Capturing Tui Visual Proof
Captures reviewable before-and-after visual proof from the real Letta Code Ink TUI. Use when a Letta Code PR changes interactive CLI rendering or behavior and needs terminal screenshots or GIFs in its PR body.
Get the complete skill folder, including its scripts and reference files.
When to use this skill
Use Capturing Tui Visual Proof when an AI agent needs a reusable SKILL.md workflow for this job: Captures reviewable before-and-after visual proof from the real Letta Code Ink TUI. Use when a Letta Code PR changes interactive CLI rendering or behavior and needs terminal screenshots or GIFs in its PR body.
When not to use it
Skip Capturing Tui Visual Proof when the task is outside the creativity category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.
How to install
Where will you use it?
mkdir -p ~/.claude/skills/capturing-tui-visual-proof # Save SKILL.md to ~/.claude/skills/capturing-tui-visual-proof/SKILL.md
- Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/capturing-tui-visual-proof/SKILL.md. For a shared project, commit the folder at .claude/skills/capturing-tui-visual-proof/ instead.
- Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
- For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.
Full install guide for Claude, Cursor, and Codex →
Try a starter prompt
After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.
Use the Capturing Tui Visual Proof skill for this task: Use Capturing Tui Visual Proof when this documented workflow matches the task. Confirm any required inputs or files before making changes.
What supports this recommendation?
71/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.
- Documentation
- 77/100
- Practical detail
- 68/100
- Source evidence
- 63/100
- Source signals
- 72/100
Model compatibility evidence
- claudeuntested
No model-specific signal or recorded compatibility test was found.
- chatgptuntested
No model-specific signal or recorded compatibility test was found.
- geminiuntested
No model-specific signal or recorded compatibility test was found.
- copilotuntested
No model-specific signal or recorded compatibility test was found.
- llamauntested
No model-specific signal or recorded compatibility test was found.
- perplexityuntested
No model-specific signal or recorded compatibility test was found.
- mistraluntested
No model-specific signal or recorded compatibility test was found.
- grokuntested
No model-specific signal or recorded compatibility test was found.
Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.
What this skill does
# Capturing TUI Visual Proof
Record the production TUI through `bun run src/index.ts`. Do not substitute a mocked Ink component, text fixture, generated image, or headless output for the real terminal workflow.
## Choose the Proof
- Static rendering change: capture before/after screenshots. - Interaction or state transition: capture before/after GIFs. - Timing or animation claim: record continuously; do not hide the interval that proves the claim.
Keep every variable except the code revision identical: terminal dimensions, theme, agent, model, prompt, fixtures, and CLI flags.
## Prepare Exact Before and After Checkouts
Use the PR's base SHA rather than current `main`, which may have advanced:
```bash repo=$(git rev-parse --show-toplevel) pr=1234 # replace with the PR number base=$(gh pr view "$pr" --json baseRefOid --jq .baseRefOid) before=/tmp/letta-code-pr-$pr-before
rm -rf "$before" git clone --shared --no-checkout "$repo" "$before" git -C "$before" checkout --detach "$base" ```
For a dependency-neutral change, reuse the current checkout's dependencies:
```bash ln -s "$repo/node_modules" "$before/node_modules" ```
If the PR changes dependencies, install them independently in each checkout instead. Never install through a symlinked `node_modules`.
## Make the Interaction Deterministic
Use the same existing test agent and a new conversation for both runs. For skill-loading proof, create a small temporary project skill with a fixed reply:
```bash proof_skills=/tmp/letta-code-pr-$pr-skills mkdir -p "$proof_skills/pr-proof-demo" cat > "$proof_skills/pr-proof-demo/SKILL.md" <<'SKILL' --- name: pr-proof-demo description: Loads deterministic instructions for TUI visual proof. ---
After loading this skill, reply exactly: `Skill loaded.` SKILL ```
Dry-run the flow in each checkout before recording:
```bash bun run src/index.ts \ --agent "$AGENT_ID" \ --new \ --no-system-info-reminder \ --reflection-trigger off \ --skills "$proof_skills" \ --skill-sources project ```
Do not add `--model` to a shared agent merely to accelerate proof; that can persistently change its model configuration.
## Record with VHS
Install [VHS](https://github.com/charmbracelet/vhs) if unavailable. Record at roughly 960px wide, 10-15 fps, and a legible font size. Produce MP4 while iterating and GIF for the PR.
Create one tape per checkout from this pattern:
```text # Replace CHECKOUT, AGENT_ID, and SKILLS_DIR before running. Output "/tmp/pr-proof.gif" Output "/tmp/pr-proof.mp4" Set Shell "zsh" Set Width 960 Set Height 720 Set FontSize 14 Set Framerate 12 Set TypingSpeed 20ms Set Theme "Catppuccin Mocha" Set CursorBlink false
Hide Type "clear && cd <CHECKOUT> && bun run src/index.ts --agent <AGENT_ID> --new --no-system-info-reminder --reflection-trigger off --skills <SKILLS_DIR> --skill-sources project" Enter Sleep 20s Show Sleep 1s Type "Use the pr-proof-demo skill, then follow its instructions." Sleep 500ms Enter Sleep 1s Hide Sleep 45s Show Sleep 4s ```
Run it with:
```bash vhs validate /tmp/pr-proof.tape vhs /tmp/pr-proof.tape ```
For a still, run the same real interaction and add `Screenshot /tmp/pr-proof.png` after the final state appears.
`Hide` may remove startup or model latency from a rendering proof while the real process continues running. First dry-run the command and choose generous waits. Never use hidden time to skip the interaction or state transition being claimed.
Before publishing, check that the recording contains no secrets, tokens, private paths, or unrelated conversation history.
## Inspect Every Recording
Open the GIF and inspect frames across its full duration, not just its first or last frame:
```bash mkdir -p /tmp/proof-frames ffmpeg -y -i /tmp/pr-proof.gif -vf 'fps=1' \ /tmp/proof-frames/frame-%02d.png ```
Verify that:
- the initial, interaction, and final states are legible; - before reproduces the original bug; - after demonstrates the fix without hiding surrounding behavior; - both recordings use equivalent inputs and layout.
## Publish to the PR
Copy only final proof assets into the branch:
```bash asset_dir=.github/pr-assets/PR-$pr mkdir -p "$asset_dir" cp /tmp/before.gif "$asset_dir/before.gif" cp /tmp/after.gif "$asset_dir/after.gif" ```
Commit and push the assets, then embed full-SHA-pinned same-origin URLs:
```bash sha=$(git rev-parse HEAD) git remote get-url origin ```
```markdown | Before | After | | --- | --- | |  |  | ```
Use `github.com/OWNER/REPO/raw/...`, not `raw.githubusercontent.com`, and use a full commit SHA rather than a branch or short SHA. Fetch the final PR body and download both embedded URLs to confirm they return the committed files.
Keep tapes, temporary skills, MP4s, frames, and detached checkouts out of the PR.
Intended uses
- Use Capturing Tui Visual Proof when this documented workflow matches the task.
Implementation notes
- Review the source instructions and adapt inputs before running the workflow.
Try it, then tell us how it went
A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.