Over the last year, a quiet pattern has emerged across almost every engineering team building with AI.
The first version of an AI coding workflow is surprisingly simple. You install Claude Code or Codex, point it at a repository, and ask it to build something. The results are often remarkable. Then reality sets in. One project needs a particular coding style. Another requires specific architectural patterns. A third has strict security requirements. Before long, every team starts building the same thing: a growing body of instructions that teach the model how software should be written inside their organization.
Anthropic’s recent article on securing its AI-native software development lifecycle is one of the clearest descriptions of this transition. Claude now authors roughly 80% of the code merged into Anthropic’s repositories. Engineers increasingly direct, review, and approve rather than manually implementing every feature. Security guidance is encoded into CLAUDE.md files and reusable skills. New classes of vulnerabilities feed back into those instructions so future generations of code improve automatically. At the same time, deterministic controls such as CI gates, identity boundaries, egress controls, hooks, and automated security reviews continue to protect deployment and production environments. (Claude)
It’s an outstanding piece of engineering. It also reinforces something we wrote several months ago. In our earlier article, we argued that AI changes the primary artifact of software engineering. Developers are increasingly expressing intent while autonomous agents determine implementation. Source code doesn’t disappear, but it becomes a realization of something that came before it. Intent becomes the artifact humans actually engineer.
The main question still remains: If intent is becoming the primary engineering artifact, where does its control plane live?
Teaching an agent is not the same as controlling one
One of the most elegant ideas in Anthropic’s engineering workflow is CLAUDE.md. Every engineering organization accumulates knowledge that never quite fits into a compiler or a static analyzer. Naming conventions. Security practices. Architectural principles. Lessons learned from past incidents. Preferred libraries. Internal frameworks. Historically, those ideas lived in documentation, wiki pages, and engineering handbooks. Whether developers remembered them depended on experience, discipline, and good code review.
CLAUDE.md changes that. Instead of teaching people, it teaches the agent. Every coding session begins with the accumulated knowledge of the engineering organization already in context. As new bug classes are discovered, the instructions evolve so the same mistakes become less likely in the future. Combined with reusable skills and AI-powered reviewers, it creates an engineering feedback loop that simply wasn’t possible before. (Claude)
We think approaches like this will become standard. Every serious engineering organization will develop its own equivalent of CLAUDE.md. But it’s important to recognize what these mechanisms actually are. They are guidance. They influence how the model reasons.
Guidance and enforcement solve different problems
Anthropic’s article also describes deterministic controls operating throughout the software development lifecycle. Pull requests pass through CI. Security scans execute automatically. Hooks validate changes. Identity boundaries limit access. Remote development environments constrain agent behavior. These mechanisms don’t persuade the model to behave correctly. They enforce properties of the system regardless of how the model arrived at its decisions. (Claude)
That distinction matters. Guidance makes the model a better engineer. Deterministic controls make the software delivery pipeline more trustworthy. Those are complementary layers, not competing ones. But there is an interesting gap between them.
By the time deterministic controls execute, the reasoning has already happened. The model has already interpreted the user’s request. It has already explored alternatives. It has already decided which files matter, which APIs to call, which architecture to pursue, and which implementation strategy best satisfies the objective. The most important engineering decisions have already been made. The CI pipeline verifies the result. It does not verify the reasoning that produced it.
The missing control plane
This is where we believe AI-native software engineering will evolve next. Today’s AI-native SDLC has a reasoning guidance layer and an execution enforcement layer. What it does not yet have is an independent intent verification layer.
That distinction is subtle but profound. Suppose CLAUDE.md tells the model to prefer one architectural pattern over another. The model reads those instructions, interprets them, balances them against the task at hand, and generates a solution. Maybe it follows the guidance perfectly. Maybe it discovers an exception that seems reasonable. Maybe two instructions conflict and it chooses one over the other. All of those decisions happen inside the model. The guidance doesn’t execute. The model executes its interpretation of the guidance. For many workflows, that is entirely appropriate.
But as agents become increasingly autonomous, long-running, and capable of coordinating dozens of tools and sub-agents, another question becomes important. How do we independently verify that the evolving plan remains faithful to the developer’s original intent?
Not whether the code compiles. Not whether the tests pass. Not whether the security scanner finds vulnerabilities. Whether the chain of reasoning itself remained a valid refinement of the objective that started the task.
That is a different control problem.
This is why we built ArmorClaude
Several months ago, we argued that intent is becoming the new source code. Building with Claude Code every day only strengthened that belief. The more we relied on AI to implement software, the less interested we became in individual code changes and the more interested we became in understanding why the agent believed those changes belonged to the task in the first place.
Git shows us the diff. The terminal shows us the commands. CI tells us whether the implementation passed. None of them explain whether the reasoning remained faithful to the developer’s objective as the plan evolved. That realization became the foundation for ArmorClaude.
ArmorClaude doesn’t replace CLAUDE.md. It doesn’t replace skills. It doesn’t replace prompts. In fact, we expect every mature engineering organization to invest heavily in those mechanisms because they dramatically improve the quality of AI-generated software.
ArmorClaude introduces a different layer.
The developer’s intent is captured and committed before execution begins. As Claude reasons, revises plans, delegates work, and refines its implementation, ArmorClaude continuously verifies that those refinements remain consistent with the committed intent. If the objective legitimately changes, that change becomes explicit rather than emerging implicitly through successive reinterpretations.
Claude remains free to reason. The verification does not depend on Claude deciding whether Claude followed its own reasoning correctly. That separation is deliberate.
The next generation of AI-native software engineering
Anthropic’s article demonstrates that AI-native software development is no longer an experiment. It is rapidly becoming how modern engineering organizations build software. Guidance will become richer. Skills will become more sophisticated. Review agents will become more capable. Deterministic execution controls will continue to harden the deployment pipeline. (Claude)
We believe one more layer is about to emerge. As developers move from writing implementations to expressing intent, intent itself becomes something that deserves independent verification. Not because guidance is insufficient. Not because deterministic execution controls are insufficient. But because they answer different questions.
Guidance asks, “How should the model approach this problem?”
Execution controls ask, “Is this code safe to ship?”
Intent verification asks something neither layer can answer on its own:
“Did the reasoning remain faithful to what the developer actually wanted?”
That is the question we believe will define the next generation of AI-native software engineering. And it is the question ArmorClaude was built to answer.
