Claude wrote the code and didn't give it to me directly.

  It's the first time in the history of the world.

Writing this code, AI has done it for you.

It's a code that doesn't write right, AI isn't responsible, and finally you have to go through it yourself: it's a mess that's stuck with a lot of people.

Recently, Anthropic has also rolled out AI adoption.

After they had Claude write the code, they didn't intercept it directly, but they ran the four checks themselves:

/code-review predecessor bug, /simplify to clean redundant implementation clean, /verify to do end-to-end verification, if this time the interface is activated, then use /design to view the DESIGN.md kernel again.

It's just a matter of getting it delivered.

On July 22, the Claude Code team unveiled an internal "verification cycle".

In other words, after Claude has written the code, he will find the error himself, and then he will come back to you.

This means that AI has evolved from "writing code" to "checking code itself".

Anthropic gave this set a name, a verification loop.

The official definition is simple: it's an iterative process of Claude checking and trying to fix his own work.

It is transformed into a closed loop that is activated by the intelligent body.

It used to be "collecting context → performing actions → performing artificial checks" and the last step was to get people to do it: AI gives you a live baby, you have to go through it yourself.

Now this line, which has been extended to "collect context→ execute action→ automatic verification→ repair→ re-verification", checks and repairs, is stuck back into the loop.

Anthropic's official Intelligent Body Cycle diagram: After being prompted in, Claude collects the context, performs the moves, verifies the results, verifies the results, but only runs back and then returns.

Some of the checks Claude would have done. The signals of certainty in the codebase, such as type checker, linter, run test, runtime error report, it would have read and changed by hand.

There's another category that's really troubling: the interface changes are wrong, the user flow goes wrong, the changes are buried in an invisible pit...

In the past, these checks were only done by humans, and the same checks were done tens of hundreds of times.

Anthropic's solution is to repeat those checks by hand every time you do them, write an article, pack it in Skill, and give it to Claude to automatically execute each task.

In the last few decades, all the processes of software engineering - writing requirements, planning, layering reviews, unfinished sessions - have been essentially due to: writing code is too slow, engineers' time is too valuable.

But when AI makes this loop of writing code faster and cheaper, the premise no longer exists.

Claude Code's own judgement is that the bottle is not gone, it's just shifted: from "writing code" to verification, code review, security.

The code is generated too quickly, and the new problems become that the code is completely wrong, who maintains it, and people can't keep up with the pace of code review.

In the face of this new bottleneck, the Claude Code team first experimented on themselves.

Within the Claude Code team, we use these four self-testing Skills every day.

/code-review, specifically reviewing code changes, removing potential bugs, and providing a review comment.

This is equivalent to giving yourself a tireless reviewer.

/simplify, clean up the modified diff, remove the complicated implementation around and around, and simplify the structure.

It does not give you additional functionality, but eliminates redundancy, simplifies implementation, and reduces maintenance costs.

This is important and powerful. Most people write code that is stacked up and can be actively used to make reductions, which is especially difficult.

/verify, end-to-end verification, real knife running again, confirming that the function is actually done, rather than "looking done".

/design, only activated when the UI is activated. It runs on the DESIGN.md in the warehouse to verify whether your visual implementation is running.

These four Skills didn't come out of nowhere.

At the bottom of them, Claude Code has laid a layer of validation support:

Built-in/verify lets the app run and observe changes, you write a clear build and test command in Cloud.md, and it executes as per execution; and Code Review, which specializes in multi-smartphone reviews on PR, which automatically fires GitHub Actions every time you submit.

The team's four Skills, on this level of common ground, add their own process.

Anthropic's approach is also simple:

Write down that step every time you do it manually, in bold words, as you exchange notes for a new colleague who is entering the first day of work.

If you want to know how to describe this step, you can ask Claude to give you a general best practice and then change it.

Your version is likely to be different in some respects from the general practice, and that's exactly what should be remembered.

It's not necessarily a "feeling wrong" kind of vague judgment.

For example, any deleted database field that doesn't support a change in data migration steps is called back. It's a general rule that you can never catch, but it's a "native rule" that belongs to your project.

The red line that you've been using to keep your hands dead, it's worth writing in a circle.

How about it?

Throw it to the skill-creator so that it interviews you in turn, or just throw a Markdown file in the.claude/skills/ itself.

The easiest way to verify Skill is to add a few lines of text to it, and then upload it again to a new task to confirm that the test is actually running and hasn't changed.

There's also a way to deal with the skills you've changed, such as built-in plugins and plugins, by writing an outline of Skill, having it reset to the original, and then resetting your verification.

After checking the packaging for Skill, the next question is: When does this game start?

Anthropic offers four degrees of automation, from loose to tight.

Standalone: Think of it yourself and tune it manually.

Embedded: Embedded into a task process and run alongside it.

Chained: Several verified Skills in a chain, running automatically one after another.

On every PR: One of the hardest files ever submitted, the code is automated once and for all.

This shift in the middle of official governance is called "from custom to contract".

It was a personal habit of "I always remember to verify after/simplify", which became a fixed contract of "/simplify is done and verifies automatically".

The whole chain has gone through its own development cycle and only comes back to you when it needs you to tap the board.

The longer the chain is drawn, the more reliable it is, but the official specification dictates one thing: chain verification will actually burn tokens on the ground.

So we're going to have to set all the checks up as a PR gate, and every time we submit a card, the correct posture is to see if it's unstable and then step up.

Behind the 4 Skills, the competition for AI programming is shifting from generation to validation.

Claude Code, the father of Claude Code, gave the same judgment.

On June 9, he suggested that in an age when powerful models can run autonomously for long periods of time, self-validation is the key to making the model run longer and closer to your expectations: you don't have to keep staring at Claude too often to give away more lives.

In other words, the stronger the test, the more intelligent the body is, and the longer the run, the more careful the person is.

In the past, we used to rely on word of mouth, but it also has a ceiling: just solve the task once, and the next time we have to do it again.

Here's to correcting a common misconception: Skill is not a Markdown cue.

It's a capability module, with instructions, file structures, scripts, tool calls, configurations, and a whole set of workflows, that takes the team's inspection steps, design specifications, craters, and stuffs them into an all-in-one package that Claude can fold himself when he needs to.

More importantly, Skill is moving from a feature of Claude Code to an open standard across manufacturers.

According to industry rhetoric, GitHub Copilot, Cursor, OpenAI Codex, and Gemini CLI have all adopted the same format.

This means that those skills that you've stuck with your team won't be locked up in a tool that's going to lock the team's experience, norms, and process checks into something that can be called back and forth.

This also led to the stark reality that the same Claude, the efficiency of different teams, could be multiplied by several, causing the gap not in the model but in the workflow:

Have you written the check as Skill, have you set up a verification cycle, have you let the smart body run the feedback loop itself?

At the end of the day, the ability of an intelligent organism is an addendum: model, add tools, add verification mechanisms, add work processes.

This model is getting closer and closer. The real distance is the three behind, which are all in the hands of the user.

Of course, what this blog shows is the process optimization of AI-assisted development, not "AI has been able to write software independently".

Therefore, it is not a smart body that is going to steal the dishes of human engineers, but the direction is already clear.

In the past, we've been teaching AI how to write code, and now we're going to start teaching it to verify that it's wrong.

For a person who writes code with AI every day, it's really starting to work for you until the day you finally give it to AI with the assurance that "you have to check it manually before you go to work".