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

> Source: <https://corti.com/review-your-ais-code-before-it-ever-hits-github-tuicr-gh-dash-claude-code-copilot-cli/>
> Published: 2026-08-02 07:27:03+00:00

# 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)