AI Code Is Fast, But Can You Review It? The show-me Skill for Scalable Code Review

Traditional Code Review Is Obsolete for AI-Generated Code

After adopting Claude Code and Codex, teams see code output speed increase dramatically—junior engineers can submit thousands of lines in half a day. However, speed does not guarantee quality, and review becomes the primary bottleneck. Facing hundreds or thousands of new lines across a dozen files, reviewers cannot mentally reconstruct call chains and data flows by scanning raw git diff output.

Human-written code tends to be locally incremental, so line-by-line diffs roughly follow the author's thought process. In contrast, LLMs emit entire blocks of code at once. The reviewer's real need is to answer three questions immediately:

Which core call chains are affected by this change?

Does the new code violate existing module boundaries?

Do component data flows still match the original design spec?

HumanLayer's open-source show-me skill directly targets this comprehension problem.

What Is show-me?

show-me is a behavioral specification for AI coding agents. Its core rule is two sentences:

Help the user understand the current topic visually. Skip the preamble and keep prose brief. Pick the smallest view that makes the key point clear.

In practice: drop all pleasantries, minimize text, and present only the minimal view that explains the logic.

Four Structured Views for Code Review

1. Compact Call Tree

When reviewing a PR, ask the AI to output the call tree for the key execution path instead of reading hundreds of lines of business logic. Each indentation level represents one call depth. A reviewer can glance at the tree and confirm critical branches—for example, whether an order flow passes through risk-control and inventory checks.

2. Shallow File Tree with Responsibilities

AI often places files incorrectly when implementing new features. show-me requires a shallow file tree annotated with responsibilities at submission time:

src/
├── domain/order/         # Domain entities & business rules
├── infrastructure/       # Database & external interface implementations
└── interfaces/api/       # Controller routing & parameter parsing

If the AI introduces an infrastructure dependency inside domain, the responsibility tree immediately exposes the violation.

3. Mermaid Sequence Diagrams

For complex flows spanning multiple services or asynchronous messages, code is scattered across modules. show-me uses Mermaid to describe interaction sequences. Reviewers can verify data-flow direction against the design doc without reading low-level details.

4. Semantic Diff

Standard git diff mixes blank lines, comments, and formatting changes. show-me extracts only changes that affect business state:

on(save)
- directCommit()
+ if isDirtyState
+   validateSchema()
+   batchCommit()

This view shows only control-flow modifications, eliminating irrelevant formatting noise.

Using show-me in Claude Code and Codex

Add the specification file to Git so every team member gets it automatically on pull.

Claude Code: create .claude/skills/show-me/SKILL.md in the project root.

Codex or generic agent frameworks: create .codex/skills/show-me/SKILL.md or .agents/skills/show-me/SKILL.md.

Global install via CLI:

npx skills add humanlayer/skills --skill show-me -g

Practical Recommendation

As code generation accelerates, the quality gate inevitably shifts to review. Instead of relying on humans to hunt through verbose diffs, require the AI to deliver call trees, file-responsibility maps, and sequence diagrams before submission. Making change logic visually explicit is the only way review throughput can keep pace with AI output speed.