How to Build Verification Skills for Multi-Agent Graph Workflows in Claude Code (2026)

Verdict: When you fan a task out across several Claude Code agents at once — a "graph" — a single unchecked error in one node can corrupt the whole output, and you will not be able to see which agent caused it until the result comes back. The fix is to give every node a verification skill it can run itself, and to pay for the smartest model you can on the reviewer node specifically. Anthropic shipped a trails of built-in skills (/verify, /code-review, /simplify) in July 2026 and published exactly how its own team wires them together, so you do not have to invent the pattern from scratch. Run them chained, on Opus, on the judging node only.

Last verified: 2026-07-31

• Graph engineering splits one task across parallel agents ("nodes") connected by "edges" — much faster, but burns more total tokens than a single agent. (Anthropic blog, July 2026)
• Claude Code ships /verify, /code-review, /simplify, and /design skills; /verify and /code-review now run only when you invoke them directly (since v2.1.215). (Claude Code docs)
• Anthropic's own Claude Code team chains code-review → simplify → verify → design in their day-to-day workflow.
• The Skill Creator plugin builds tested custom skills from a prompt (/plugin install skill-creator@claude-plugins-official, Anthropic-verified).
• ViewModel: the cheap model (Haiku) over-flags; spend the judging node's budget on Opus, not Haiku.
• Cost guardrail: graphs hit rate limits far faster than single agents — Claude Code Pro ($20/mo) is not enough; budget for API/Max tier usage.

Why does a graph break differently than a loop?

A loop runs one step, verifies it, runs the next step — one agent doing one thing at a time. Slow, but honest: if something is broken, you find it as it happens.

A graph splits the same job across many agents at once. A node is one agent working on one piece in its own isolated context window. An edge is how that node's output reaches the next node. Shape-wise, the two most useful patterns are:

• Diamond — one task fans out into several parallel agents, then narrows back into one agent that merges everything.
• Fan-out / barrier (fan-in) — the same work is judged from several angles at once; nothing moves forward until every judge reports back.

The shape is what gives you speed and reach. It is also what gives graphs their failure mode: because every node only ever sees its own piece, a bad fix in one node is invisible to the others until they have all built on top of it. The end result looks wrong, the trace looks clean, and you have no easy way to point at which node started it. That is why verification in a graph is not an optional polish step — it is the thing that keeps the graph worth doing. For a deeper take on orchestrating whole agent teams like this, see our 5-layer AI agent orchestration framework.

What built-in verification loops does Claude Code already provide?

Claude Code already ships a set of bundled verification skills out of the box, so the first move is to learn what is there before you write your own. According to Anthropic's official skills documentation, the bundled skills include /doctor, /code-review, /batch, /debug, /loop, and /claude-api. As of v2.1.215, /verify and /code-review run only when you invoke them yourself (before that, Claude could auto-fire them) — this keeps long-running reviews from burning tokens without consent.

The most relevant built-in verification primitives for graph workflows are:

Built-in skill	What it does	Good for a graph?
/verify	Builds, runs, and observes the app — catches runtime errors automatically.	Yes, but only catches major errors. Does not check how code is written.
/code-review	Reviews the current diff for bugs and clean-up, optionally applies fixes. Set up as a multi-agent PR reviewer with a falsification step that tries to disprove each finding.	Strong, because each node sees only its own piece — this gives it a way to check that piece against the original spec.
/simplify	Reviews changed code for reuse, quality, efficiency, then fixes what it finds.	Yes — pairs well with /code-review per the Anthropic team.
/design	Checks the interface against the DESIGN.md file (design decisions for the product).	Yes, when the node touches UI.
Toolchaining	Claude aims to catch error codes/warnings from any tool you put in CLAUDE.md.	Yes — list your exact build/test commands so Claude does not have to infer them each run.

The same skills work across the wider ecosystem too: the SKILL.md format is cross-compatible with Cursor, Gemini CLI, Codex CLI, and Antigravity IDE per Anthropic's ecosystem, so a skill you build once will move with you.

How do you chain verification skills the way Anthropic's own team does?

