AI coding agents have changed who writes most of the code in my PRs — but they haven't changed who is accountablefor it. The weakest point in an agent-driven workflow is the moment between "the agent says it's done" and "I open a pull request." Pushing unreviewed agent output to GitHub and reviewing it there means my teammates become the first line of defense against my agent's mistakes.
This post describes a workflow that fixes that, using two terminal tools:
— a TUI for code review with vim keybindings. It renders a GitHub-style diff in your terminal, lets you leave line-level comments, and can either push a real PR review to GitHub or hand structured markdown back to your coding agent.tuicr— a** gh-dash**gh
CLI extension that gives you a rich terminal dashboard for PRs and issues, so the GitHub side of the loop never requires a browser either.
The loop looks like this:
Claude Code / Copilot CLI writes code
│
▼
tuicr: I review the diff locally, leave inline comments
│
├── comments flow back to the agent → agent fixes → re-review
│
▼
commit + push + PR (created by the agent via gh)
│
▼
gh-dash: track, check out, re-review, and merge PRs — all in the terminal
Both DevOps Toolbox videos that inspired this post are worth watching: The Holy Grail of Code Review TUIs covers tuicr and the agent review loop, and I'm never going back to GitHub UI ever again. covers gh-dash.
Part 1: Install the tooling #
tuicr
tuicr is a single static binary (written in Rust). Pick one:
curl -fsSL tuicr.dev/install.sh | sh
brew install agavra/tap/tuicr
cargo install tuicr
mise use github:agavra/tuicr
nix run github:agavra/tuicr
It auto-detects git, jj, and Mercurial repos. For the GitHub integration (:submit
, tuicr pr <n>
) you need an authenticated gh
CLI; for GitLab, glab
.
gh-dash
gh-dash is a gh
extension, so the GitHub CLI is a prerequisite:
brew install gh # or your platform's package manager
gh auth login
gh extension install dlvhdr/gh-dash
Install a Nerd Font for the icons (e.g. brew install --cask font-fira-code-nerd-font
) and set it in your terminal. Then run:
gh dash
An agent CLI
Either (or both):
npm install -g @anthropic-ai/claude-code # Claude Code
npm install -g @github/copilot # GitHub Copilot CLI
Part 2: The core skill — reviewing agent output with tuicr #
tuicr can review anything a diff can describe:
tuicr # interactive commit selector
tuicr -w # uncommitted working-tree changes ← the agent-review sweet spot
tuicr -r main..HEAD # a commit range
tuicr pr 125 # a GitHub PR (via gh)
tuicr mr 125 # a GitLab MR (via glab)
tuicr -w
is the one I use most: the agent has just finished editing, nothing is committed, and I want to read every hunk before anything becomes permanent.
Navigation is vim-native: j
/k
to scroll, Ctrl-d
/Ctrl-u
for half-pages, {
/}
to jump between files, [
/]
between hunks, g
/G
for top/bottom, /
to search, {N}G
to jump to a line. ?
shows help.
Commenting mirrors the GitHub PR review model:
| Key | Action |
|---|---|
c |
Comment on the current line |
v / V then c |
Select a range, comment on it |
C |
File-level comment |
;c |
Review-level (overall) comment |
Each comment gets a classification — issue, suggestion, note, or praise — which matters later, because the agent can prioritize issues over notes.
When the review is done, tuicr has three export targets:
— pushes your inline comments to GitHub (or GitLab) as a**:submit*** real*PR review, through the authenticatedgh
/glab
CLI.— pipes the review as markdown to stdout for scripting or CI.--stdout
** y or :clip** — copies a structured markdown block to the clipboard, with numbered comments anchored to files and lines:
I reviewed your code and have the following comments. Please address them.
1. `src/auth.rs` - Consider adding unit tests
2. `src/auth.rs:42` - Magic number should be a named constant
3. `src/auth.rs:50-55` - This block could be refactored
Paste that straight into Claude Code, Copilot CLI, Codex, or Cursor and the agent has precise, addressable feedback.
tuicr also tracks review sessions across invocations: revisit a PR and it preselects only the commits you haven't reviewed yet.
Part 3: The skills — wiring tuicr into Claude Code and Copilot CLI #
This is where the workflow stops being copy/paste and becomes a closed loop. The tuicr repository ships an agent skill at skills/tuicr/SKILL.md. Skills are the (now cross-vendor)
SKILL.md
convention: a directory containing a markdown file with YAML frontmatter (name
, description
) plus instructions that get injected into the agent's context when the skill is invoked.### What the tuicr skill teaches the agent
The skill's description: "Use tuicr's review CLI to read and add comments in active TUI review sessions, and launch tuicr in tmux, Zellij, or Herdr when a user needs an interactive review pane."
Concretely, it instructs the agent to:
Launch tuicr in a split pane of your terminal multiplexer (tmux, Zellij, or Herdr) when you ask for a review — so the diff opens next to the agent's chat, not instead of it. If no multiplexer is running, the agent asks you to launch tuicr manually.Not reach for tuicr for rawgit diff
questions or when you've asked for a different workflow.
Distinguish two review modes: a user-led review, where you write the comments and the agent only retrieves them; and an agent review, where the agent critiques an AI-generated patch itself and — after confirming with you — adds its own findings into the session:
tuicr review add --repo /path/to/repo --session <slug> \
--target-file src/auth.rs --line 42 --type issue \
--username "Claude" "Magic number should be a named constant"
Poll your comments (roughly every 30 seconds during an active review) and pull them in without you copying anything:
tuicr review comments --repo /path/to/repo --session <slug>
Comments come back with path, line numbers, classification, and lifecycle state.
Attach to existing sessions rather than spawning duplicates:
tuicr review list --repo /path/to/repo # sessions for this repo
tuicr review list --all # all sessions
Installing the skill for Claude Code
Claude Code discovers skills in .claude/skills/
(per-project) or ~/.claude/skills/
(personal). Copy the skill out of the tuicr repo:
git clone --depth 1 https://github.com/agavra/tuicr /tmp/tuicr
mkdir -p ~/.claude/skills
cp -r /tmp/tuicr/skills/tuicr ~/.claude/skills/tuicr
Inside Claude Code, the skill triggers automatically when you ask for a review, or explicitly with /tuicr
. A session then looks like:
> Refactor the auth module to remove the session-token duplication.
... agent edits files ...
> /tuicr — open a review of your changes
... tuicr opens in a tmux split with the working-tree diff ...
You review in the right pane with full vim navigation, drop c
comments as you go, and the agent picks them up and starts fixing — no clipboard involved. Re-run the review until the diff is clean.
Installing the skill for Copilot CLI
Copilot CLI reads the same SKILL.md
format from several locations — and notably, ** .claude/skills is one of them**, so a repo-level skill serves both agents at once. Per
- Project-level:
.github/skills/
,.claude/skills/
,.agents/skills/
- Personal:
~/.copilot/skills/
,~/.agents/skills/
Either copy the directory:
mkdir -p ~/.copilot/skills
cp -r /tmp/tuicr/skills/tuicr ~/.copilot/skills/tuicr
or use the built-in management commands:
copilot skill add /tmp/tuicr/skills/tuicr # from a file, URL, or directory
copilot skill list
Inside a Copilot CLI session, /skills list
shows what's loaded, /skills reload
refreshes mid-session, and /tuicr
invokes the skill explicitly — same slash-name convention as Claude Code.
Related skills on the GitHub side
Two adjacent facts worth knowing while you're setting this up:
- Anthropic maintains a public catalog of agent skills at
anthropics/skills, and GitHub curates Copilot-flavored ones ingithub/awesome-copilot— the same
SKILL.md
format throughout. - As of July 29, 2026,
Copilot code review on github.com also reads agent skills from.github/skills/
(GA announcement). So a coding-standards skill you write for the local loop can double as review context for Copilot's server-side PR reviews.
Part 4: The full loop, end to end #
Here's the workflow I run, with Claude Code as the example (Copilot CLI is symmetric):
1. Start in tmux. The skill needs a multiplexer to open the review pane:
tmux new -s feature-auth
claude
2. Let the agent build. Describe the task; the agent edits the working tree.
3. Review before anything is committed. Ask for a review (or /tuicr
). tuicr opens in a split with -w
semantics — the uncommitted diff. Read every hunk. Mark real problems as issue
, style thoughts as suggestion
or note
, and yes, use praise
— it tells the agent what to preserve.
4. Let the comments flow back. The agent polls the session, reads your classified comments, and fixes. Repeat 3–4 until you'd sign your name to the diff. (Without the skill, the manual fallback is y
in tuicr and paste into the chat — same information, more friction.)
5. Ship it. Have the agent commit and open the PR:
> Commit this as "refactor(auth): deduplicate session token handling"
and open a PR against main using gh.
6. Manage the PR in gh-dash. Run gh dash
. Your dashboard is driven by ~/.config/gh-dash/config.yml
, where sections are just GitHub search filters:
prSections:
- title: My Pull Requests
filters: is:open author:@me
- title: Needs My Review
filters: is:open review-requested:@me
- title: Agent PRs
filters: is:open author:@me label:ai-assisted
With a PR selected, the defaults cover the whole lifecycle: d
shows the diff in your pager, C
checks the PR out locally (gh pr checkout
), c
comments, v
approves, u
updates the branch, w
watches checks (gh pr checks --watch
), W
marks ready-for-review, m
merges, x
/X
close/reopen, a
/A
assign/unassign. Since v3.10.0, mutating commands prompt for confirmation.
7. Close the loop: launch tuicr from gh-dash. gh-dash lets you bind keys to arbitrary shell commands with template variables — which means one keystroke can take you from a PR row in the dashboard into a full tuicr review of that PR:
keybindings:
prs:
- key: T
name: review in tuicr
command: >
cd {{.RepoPath}} && tuicr pr {{.PrNumber}}
Now reviewing a teammate's (or your own agent's) PR is: gh dash
→ arrow to the PR → T
→ vim-review → :submit
. The review lands on GitHub as real inline comments, and you never opened a browser.
Why this ordering matters #
The point of this stack is where the review happens. Reviewing in the terminal, before the push, means:
The agent's first draft is never the PR. Reviewers on GitHub see code that has already survived a line-by-line human pass.Feedback is structured, not vibes. Classified, line-anchored comments are something an agent can act on deterministically — "fix issues 1 and 3, skip note 2" works.The tools compose instead of competing. tuicr owns the diff-and-comment loop;gh
/gh-dash own the GitHub state machine; the skill file is the only glue, and the sameSKILL.md
serves Claude Code, Copilot CLI, and (in.github/skills/
) even Copilot's server-side code review.
Accountability for AI-generated code shouldn't be outsourced to your teammates' patience. With tuicr and gh-dash, the review moves to the cheapest possible point — your own terminal, before the push — and the agents are wired to listen.
References #
- tuicr — tuicr.dev·github.com/agavra/tuicr·skills/tuicr/SKILL.md - gh-dash — gh-dash.dev·selected-PR keybindings·custom keybindings - Copilot CLI agent skills — GitHub Docs - Copilot code review skills GA — GitHub Changelog, 2026-07-29