MemoryLake
Back to all articles
NewsNovember 17, 2026·12 min read

How Does the Claude Code Team Verify Claude's Work? What /verify Saves for the Next Run, Why Each Item on Their Checklist Has a Trigger, and How Review Rounds Build on Earlier Ones (2026)

Last month a change broke session resume in your app. Someone found it, fixed it, and wrote a short note in the incident channel. Three weeks later, a different change touched the same storage code, and nobody remembered the note. Claude reviewed the diff, the tests passed, and the same kind of bug shipped again.

The Claude Code team at Anthropic wrote about exactly this problem on November 16, in a post on the claude.dev blog about how the team verifies Claude's work. One line from it is the reason this guide exists. The team keeps a reliability checklist, and Claude checks only the items that match a change, "so nobody has to memorize past outages."

Most of the post is about test types. This guide focuses on the other half: what the team writes down so verification gets better over time. That includes what /verify saves for the next run, how the checklist is structured, how review rounds build on each other, and how missed bugs become rules.

Why verification decides how much you can delegate

The post opens with the stakes: "Verification loops are the building block that lets you delegate more work to Claude." Without them, it says, you can only run one or two Claudes at a time, because you have to check everything yourself.

It also makes a point about cost. Tests, benchmarks, and specs used to be expensive to write. Now an agent can produce them, and once written, they run as software, so they can run often without spending many additional tokens.

The part that connects verification to memory comes next. The post says you can close the loop "by using the results to improve the agent’s performance on that task." Its example: if an agent repeatedly fails a test that checks logs for user data, "you can create a hook or a more explicit rule in your CLAUDE.md to avoid future issues."

That's the theme of everything below. A verification result is useful once. A verification result that turns into a recorded rule is useful every time after.

The three test types the team recommends

The post names three test types worth investing in, and explains why each is hard for an agent to fool.

End-to-end tests. "If you have to focus on one test type, pick end-to-end." These describe real user flows, and either the whole feature works or it doesn't.

Property tests. You write a statement you think can't fail, and a library generates thousands of inputs trying to prove otherwise. The post's examples include round-trip encoding, invariants, idempotency, and equivalence. The point is to use edge cases that weren't created with the same bias as the agent that wrote the code.

Differential tests. Run the old system and the new one on the same inputs. If results differ, there's a bug or a breaking change. These suit migrations where behavior should stay the same.

It also names two failure modes to avoid. Flaky tests train an agent to rerun them instead of fixing the code. Slow tests mean fewer runs, which makes problems harder to pinpoint.

What /verify does, and what it saves

The team's first rule is that running the app matters more than tests: "You wouldn't ship an iOS change without trying it in a simulator, and the same goes for Claude."

To make that repeatable, the post says to "create a skill called verify" in a .claude/skills/ folder in your repository, "as close to the relevant code as you can". It adds that Claude knows to use the verify skill before committing changes.

Claude Code also ships a bundled /verify. The skills documentation describes it as a way to "Build and run your app to confirm a code change does what it should, without falling back to tests or type checks". It works without setup by inferring how to launch your project from its type and from files like your README, package.json, or Makefile. The documentation is candid about the limit of that: "That inference gets unreliable for projects that need anything beyond a standard launch: a database, an env file, a graphical session, a multi-step build." That's exactly the kind of project where writing the steps down pays off.

The memory part is what happens after a successful run. According to the documentation, "/verify can also record its own recipe." When it has to build and drive your app without a recorded recipe, "it writes what worked to .claude/skills/verify/SKILL.md at the repo root, or in the touched package directory in a monorepo, so later runs and other agents follow the same steps."

That's a small, specific kind of learning. The first successful run figures out the launch steps. Every later run follows them instead of rediscovering them. Two more details matter:

  • The recorded skill takes over. "At the repo root, the recorded skill replaces the bundled /verify."
  • It doesn't churn. "Claude edits the recorded file only when it steered a run wrong, such as a command that failed or a missing step, so you can commit the file without per-session diffs."

A related bundled skill, /run-skill-generator, records the recipe deliberately. The documentation says it gets your app running from a clean environment, captures the install commands, env vars, and launch script, and commits them as a per-project skill. After that, /run, /verify, and other agents in the repository follow it. The documentation's advice on upkeep: "Run /run-skill-generator once per project, and again if the build or launch process changes."

When Claude runs the verify skill before a commit

