Writing code is something AI already does for you. Accepting the work is still your job. Whether a chunk of code is actually correct has been AI’s blind spot — you read it line by line at the end, and that checkpoint stalls a lot of teams.
On July 22, Anthropic filled that gap too. They taught Claude to stop handing over work the moment it’s written and instead run four checks on itself: /code-review to hunt bugs, /simplify to strip bloat, /verify for end-to-end validation, and /design to check the visual implementation. All four pass, then it ships.
AI has moved from “can write code” to “can review its own code.”
The Verification Loop: the Missing Piece of the Agent Circuit
Anthropic calls the mechanism a verification loop — an iterative process in which Claude checks and attempts to repair its own work. What changed is the shape of the agent’s circuit:
-
Before: gather context → take action → human checks.
-
Now: gather context → take action → verify automatically → repair → verify again.
Checking and fixing moved inside the loop; the human is reached only at the end. Some checks Claude already does — deterministic signals like type checkers, linters, test failures, and runtime exceptions are legible to it, and it fixes what they flag unprompted.
The hard part was always the other class: did the UI come out right, does the user flow hold up, did this change bury a landmine nobody can see? Those checks used to belong to humans performing the same inspection dozens or hundreds of times. Anthropic’s solution: write down every check you would do manually anyway, package each one as a Skill, and let Claude run them automatically on every task.
The Four Self-Check Skills the Claude Code Team Uses Daily
/code-review — the tireless reviewer
Audits the changes, surfaces potential bugs, and returns review comments. Effectively a reviewer on your team who never gets tired.
/simplify — subtraction as a feature
Cleans up the diff of the current change: deletes convoluted implementations and simplifies structure. It never adds features — it removes redundancy, pushes future maintenance costs down. Most tooling piles code upward; a tool that voluntarily subtracts is rare.
/verify — end-to-end, for real
Actually runs the thing and confirms the feature works — as opposed to looking finished.
/design — visual conformance
Only enters the field when UI changed. It reads the repo’s DESIGN.md and checks your visual implementation against it, item by item.
These four did not appear from nowhere. Underneath, Claude Code already provides a verification layer: the built-in /verify can launch your app and observe changes, and if you document build and test commands in CLAUDE.md, it follows them. The team’s four Skills add their own process step on top of that shared foundation.
How to Write Your Own Verification Skill
Anthropic’s method is disarmingly simple: write down, in plain language, the step you perform manually every single time — as if briefing a new hire on their first day. Their example: any change that drops a database field without a matching data migration gets rejected. No generic linter will ever catch that; it is your project’s house rule. Any red line you currently hold only by staring manually is worth turning into a loop.
Mechanically: drop a Markdown file into .claude/skills/ — the simplest verification Skill is a few lines of instructions plus a body. Then run one fresh task and confirm the check actually fired; adjust if not.
Verification Is Not All-or-Nothing: Four Levels of Automation
-
Standalone — you remember to invoke it manually.
-
Embedded — wired into a task’s flow so it runs along.
-
Chained — several verification Skills linked into a chain that runs one after another automatically.
-
On every PR — the strictest tier: every submission passes through automatically.
Anthropic calls the middle transition “from habit to contract.” “I remember to run /verify after /simplify” is a personal habit; chained, it becomes “when /simplify completes, /verify fires” — a fixed contract. The chain walks the development loop on its own and returns only when a human decision is genuinely needed. Longer chains are more reliable, with one official caveat: chained verification burns real tokens. Prove stability first, then extend step by step.
AI Coding Is Rotating From Generation to Verification
Behind the four Skills, the competition is changing tracks. The Claude Code creator put it plainly in June: in an era when strong models run autonomously for long stretches, self-verification is the key to running longer while staying aligned with what you actually wanted. The sturdier the verification, the further agents dare to run — and the less you babysit.
Prompts were the old answer, and prompts have a ceiling: they serve one task, then you start over. A common misconception deserves correcting here: a Skill is not a slab of Markdown prompt. It is a capability module — instructions, file structures, scripts, tool calls, configuration, and a whole workflow — your team’s checks, design standards, and scar tissue packaged into something on call. Notably, Skills are turning from a Claude Code feature into a cross-vendor open standard: GitHub Copilot, Cursor, OpenAI Codex, and Gemini CLI have all adopted the same format, so the Skills your team builds won’t be locked to one tool.
Which leads to an uncomfortable truth: the same Claude can deliver several-fold different productivity depending on the team. The gap is not the model — it is the workflow. Did you write your checks as Skills? Did you build a verification loop? Did you let the agent close its own feedback circuit?
An agent’s capability is an addition problem: model + tools + verification mechanism + workflow. The model term converges across vendors. The other three belong entirely to you.
We spent years teaching AI to write code. Now we start teaching it to check whether what it wrote is right. The day “one last manual review before clocking out” can be handed to AI with real confidence is the day it starts carrying real weight for you.