You chain them. Per Anthropic's blog post, the Claude Code team's day-to-day actually chains four skills together, in order, on every change:

1. /code-review — hunts for bugs in the diff.
2. /simplify — cleans up and organizes the diff.
3. /verify — confirms end-to-end behavior actually runs.
4. Custom /design — checks the change against the product's DESIGN.md when the change touched UI.

Chaining is also how you bolt verification onto a skill you cannot modify: build a wrapper SKILL.md that invokes the original skill, then invokes your verification skill. The example Anthropic gives:

# .claude/skills/safe-refactor/SKILL.md
Run /simplify on the current diff first.
When /simplify finishes, invoke /verify-no-public-api-changes.

What used to be a habit ("I always run /verify after /simplify") becomes a contract ("/simplify always runs /verify when it finishes"). Once that contract is encoded, the chain runs the whole dev cycle by itself — you only step in when something escalates back to you. This is the same habit-turned-contract idea we describe in the AI manager skill guide: the highest-leverage move in 2026 is supervising AI agents, not doing their work.

How do you build a custom verification skill with Skill Creator?

You build it with the Skill Creator plugin — an Anthropic-verified plugin (~376k installs as of July 2026 per the plugin page) that creates tested skills from a prompt instead of a one-shot blob of prose. Install it via:

/plugin install skill-creator@claude-plugins-official

Invocation: /skill-creator, then pick one of four modes (Create, Eval, Improve, Benchmark). Under the hood four composable agents do the work: an Executor that runs the skill against eval prompts, a Grader that scores outputs against expectations, a Comparator that does blind A/B comparisons between skill versions, and an Analyzer that suggests targeted improvements.

Tell it what verification you want and be explicit. For a reviewer that checks finished work against the original ask, prompt it like:

Create a new skill that reviews the finished diff against the original feature requirements in this repo, and flags any place where the implementation does not match the spec. Be comprehensive — deep pass, not a quick one. Include reference checks and scripts.

Because Skill Creator generated it, the skill comes back with references/ and scripts/ subdirectories that were structured and tested as part of the process — which is what makes it easier to trust than ad-hoc prompting. If you want a worked example of packaging an entire workflow into a portable skill file, our portable AI skill file guide walks through the same pattern for a different domain.

When should a verification skill be standalone, embedded, or "second opinion"?

Not all verification skills want to fire the same way. There are three useful kinds, and the choice is a real design decision.

1. Standalone skills — run only when you invoke them yourself. Built for a deep pass on already-finished output. The reason you do not want a standalone skill firing after every run is that you would be burning tokens on a heavy review of work that is not even done yet. A standalone skill is the right shape for a "thermonuclear" code review — it fans out a set of agents and sends each one through the code from a different angle, then gathers every finding in one place so fixes can happen together. Exactly the kind of review you only run once the app is finished.

2. Embedded skills — fire automatically as part of the workflow. A skill that kicks in whenever, say, someone asks for a new feature. It checks that every component being created follows the rules you laid out in the skill, and it will not let the implementation finish until it has been checked against those rules. You can build embedded skills yourself, but you cannot easily take a pre-installed one (like the /verify skill) and make it auto-fire — those instructions live inside the product and are not yours to touch. To make your own embedded skill, tell Skill Creator to "run verification steps after every feature implementation" and to "test the feature from start to finish so it catches whether the new work broke anything that was already working."

Embedded verification is the kind of skill that, baked into a node, lets the graph self-correct mid-flight. For broader coverage of agent workflows that already work this way at this layer, see our 5 AI agent workflows that replace repetitive tasks.

3. "Second opinion" skills — launch a fresh session with zero inherited context. The agent that built the thing is the worst one to review it: it judges its own work from the same context it used to build it. Claude does have a built-in advisor, but the advisor reads the chat you are currently in — so it inherits all that same context. A second-opinion skill starts a fresh Claude session using the -p (background) flag, hands it a prompt, and waits. The fresh session has seen none of the original context, gives an unbiased review, and returns a straight answer.

Two warnings with second-opinion skills:

• They are slow because they spin up an entirely separate session.
• Model choice matters more here than anywhere else, because the entire point is a smarter second read. Tell Claude explicitly to start that session on Opus, not the default Sonnet/Haiku — the judge node is the single place where saving tokens costs you the whole graph. If you want the underlying background-session mechanics, the open-source Orca parallel-coding guide covers running agents in parallel worktrees; the principle is the same.

How do you run visual browser verification inside an embedded skill?

For UI changes, Claude verifies by default using browser testing — it opens a full Chrome instance, loads the page, and takes screenshots. If you have wired up Puppeteer or Playwright, they do the same thing. The problem is that Chrome is famously memory-heavy, and re-running it over and over inside a workflow starts to cost you real wall-clock time.

The lighter alternative is chrome-headless-shell — a stripped-down build of the browser that ships as a separate binary. Per the Puppeteer headless-modes docs, chrome-headless-shell "does not match the behavior of the regular Chrome completely but is currently more performant for automation tasks where the complete Chrome feature set is not needed." Switch to it in Puppeteer with:

const browser = await puppeteer.launch({ headless: 'shell' });

You can build that directly into the embedded verification skill you create — so every feature the agent ships gets checked visually with screenshots, without you setting it up each time. The trade-off to remember: chrome-headless-shell is not a full Chrome, so do not use it for cases that depend on the complete Chrome feature set (it does not match regular Chrome's behavior exactly). Use it for the recurring "load the page, take a screenshot, compare to expectations" loop.

How do you stop model choice from quietly breaking your graph?

This is the part people get wrong: the model you pick for the reviewer node does not just decide the quality of the review — it decides the quality of the whole graph. The judging node is the one place where saving tokens costs you everything.

The pattern that will bite you: run the reviewer on the cheap model because the job "looks simple enough," watch it come back with a long list of findings, and assume it did a great job. Then run the exact same review on Opus — it flags far fewer things, which looks like the worse result. But when you read the reasoning, Opus had worked out that a lot of what the cheap model flagged were things you left there on purpose. The cheap model missed the surrounding context that made those things intentional. The "cheap" review had not saved you anything — now the review itself needs reviewing.

Inside a graph that gets worse fast: put that same cheap-review skill on every node, and you have agents burning time and tokens fixing things that were never broken, with no way to tell which node started it, because it all happened in parallel.

Node role	Sensible model	Why
Build / write node	Sonnet (or whatever fits the job)	Cheaper models are fine for most production work; you can pick per-node since each runs in its own context.
Reviewer / judge node	Opus (the strongest Claude available)	The reviewer is the one place you cannot cheap out. Wrong review = wrong graph.
Second-opinion session	Opus explicitly	The entire point is a smarter second read. Tell Claude to start that -p session on Opus.

The cost story across the graph is the opposite of what people expect: per-node cost goes down (you can pick cheaper models per job, one per node), but total token burn goes up — a whole set of agents is firing at once instead of one, so you will hit usage limits far sooner than with a single agent. The $20/mo consumer Claude Code plan is not enough; expect to be on Max or PAYG API tier for anything non-trivial.

What is the simplest way to run multi-angle review across nodes?

You cannot stuff every angle of review into one skill. Once you are reviewing something properly, you are reviewing it from several angles — security, logic, style, design — and each angle has its own way of measuring. Stuff them all into one skill and the agent gets too many directions at once and ends up getting worse, not better.

The honest pattern, which is how Anthropic itself works, is one separate skill per angle, chained together:

• /code-review — logic bugs
• /simplify — quality, reuse, efficiency
• /verify — runtime behavior end-to-end
• A custom /design skill — UI compliance with DESIGN.md

But you cannot just tell the agent to run all of them at once. What you actually need is one more skill sitting above the rest — a small orchestrator skill whose only job is to run other skills. It spins up an agent for every review skill, hands each one its skill, lets them all review in parallel in their own context windows, then pulls every finding back into one report the fixing agents can work from. Once that orchestrator exists, the only thing you ever have to say in a graph prompt is "use that one skill" — every node loads it, and the whole review fans out underneath on its own.

What this means for you

If you are using Claude Code for real work in 2026, the single highest-leverage change you can make is to stop trusting the default self-check and add a verification skill to the judge node of every graph you run. Concretely:

1. Install Skill Creator: /plugin install skill-creator@claude-plugins-official.
2. Build one embedded verification skill that checks finished work against your requirements, and tell the reviewer to run on Opus.
3. Build one second-opinion skill (using -p) for unbiased reviews on the changes that matter most — also on Opus.
4. Write one orchestrator skill that chains code-review → simplify → verify → design, one per review angle.
5. Put chrome-headless-shell in your visual verification skill instead of full Chrome for the recurring load-and-screenshot loop.
6. Budget for the higher total token burn a graph incurs — the per-node cost goes down, but the aggregate goes up. Plan your tier accordingly.

The build-fix loop is no longer the bottleneck — verification is. An agent that ships in 90 seconds is irrelevant if you then spend 10 minutes reviewing what it did. Verification skills make the review step automatic and consistent, so the speed of the graph is actually usable. This is the same shape of move we point to in How to Build an AI Agent Operating System: the agents are only as reliable as the control loop you put around them.

FAQ

Q: What is graph engineering in Claude Code? A: Graph engineering is splitting one task across multiple Claude Code agents ("nodes") connected by data paths ("edges") that run in parallel, instead of looping one agent through every step serially. The benefit is speed and reach; the cost is higher total token burn and harder-to-trace error propagation.

Q: What verification skills ship with Claude Code? A: As of v2.1.215, Claude Code bundles /verify, /code-review, /simplify, /design, /loop, /batch, /debug, and /claude-api. /verify and /code-review run only when you invoke them directly — they no longer auto-fire — so you control when the long-running checks spend tokens.

Q: Why does Anthropic's team chain verification skills instead of using one? A: Chaining lets each skill own one angle (bugs, quality, runtime, design) instead of one skill trying to be good at everything. The team's day-to-day order is /code-review → /simplify → /verify → /design. Chaining also lets you bolt verification onto any skill you can't modify, via a small wrapper SKILL.md.

Q: Should the reviewer node run on the cheapest model? A: No. The reviewer is the one node where cheaping out costs the whole graph. A cheaper model over-flags intentional choices as problems, and in a graph those wrong fixes propagate across nodes with no way to trace the origin. Run the reviewer on the strongest model you have (Opus), even if the build nodes run on Sonnet.

Q: How do you get a fresh, unbiased review on a Claude Code change? A: Use a "second opinion" skill that launches a separate Claude session with the -p (background) flag, hands it a prompt, and waits. The fresh session has not seen the build context, so it cannot fool itself into accepting the original assumptions. Tell it to start on Opus — the whole point is a smarter second read.

Q: Is the $20/mo Claude Code plan enough for graph workflows? A: Probably not. Per-node cost goes down with a graph (you pick the cheapest model that fits each job), but the aggregate token burn goes up sharply because many agents fire at once. Expect to hit rate limits far sooner than with a single agent, and plan for Max or PAYG API tier.

Sources

• Building verification loops in Claude Code with skills — Anthropic, July 22, 2026 (the official source for the chaining pattern, verification-loop definition, and Anthropic's internal workflow).
• Extend Claude with skills — Claude Code docs — official bundled-skills list, /verify + /code-review now run only when invoked (v2.1.215).
• Skill Creator plugin page — Anthropic-verified, ~376k installs, four modes (Create/Eval/Improve/Benchmark) with Executor/Grader/Comparator/Analyzer agents.
• Code Simplifier plugin page — Anthropic-verified simplification agent, 341k installs.
• Headless mode — Puppeteer docs — chrome-headless-shell is faster for automation; headless: 'shell' opt-in; full Chrome is the default.
• Anthropic's Claude Code adds self-review skills — Mike Gingerich, July 26, 2026 — independent confirmation of the four /code-review, /simplify, /verify, /design commands and the July 21-24, 2026 release window.

Updates & Corrections

• 2026-07-31 — First published. Verified built-in skill names, install command, and the Anthropic chaining pattern against the official Claude Code docs and Anthropic's July 22, 2026 blog post. chrome-headless-shell behavior verified against the Puppeteer headless-modes docs.

---