The documentation describes one more piece. "When a session starts with a skill named verify or simplify in place, Claude Code's commit instructions tell Claude to run it right before each commit, except for changes to docs or tests." This requires Claude Code v2.1.286 or later.

The conditions are specific. The skill has to load from a supported location, and the recipe /verify records at your repo root counts. The bundled /verify and /simplify, plugin skills, and skills from your claude.ai account don't. Claude also has to be able to invoke the skill, and the built-in git instructions have to be on.

So recording a recipe does two things at once. It saves the launch steps, and it gives Claude Code a project skill named verify, which changes what Claude is told to do before each commit.

The checklist: a trigger for each past outage

This is the part of the post most directly about memory.

"We maintain a reliability checklist with 39 items, each with a trigger that can be read from a diff, a check, and the incidents or PRs behind it."

Each item has three parts:

  • A trigger that can be read from a diff, so Claude can tell whether the item applies.
  • A check to run when it does.
  • The incidents or PRs behind it, so the reason is recorded with the rule.

The post's example is "--resume loads old transcripts." When session storage or message types change, the team asks whether a new field loads safely, because older transcripts won't have it.

Then the key sentence: "Claude reads the diff and checks only the items whose trigger matches–usually 3 to 10–so nobody has to memorize past outages."

Two design choices stand out. The checklist isn't loaded as a wall of reminders on every change. Only items whose trigger matches are checked. And every item carries its history, so the rule stays understandable after the people who wrote it have moved on.

That's the difference between the incident note in the opening example and a checklist item. The note relied on someone remembering it. The checklist item fires when a diff touches the same area.

Review rounds that build on each other

The post describes a second habit that works the same way: "We point each pass at context from earlier rounds and past failures rather than re-checking everything from scratch. It’s cheaper and finds more."

The team also keeps reviewers focused instead of adding more of them. Rather than stacking a second, more expensive reviewer, it keeps a REVIEW.md that says what the reviewer should pay attention to for that code.

That file is protected from the changes it judges. "If a change can modify the check that judges it, the check is broken." The post says Code Review reads REVIEW.md from the base or default branch, never from the pull request's changes.

A few other rules from the team's process follow the same logic:

  • Escalate on repeated failure. Claude runs the checks and tries to fix what fails. "If a check is still failing after three rounds, Claude stops and brings in a human."
  • Say why. When a check pulls in a reviewer, it should say why, so they don't have to work it out from the diff.
  • Review commits, not moving targets. "A passing review on an out-of-date commit means nothing."
  • Run cheap checks first. Claude runs the tests, build, and linter before opening a pull request. The post says you can enforce this with a hook that runs tests when Claude finishes. We covered what hooks can do, and which ones can add context for Claude, in our guide to what Claude Code hooks are.

Stamps and gates: recording how each commit was verified

The team records verification on the commit itself. "In our own repos, we stamp each commit with how it was verified." The stamp can say "none", so the team can query for commits that weren't verified.

It also built a commit gate that can block a commit if the session didn't include /code-review or /verify, with off, observe, and enforce modes. Observe mode logs what would have been blocked, so false positives can be reviewed first. In enforce mode, a commit can carry an explanation of why it wasn't verified, and after two blocked commits in a session, the next one goes through "so Claude doesn't get stuck".

These are the team's own tools, described in a blog post. The post doesn't present the stamp or the gate as Claude Code features you can switch on.

How missed bugs become rules

The last section of the post is about turning misses into memory. In the Claude Code repository, the team uses two methods.

The first extracts patterns from human review comments and PR reverts. A pattern has to "occur in at least two PRs and be identifiable from a diff" to be considered as a rule. Three agents try to disprove it, and a human reviews and approves it in a PR.

The second replays three bug finders against a PR linked to a known incident. If at least two find the bug, it's detectable. If the bug is missed on a small diff, that's a gap worth turning into a rule in REVIEW.md.

Flaky tests get similar treatment. Claude can't skip them, add sleeps, or retry until they pass. If it can't find the root cause, "it deletes the test and writes down why."

And the rules themselves need upkeep: "Rules need cleaning up too." Test suites, verification steps, and .md files only grow if you let them, so the team tidies them on a routine.

The post's closing advice ties it together: treat the verification layer like any other system, and "write down lessons when they miss something so that it doesn’t happen more than once, and prune those lessons so they stay worth running."

What people try first

Writing an incident note and hoping someone remembers. The team's checklist ties each lesson to a trigger in the diff.

Adding a second reviewer. The post favors tuning the primary reviewer with REVIEW.md.

