> ## Content Index
> Fetch the complete content index at: https://corti.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Review Your AI's Code Before It Ever Hits GitHub: tuicr + gh-dash + Claude Code / Copilot CLI
- URL: https://corti.com/review-your-ais-code-before-it-ever-hits-github-tuicr-gh-dash-claude-code-copilot-cli/
- Published: 2026-08-02T07:27:03.000Z
- Updated: 2026-08-02T07:27:03.000Z
- Author: Sascha Corti

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:

- [**tuicr**](https://tuicr.dev/?ref=corti.com) — 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.
- [**gh-dash**](https://www.gh-dash.dev/?ref=corti.com) — a `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

![](https://corti.com/content/images/2026/08/tuicr-1.png)

tuicr is a single static binary (written in Rust). Pick one:

```bash
# 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

![](https://corti.com/content/images/2026/08/gh-dash.png)

gh-dash is a `gh` extension, so the GitHub CLI is a prerequisite:

```bash
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:

```bash
gh dash

```

### An agent CLI

Either (or both):

```bash
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:

```bash
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:

1. `**:submit**` — pushes your inline comments to GitHub (or GitLab) as a *real* PR review, through the authenticated `gh`/`glab`CLI.
2. **`--stdout`** — pipes the review as markdown to stdout for scripting or CI.

**`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:

```bash
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:

```bash
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:

```bash
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:

```bash
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:

```bash
mkdir -p ~/.copilot/skills
cp -r /tmp/tuicr/skills/tuicr ~/.copilot/skills/tuicr

```

or use the built-in management commands:

```bash
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:

```bash
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:

```yaml
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:

```yaml
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)