Review Your AI's Code Before It Ever Hits GitHub: tuicr + gh-dash + Claude Code / Copilot CLI

A new workflow using tuicr, gh-dash, and Claude Code or GitHub Copilot CLI enables developers to review AI-generated code locally before pushing to GitHub, preventing unreviewed agent output from reaching teammates. tuicr, a Rust-based terminal UI with vim keybindings, allows line-level comments and can push reviews to GitHub or return structured markdown to the agent for fixes, while gh-dash provides a terminal dashboard for tracking and merging PRs. The workflow addresses the accountability gap in agent-driven development by making the developer the first line of defense.

Review Your AI's Code Before It Ever Hits GitHub: tuicr + gh-dash + Claude Code / Copilot CLI AI coding agents have changed who writes most of the code in my PRs — but they haven't changed who is accountable for 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 https://www.youtube.com/watch?v=6cqVzgVQJfE&ref=corti.com covers tuicr and the agent review loop, and I'm never going back to GitHub UI ever again. https://www.youtube.com/watch?v=Z-3dUHDnkEI&ref=corti.com covers gh-dash. Part 1: Install the tooling tuicr tuicr is a single static binary written in Rust . Pick one: install script curl -fsSL tuicr.dev/install.sh | sh Homebrew brew install agavra/tap/tuicr Cargo cargo install tuicr mise / nix 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 authenticated gh / 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 https://github.com/agavra/tuicr/blob/main/skills/tuicr/SKILL.md?ref=corti.com . 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 raw git 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 GitHub's docs https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-skills?ref=corti.com : - 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 https://github.com/anthropics/skills?ref=corti.com , and GitHub curates Copilot-flavored ones in github/awesome-copilot https://github.com/github/awesome-copilot/blob/main/docs/README.skills.md?ref=corti.com — 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 https://github.blog/changelog/2026-07-29-copilot-code-review-agent-skills-and-mcp-now-generally-available/?ref=corti.com . 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 same SKILL.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 https://tuicr.dev/?ref=corti.com · github.com/agavra/tuicr https://github.com/agavra/tuicr?ref=corti.com · skills/tuicr/SKILL.md https://github.com/agavra/tuicr/blob/main/skills/tuicr/SKILL.md?ref=corti.com - gh-dash — gh-dash.dev https://www.gh-dash.dev/getting-started/?ref=corti.com · selected-PR keybindings https://www.gh-dash.dev/getting-started/keybindings/selected-pr/?ref=corti.com · custom keybindings https://www.gh-dash.dev/configuration/keybindings/?ref=corti.com - Copilot CLI agent skills — GitHub Docs https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-skills?ref=corti.com - Copilot code review skills GA — GitHub Changelog, 2026-07-29 https://github.blog/changelog/2026-07-29-copilot-code-review-agent-skills-and-mcp-now-generally-available/?ref=corti.com