Letting /verify rediscover the launch every time. It can record a recipe to .claude/skills/verify/SKILL.md.

Turning every miss into a rule. The team requires a pattern in at least two PRs, readable from a diff, and human approval.

Keeping every rule forever. Rules are pruned on a routine.

The Fix: Turn verification results into something the next session can use

Step 1: Record how to run the app

Use /run-skill-generator, or let /verify record its recipe, and commit the result.

Step 2: Give each lesson a trigger

When a bug ships, write the rule with what in a diff should trigger it and the incident behind it.

Step 3: Keep the rules out of reach of the changes they judge

Put review rules where the change under review can't edit them.

Step 4: Write down the reasoning behind your rules

A trigger says when a rule applies. The decision behind it, and the incident that caused it, need a home that lasts.

Setting this up in MemoryLake

A checklist item works because it carries its history. The same is true of the decisions behind your project: why a check exists, which approach was tried and dropped, and what an incident taught you.

MemoryLake is a memory layer for that kind of project context, such as decisions, lessons from incidents, and the reasons behind your rules, kept in one place you maintain and available to the assistants you connect, such as ChatGPT, Claude Code, and Codex.

You write the entries yourself, in your own words. Nothing is read out of, written to, or deleted from your skills, your REVIEW.md or CLAUDE.md files, your sessions, your commits, or any vendor's store. /verify and Code Review work the way Anthropic describes them.

Step 1: Create an API key

Sign in and generate a key from the dashboard. Store it outside your repositories, like any other credential.

The MemoryLake console showing the API keys screen, where a new key is created and copied for use in an agent
The MemoryLake console showing the API keys screen, where a new key is created and copied for use in an agent

Step 2: Upload your first memories

Start with what you wrote in Step 4 of the fix: the incidents behind your rules and what each one taught you. One lesson per entry, with the date.

The MemoryLake workspace with the first documents uploaded, listing each file as it becomes searchable memory
The MemoryLake workspace with the first documents uploaded, listing each file as it becomes searchable memory

Step 3: Connect your AI & agents

Connect Claude Code and the other assistants you use. A new session, or a teammate's assistant, can draw on the same lessons.

The MemoryLake integrations screen listing the AI clients and agent frameworks that can be connected to the memory layer
The MemoryLake integrations screen listing the AI clients and agent frameworks that can be connected to the memory layer

What this changes in practice

The first difference is that lessons outlast the people who learned them. The reason for a rule is written down.

The second is less rediscovery. A recorded recipe and a recorded decision both save the next session from working it out again.

The third is shared context across tools. Codex or another assistant working on the same project can use the same lessons.

Best practices for verifying Claude's work

Run the app end to end. The team treats this as more important than tests.

Record the launch recipe. Commit .claude/skills/verify/SKILL.md once it works.

Give rules triggers. Check only what a diff touches.

Attach history to rules. Keep the incident or PR with each item.

Build on earlier rounds. Point each pass at past failures.

Escalate after repeated failures. The team brings in a human after three rounds.

Prune your rules. Rules only grow if you let them.

Conclusion

The Claude Code team's verification process is as much about memory as about tests. /verify can record the steps that worked to .claude/skills/verify/SKILL.md, so later runs and other agents follow them. The team's reliability checklist gives each lesson a trigger, a check, and the incidents behind it, and Claude checks only the items a diff matches. Review rounds point at past failures, and missed bugs become rules only after they repeat and a human approves.

The common thread is that a lesson has to be written down somewhere the next session will find it, with enough history to stay understandable.

Frequently asked questions

What does /verify do in Claude Code?

It builds and runs your app to confirm a change works, without falling back to tests or type checks.

Where does /verify save what it learns?

When it runs without a recorded recipe, it writes what worked to .claude/skills/verify/SKILL.md at the repo root, or in the touched package directory in a monorepo.

Does Claude run verify before every commit?

When a session starts with a project skill named verify in place, Claude Code's commit instructions tell Claude to run it before each commit, except for docs or test changes. The bundled /verify doesn't count.

What is the Claude Code team's reliability checklist?

A list of 39 items, each with a trigger readable from a diff, a check, and the incidents or PRs behind it.

How do review rounds build on each other?

Each pass is pointed at context from earlier rounds and past failures instead of re-checking everything.

Is the commit gate a Claude Code setting?

The post describes it as something the team built for its own repositories.

How does the team turn missed bugs into rules?

A pattern must appear in at least two PRs and be readable from a diff, survive three agents trying to disprove it, and get human approval.