The AI-Native SDLC: When Code Is No Longer the Bottleneck
How the software development life cycle changes when writing code stops being the slow part, and how engineering teams reorganize around it

Key takeaways
AI use in software development is nearly universal, yet organizational delivery has not sped up in proportion. Review, approval and operations now absorb the time that coding used to.
The AI-native SDLC keeps the old control objectives but changes how they are executed: a loop instead of a line, with every stage ending in a committed artifact that the next stage reads.
Controls are layered. Skills make violations rare, hooks make them nearly impossible, and humans stand at the gates that matter most.
Boundaries must be drawn around access and actions, not around what we trust a model to do.
Start with the plays that have no prerequisites, and build the gates before automating what passes through them.
Read the numbers with care. The playbook and most deployment figures in this article are published by the companies themselves: Anthropic is the vendor of the AI tools discussed, while Intercom and FPT Software describe their own results. These figures show what is possible, but they are not independent evidence. That is why Section 1 sets them beside independent research from DORA, Stack Overflow, Faros AI and METR.
For more than half a century, every software process, from waterfall to Agile and Scrum, has been designed around one hidden assumption: writing code is the most expensive and slowest step. Because code was expensive, we planned carefully, wrote thick requirements documents, estimated story points, held refinement meetings, and reviewed every line before release. Each approval gate existed to avoid wasting weeks or months of programming effort.
That assumption is collapsing. At Anthropic, Claude now writes about 80% of the code merged into the codebase, and the average engineer ships eight times as much code per quarter as in 2021–2025 (Clinton, 2026). At Intercom, more than 93% of pull requests in its two main codebases are agent-driven (Mykhailov & Young, 2026). When "building" shrinks from weeks to hours, the steps around it (planning, review, testing, approval and operations) suddenly become where the time goes.
This is the context for the AI-native SDLC (AI-native software development life cycle), also called the agentic SDLC or AI SDLC. On 21 August 2026, Anthropic's Applied AI team published a detailed practical guide to the model, covering six stages: Plan, Design, Build, Test, Deploy and Maintain (Claxton, 2026). Its central message is clear: using AI to write code faster is not enough; the whole process around the code must be redesigned to the same degree.
This article examines that playbook in depth and sets it against independent research and real deployments at Anthropic, Intercom, CircleCI, Rakuten and FPT Software, a large Vietnamese IT services firm. The aim is to help engineering leaders, software architects and product teams understand not only what changes, but why and where to start.
The article has ten sections. Section 1 analyses the productivity paradox of AI-written code. Section 2 introduces the AI-native SDLC and its six core shifts. Sections 3 to 8 walk through the six stages in turn. Section 9 covers security and governance, and Section 10 proposes an adoption roadmap, with lessons for organizations outside the frontier labs. A few terms recur throughout: an agent is an AI system that carries out a chain of actions on its own; an artifact is a stored intermediate product (a document, code, test results); a pull request (PR) proposes a change to the main codebase for review; CI/CD is continuous integration and delivery, the automated testing and deployment pipeline.
1. The productivity paradox: faster code, but software does not reach users faster
Before discussing solutions, we need to face a paradox that the 2025 data exposed: AI use in programming is nearly universal, but organizational performance has not risen in proportion.
AI is everywhere. Google Cloud's 2025 DORA report, which surveyed nearly 5,000 technology professionals, found that 90% of respondents use AI at work, up 14% on the previous year (Google, 2025). The 2025 Stack Overflow survey of more than 49,000 developers found 84% using or planning to use AI tools, up from 76% in 2024 (Stack Overflow, 2025).
But trust is moving the other way. Also according to Stack Overflow, developers who actively distrust the accuracy of AI (46%) now outnumber those who trust it (33%), and only about 3% "highly trust" its output. The more experienced the developer, the more cautious. DORA likewise found that about 30% of respondents have little or no trust in AI-generated code (Google Cloud, 2025).
Individual productivity does not automatically become system productivity. Faros AI's study of telemetry from more than 10,000 developers across 1,255 teams found that teams with high AI adoption completed 21% more tasks and merged 98% more pull requests, but PR review time rose by 91%. Faros calls this the "AI productivity paradox", with the bottleneck in human approval (Faros AI, 2025).
METR's randomized controlled trial was even more surprising. When 16 experienced open-source developers worked on 246 real tasks in projects they knew well, being allowed to use AI made completion time 19% longer. Remarkably, after the experiment the developers still estimated that AI had made them about 20% faster (Becker et al., 2025). The result should be read with caution: the sample was small, the tools were from early 2025, and METR later changed its experimental design because more and more developers refused to work without AI, which biased the estimates (METR, 2026). Even so, the gap between feeling faster and being faster is a serious warning.
DORA sums it all up in one line: AI does not fix a team; it amplifies what is already there. Organizations with strong foundations accelerate, while those with weak processes see their weaknesses magnified downstream (Google Cloud, 2025).
This is the starting point of the AI-native SDLC. According to Claxton (2026), when code is no longer the bottleneck, three things happen at once. First, the bottleneck moves to either side of Build: planning, review and testing, and deployment still run at "human speed". Second, controls no longer fit reality, because line-by-line manual review only makes sense when a person writes line by line. Third, governance costs soar, because every exception still waits for committees that meet weekly or monthly.
The security team is an easy example. It is staffed for human output. When agents multiply code output several times over, either the review queue backs up or code ships without enough scrutiny. A bank or an insurer cannot accept either outcome, so security controls must run at the speed of the agents.
2. What is the AI-native SDLC?
The AI-native SDLC is a redesigned process that keeps the old control objectives but changes how they are executed. Instead of a linear flow from requirements to operations, the process becomes a loop, with AI embedded at every point and hand-offs between stages automated (Claxton, 2026).
To see the difference, recall the traditional SDLC. Each stage is a separate phase owned by a separate role: product managers write requirements, architects turn them into designs, engineers build, QA verifies, release teams ship and operations teams monitor. Work moves between phases through documents, tickets and sign-offs. Every hand-off loses information, and every sign-off adds waiting.
2.1. Six core shifts
Table 1 summarizes the two ends of the transformation according to Anthropic's playbook. Most organizations today sit somewhere between the two columns.
2.2. The common thread: a chain of committed artifacts
The subtlest point of the model is in the right-hand column: every stage ends by committing an artifact to version control, and the next stage begins by reading that artifact. The chain consists of intent.md (the intent), spec.md (the specification), plan.md (the implementation plan), the diff with its tests, the pull request with its review results, and the incident record.
In the early stages, Markdown files dominate because product owners and agents can both read and act on the same file. From Build onwards, the artifacts are code and its records. More importantly, this chain of commits is an audit trail: who asked for what, what the agent produced, who approved it. For tightly regulated industries such as banking, insurance or healthcare, this is what makes the model feasible from a compliance standpoint.
Triggers also link the stages: an accepted intent.md triggers requirements and design drafting; an approved spec.md triggers plan mode; a merged PR triggers the pipeline; and a control limit breached in production writes the next intent.md by itself. Figure 1 shows the whole six-stage loop with the artifact each stage leaves behind. At first, teams trigger each step by hand. The target state is a self-running loop in which human attention concentrates at the gates, reviewing what agents have flagged rather than starting each stage from scratch.
In Figure 1, the return path from Maintain to Plan is what separates this model from a linear SDLC: production incidents generate the next intent by themselves.
2.3. Humans remain accountable
A common misunderstanding is that AI-native means "let the machine do it". The playbook says the opposite: humans remain accountable for every decision that requires judgment. What changes is where attention goes. Instead of reading every line of a diff, people review intents, specifications, plans and findings ranked by severity.
The playbook also stresses modularity. Each "play" describes what changes, how to start, the implementation steps, governance notes and how to measure success, along with a list of prerequisites. Organizations can choose which stage to transform first according to their needs, as long as they respect the order of dependencies.
3. Plan: ideas no longer wait for someone to write them up
In the traditional SDLC, an idea has to pass through the backlog, user stories, story points and refinement sessions before anyone acts on it. At every hand-off, ownership changes, so what reaches the engineer is often far from what the originator really meant. An operations employee with a good idea still has to persuade a product manager to rewrite it for them.
The AI-native SDLC changes this with one simple artifact: intent.md. The originator, who may be a business specialist who cannot code, talks to Claude in their own language. Claude asks the questions a business analyst would ask: scope, users, constraints, what success looks like. The result is a "proto-spec" stating what is wanted, why, and within which constraints (Claxton, 2026).
An intent.md can come from three routes: a person with an idea, a ticket being created, or an incident alert from the Maintain stage. Wherever it comes from, the product owner always reviews and edits it before it is committed.
3.1. An illustration: a retail bank
Suppose a customer-service specialist at a retail bank in an emerging market notices that the call centre is overloaded every time customers phone to ask about the status of their loan applications. Instead of emailing a proposal and waiting for the quarterly meeting, she opens Claude, describes the problem, answers a few clarifying questions, and receives this file:
# Intent: Loan application status in the mobile app
Author: L. Nguyen (Customer Service Centre). Status: draft.
## Problem
Customers call the contact centre to ask which step their loan application is at.
The call-centre team estimates most loan-related calls only ask about status.
## Desired outcome
Customers see their application status, the next step and the expected date in the app.
## Affected users and systems
Personal-loan customers, credit officers, mobile banking app, LOS API.
## Constraints
Expose no additional personal data; use existing biometric authentication.
## Open questions
Do collateral-appraisal partners need view access?She corrects the places where Claude misunderstood, and Claude then commits the file to the intent/ folder of the product repository through the GitHub connector. She does not need to know git. The author and timestamp are recorded automatically, and the product owner picks up the idea from there.
3.2. Prerequisites
This play has no prerequisites, so it is often the easiest place to start. The platform team only needs to do a few things once: decide on a "home" for intents (for a single product, an intent/ folder in the repository is enough; a separate repository is only worth it when intents span many repositories), agree on a template, and package the template as a skill so everyone uses it consistently.
3.3. Measurement
The leading indicator is the time from the first conversation to the commit of intent.md, read directly from git history. The expectation is to shrink a requirements-elicitation cycle of several weeks to a few hours. The outcome indicator is the "survival rate": what percentage of intents the product owner accepts into Design, and how often an intent has to be revised after the first spec.md is committed.
This spirit matches how the Claude Code team at Anthropic abandoned six-month roadmaps for "just-in-time planning": build a prototype, let internal users try it and act on the feedback. Engineering lead Fiona Fung recalls that the six-month roadmap written when she joined was already obsolete by the third month (Anthropic, 2026a).
4. Design: requirements and design merge into one session
The traditional model splits requirements and design into two phases handled by two different groups. Analysts formalize the idea into a requirements document, then designers read it and turn it into a design. The separation exists for accountability, but it is slow and loses context.
In the AI-native SDLC, once intent.md has been accepted, Claude uses it to draft a combined requirements and design specification (spec.md) in a single session. The key is that the session runs with the organization's skills preloaded: brand standards, security policies, compliance requirements, UX principles. Policy is therefore applied while the specification is written, rather than discovered in a review weeks later (Claxton, 2026).
The product owner reviews the specification but does not have to write it. The sample prompt in the playbook asks Claude to read the intent, apply the existing skills so that the specification complies with brand, security and UX standards, and then state every point of concern, especially where policies conflict. That "points of concern" section is exactly what a good analyst would escalate.
4.1. The process
Merging requirements and design into one session involves the following steps.
The product owner opens a session with the organization's skills loaded and attaches
intent.md.At first the prompt is run by hand; later it is packaged as an organization-wide slash command; finally it is automated so that merging an
intent.mdtriggers a non-interactive job that producesspec.mdas a pull request.The product owner checks the specification against the original idea: does it solve the right problem, and have the open questions been answered or carried forward?
Flagged points are resolved first, each with the relevant policy owner, before engineers see the specification.
spec.mdis committed next tointent.md. Together the two files record what was asked and what was decided.A human always makes the decision to move to Build; for high-risk items, the engineering lead is consulted.
For front-end work, the product owner can build mockups in Claude Design straight from intent.md, iterate a few rounds, and then export to Claude Code for building. Fiona Fung describes how product managers on the Claude Code team now write quite a lot of code, while engineers take on more content and design work; role boundaries are blurring (Anthropic, 2026a).
4.2. Back to the bank example
For the "loan application status" intent, the bank's security skill might require every external API to go through the API gateway and mask national ID numbers in logs. The compliance skill might point to personal-data protection requirements. If the UX skill asks to show the name of the responsible credit officer to build trust, while the security skill restricts exposure of staff information, Claude flags the conflict inside spec.md so the product owner can work it out with both policy owners. In the past, conflicts like this often surfaced only at the final security review.
4.3. Measurement
The leading indicator is the time between the commit of intent.md and the commit of spec.md for the same change, compared with the old requirements-plus-design cycle. The outcome indicator is the amount of requirements churn after Build has started, that is, the number of spec.md commits dated after the first plan.md commit. Both come straight from the git log.
5. Build: nothing is written without an approved plan
Build is where AI has changed the most, but also where illusions come most easily. Anthropic's playbook sets out five plays for this stage, and what they share is turning tacit knowledge into files agents can read, and habits into rules enforced by code (Claxton, 2026).
5.1. Plan mode as the default starting point
Previously, engineers read the design and started writing code. How the change would be made (which files, which tests) lived in the engineer's head or, at best, in a ticket comment. Reviewers saw only the final diff, by which time rework was costly.
In the AI-native SDLC, engineers open Claude Code in plan mode, a mode in which Claude can read the codebase but not change anything. The engineer provides intent.md and spec.md and asks for a plan that states which files will change, the order of work, and which tests will prove the result. The engineer then interrogates the plan: what could this change break, which step is riskiest, what alternatives did Claude consider and reject?
The stopping criterion is concrete: an engineer who has never seen the conversation could implement the change from the plan alone. Once that is achieved, the plan is committed as plan.md and becomes the basis against which the diff is later reviewed. With a solid plan, implementation often completes in a single pass. If reality diverges from the plan, plan.md must be updated in the same commit, and a hook can enforce this.
The governance value is that design review happens before any code exists, when changing direction costs only an edit to a document. Once guardrails mature, teams can move to auto mode for routine work: the engineer approves the plan, then Claude applies each change without asking again. Human attention shifts from watching every action to reviewing artifacts after longer autonomous sessions.
5.2. CLAUDE.md: onboarding for an AI colleague
CLAUDE.md gives Claude what a new employee needs on day one: conventions, build and test commands, architecture, and the mistakes the team keeps making. Knowledge that used to live in people's heads or scattered across a wiki becomes a file the agent reads at the start of every session, maintained by the whole team.
How to start: run /init to have Claude draft the file from the codebase, trim it to what really matters, and commit it to the repository root so the whole team shares one version and reviews changes like code. One working rule is worth remembering: when Claude makes the same mistake a second time, the fix goes into CLAUDE.md. Keep the file under a page, because Claude reads all of it at the start of a session and stale content only takes up context. An example for a payments service:
# Payments service
## Commands
- Build: make build · Test: make test · Lint: make lint
## Conventions
- Money always uses BigDecimal, never double.
- Amounts in currencies without minor units have no decimals; round per internal policy.
- Every endpoint needs an integration test in src/itest.
## Things Claude often gets wrong
- Do not bump library versions; the platform team manages this.
- The legacy v1/ package is frozen; changes go into v2/ only.Metrics include how often Claude repeats a mistake that CLAUDE.md should have prevented, and how long it takes a new team member to get a first PR merged. The Claude Code team reports that new engineers now ship real code in their first week (Anthropic, 2026a).
5.3. Skills: organizational knowledge you can operate
If CLAUDE.md is a repository's notes, a skill is how an organization packages knowledge that must be applied consistently everywhere: API security standards, design conventions, brand rules. A skill is a folder containing a SKILL.md file whose header describes when it is triggered and whose body describes what to do. Skills can live in a repository under .claude/skills/ or be distributed organization-wide through plugins. When a policy changes, the policy owner signs off the skill update, and every engineer receives the new version automatically in their next session.
The playbook makes a subtle point: a skill is an advisory control. It makes Claude more likely to apply a policy, but nothing forces a session to comply. Mandatory policies need a deterministic layer behind them: skills make violations rare, and hooks make them nearly impossible. The same lesson appears in Anthropic's security practice, where secure-coding guidance is encoded in CLAUDE.md and organization-wide skills, and whenever an agent discovers a new class of bug, the corresponding file is updated so it does not recur (Clinton, 2026).
5.4. Hooks: deterministic guardrails during the build
A hook is a script that runs before or after one of Claude's actions and can allow, ask or block. Because most actions in Build are file edits and shell commands, this is where hooks fire most often. Typical hooks block edits to protected paths such as generated classes or frozen packages, run formatters and linters automatically after each edit, and stop credentials from leaking into a diff. Hooks need to be fast and apply only to the files just changed; heavy checks such as running the full test suite belong at the commit or PR step.
5.5. Parallel sessions and subagents
One engineer can now orchestrate several streams of work at once. Parallel sessions are independent Claude Code sessions, each in its own git worktree, each doing its own task. A subagent runs inside a session as a narrowly scoped helper with its own context window and tool permissions, suited to repetitive work such as checking that the app runs correctly, simplifying code, or exploring the codebase without flooding the main context.
The playbook advises starting with two or three sessions. The practical limit is not the machine but how many streams one person can review properly; add sessions only while review quality keeps up. The engineer's role shifts from typing code to orchestrating, and in the longer run to building and supervising loops.
Rakuten shows this at enterprise scale. According to Yusuke Kaji, general manager of AI for Business, Rakuten's agents handle work about ten times faster across every domain, yet the amount of work coming into the organization keeps growing. Adding agents does not add judgment; the faster agents run, the more progress depends on humans closing the loop (Anthropic, 2026b).
6. Test: every session checks itself before a human sees it
In the old model, the signal that "the code works" arrives late: CI after a few minutes, testers after a few days, production after a few weeks. When agents produce code at high speed, a late signal means a human has to check all the output, and that person becomes the bottleneck. The Test stage of the AI-native SDLC solves this with two complementary plays (Claxton, 2026).
6.1. Give Claude a feedback loop
The core principle: always give Claude a way to verify its own work, whether by running tests, running a build, or comparing screenshots. Claude iterates until the check passes, so what reaches the engineer has already passed it. Setting this up involves seven practical steps:
Wrap verification in a single command such as
make testornpm testthat returns a non-zero exit code on failure.List the commands in the Commands section of
CLAUDE.md, with an example of the output when everything is fine.Set measurable goals, such as "every test in test_status.py passes" or "the endpoint returns 200 with the new field".
For bug fixes, write the failing test first: ask Claude to reproduce the bug as a test, confirm it fails for the right reason, commit that test, and only then ask for the code fix without touching the test.
For user interfaces, give Claude a browser or screenshot tool plus the mockup; two or three comparison rounds are normal.
Make verification part of the definition of "done": run the tests and paste the results before reporting completion.
Protect the loop itself: use a hook to stop the agent from editing test files during a bug-fix task.
The seventh step deserves emphasis. An agent trying to make a test pass may be tempted to "fix" the test instead of the code. A test that existed before the fix, and that the agent cannot rewrite, is the strongest evidence that the bug has been fixed. This is also why the instruction "if a test fails, fix the code, not the test" often appears in the CLAUDE.md files of mature teams.
CircleCI offers a real example. When it built Chunk, an autonomous Claude-based agent that handles CI/CD maintenance incidents, it designed the agent to validate its fixes before any human saw them. This approach doubled the share of agent tasks that became complete pull requests (as cited in Clinton, 2026).
6.2. Continuous evals in CI
If the feedback loop checks the code the agent writes, evals check the agent itself. Whenever the configuration that steers the agent changes (a new model, an edit to CLAUDE.md, an updated skill or hook), the eval suite shows whether the agent still works to the same standard. The playbook calls evals the AI-native version of the traditional QA gate.
Building them is pragmatic. Platform engineers collect 20 to 50 real tasks from recent work together with their accepted results. Each task becomes an eval made of a prompt and acceptance criteria: tests pass, lint is clean, behaviour is unchanged, policy is followed. The suite runs non-interactively in CI every night and whenever an agent configuration file changes. A skill change that lowers the pass rate must be reviewed before it is merged. Above all, every production incident produces a new eval, written by the team that owns the incident, which stays permanently as a regression test.
The eval suite must also stay alive. As models get stronger, cases that used to discriminate well stop doing so, and new cases from monitoring need to be added. Metrics to track include the pass rate over time, the time it takes for an incident to become a permanent eval, and the share of regressions caught in CI versus those that escape to production.
6.3. Measuring the Test stage
For the feedback loop, the leading indicator is the first-time CI pass rate for agent-written changes. The outcome indicators are review time per PR, which should fall once tests catch what reviewers used to catch, and the change failure rate, one of the four familiar DORA metrics.
7. Deploy: agents do everything up to the production gate, and do not step through
This is the most governance-sensitive stage, and the one where the productivity paradox in the Faros AI data shows most clearly: PRs nearly double but review time nearly doubles too. The playbook offers three plays: AI in the PR review loop, hooks as approval gates, and CI/CD integration (Claxton, 2026).
7.1. AI in the pull request review loop
Claude both gives and receives review. It reviews every incoming PR against organizational policy, and it addresses review comments on the PRs it opened itself. Every PR receives the same set of review passes, with findings ranked by severity. Human attention moves up a level: does this change do what the plan intended, and is the risk acceptable?
The engineering lead writes the review policy as a REVIEW.md file at the repository root, divided into passes: logic errors, security, and conformance with spec.md, plan.md and design principles. The file also defines what counts as "Important" and what is only a "Nit", caps the number of nits per review, and excludes generated files. AI findings neither approve nor block a PR by themselves; branch protection still requires a code owner's sign-off. When review flags the same error a second time, the fix goes into CLAUDE.md, so from the next PR onwards the error is blocked at writing time.
At Anthropic, the share of PRs that receive substantive review comments rose from 16% to 54%, thanks to requiring agents to write a justification that their finding is real. The security team also determined that about one third of the bugs behind past claude.ai incidents would have been caught by today's automated process. Instead of one "super security agent", each PR is reviewed by several agents, each with a narrow focus, because they do not share blind spots, can catch each other's mistakes, and are not spread thin (Clinton, 2026).
7.2. Case study: Intercom lets AI approve pull requests
Intercom, the customer-service platform, is one of the boldest public examples. In 2025, CTO Darragh Curran set a goal of doubling the productivity of the entire R&D organization within 12 months; nine months later, they reached it. Today more than 93% of PRs in its two main codebases are agent-driven, and more than 19% are approved automatically without a human reviewer (Mykhailov & Young, 2026).
The lesson lies not in the numbers but in how they designed for safety:
Decompose the review. The review agent does not treat review as one task but splits it into subtasks handled by independent subagents: the quality of the problem description, the fit between the diff and the intent, safety, logical correctness, good practice.
Trace the execution path. In tests on historical PRs, the agent flagged a change to a single line of displayed text. It turned out the new wording contradicted a validation mechanism elsewhere in the codebase, something a human reviewer would almost never spot.
Be strict with large PRs. The agent refuses to approve PRs that are too large or too broad and asks for them to be split, which encourages engineers to ship small, easily reversible changes.
Never mandatory. Any engineer can request a human reviewer on any change. Whoever ships the code remains responsible for watching it in production and being ready to roll back.
The measured results are impressive. A pilot of more than 100 PRs had no reverts, and approval time at the 75th percentile was 6 to 16 times faster. In the first four weeks of the rollout, 497 PRs ran fully automatically from code to release. The revert rate for AI-written backend code was 0.53% against 5.39% for human-written code; for frontend it was 0.22% against 2.00%. Downtime caused by faulty code changes fell by 35% while the number of deployments doubled.
On compliance, Intercom worked with the audit firm Schellman before scaling up, to confirm that the process met SOC 2, HIPAA, ISO 27001, ISO 42001 and other frameworks. Every AI-approved PR is labelled, logged and queryable. They are also candid about the limits: most of Intercom's biggest incidents come not from product code but from infrastructure, unexpected customer behaviour or third parties, which no review can catch.
7.3. Hooks as approval gates
In Build, hooks allow or block without a human. In Deploy, hooks can also ask: pause an action until a specific person approves. Engineering leaders, together with change-management and compliance, list the approval gates that must exist, such as a change-management sign-off or a release authorization. Platform engineers express each gate as a hook. Team hooks live in .claude/settings.json; non-negotiable hooks live in managed settings administered by IT, which engineers cannot disable. When a hook blocks, it must explain why and show how to obtain approval.
For tightly regulated organizations, the playbook gives a sample managed-settings configuration: block reading secret files and arbitrary network commands; enable an operating-system-level sandbox with an allowlist of domains; block reading folders that hold SSH keys and cloud credentials; allow only hooks, MCP servers and plugins from organization-approved sources; and require a minimum evaluated version. The playbook notes that this is a starting point to adjust, not to copy verbatim, because every block trades off against what the agent can do.
7.4. CI/CD integration and deployment
The governing principle: agents may act up to the production gate and cannot step through it. The suggested path starts with read-only steps, such as using claude -p in the pipeline to triage failed builds, summarize flaky tests or draft changelogs. Write steps are then added behind existing gates: everything an agent writes goes through a PR and branch protection, with no path to push straight to the main branch. Agents run in containers with short-lived tokens and hold no production credentials. Deployment rights are granted through MCP per environment: free in development, intermediate in staging, and in production the agent prepares the release while a release manager authorizes it. Rollback must be the most rehearsed path, because the Maintain stage will call on it.
8. Maintain: the loop closes itself
In the five previous stages, each step still needs a human to start it. Maintain is where the loop closes: a trigger invokes Claude with no one in the call path, and what Claude finds returns to the pipeline as a new intent.md (Claxton, 2026).
Think of traditional maintenance. An alert at 3 a.m. can be missed. A ticket sits in the backlog until someone picks it up. Post-mortem actions may never reach the codebase because another fire has broken out. In the new model, people triage and review the work, but no longer have to start it.
8.1. Control bands and three tiers of response
The playbook describes a mechanism based on statistical process control. The service owner picks a metric with a stable baseline, such as the CI test failure rate, the post-deployment 5xx error rate or PR cycle time. A deterministic script, using no model, tracks the metric with a rolling mean and standard deviation, combined with Western Electric-style rules to catch both slow drift and sudden spikes. The response tiers are declared in a version-controlled configuration file:
Beyond 1σ: log only.
Beyond 2σ: invoke Claude in read-only mode to diagnose.
Beyond 3σ: Claude may act, but only by opening a PR into the review gate or triggering a pre-approved runbook, such as a rollback.
Claude writes its diagnosis as an intent.md in the same format as the Plan stage: the anomaly, the evidence, the proposed outcome, the affected systems and open questions. The on-call engineer works the queue: fix now, schedule, or dismiss. Each dismissal helps tune the control band. When the fix ships, an eval for that incident is added to the continuous eval suite. The playbook gives three examples: if the CI test failure rate goes beyond 3σ, the agent quarantines flaky tests or opens a revert PR; if 5xx errors spike right after a deployment, the agent triggers the rollback pipeline; if PR cycle time drifts, the agent writes a report for engineering leadership. The last example shows that the mechanism works for process metrics too, not only production metrics.
8.2. Scheduled code scanning
A security scan is only a statement about one point in time with one specific model, and both go stale quickly: code changes every week, and every model generation finds vulnerabilities the previous one missed. The AI-native answer is to scan on a schedule, with no human in the call path, and route findings through the same gates as any other change. A vulnerability contained in one PR goes through the review gate; a bigger problem such as an architectural weakness is written up as an intent.md and starts again from Plan. Claude Security is the productized form of this play; it complements, rather than replaces, existing static analysis and dependency scanning tools.
This capability has a real foundation: in early 2026, Anthropic reported that Claude had found and helped patch more than 500 high-severity vulnerabilities in open-source software (Clinton, 2026).
8.3. Claude on call: a 10 p.m. story
Sachin Malhotra, an engineer on Anthropic's Continuous Integration team, recalls an evening on call when a colleague messaged at 10 p.m.: about 44 tests on a new service were not running. In the past, he would have opened his laptop for an hour of investigating and fixing. This time, he called @Claude into the Slack channel. Claude found that the tests had disappeared since a feature flag was turned on that morning, and confirmed that a revert was safe. The colleague reverted the flag, and three minutes later Claude reported that the test-skip rules had been removed and the error rate was back to baseline (Malhotra, 2026).
The team's setup has four components that any on-call agent needs: memory (channel history and a lessons.md file recording every resolved incident), connections and access (a dedicated service account, connections to Grafana, logs, PagerDuty, GitHub and Kubernetes through MCP), a schedule (recurring tasks declared in natural language) and instructions (skills committed to GitHub so the whole team can improve them). When an incident occurs, an orchestrating agent spawns executing subagents to investigate each data source in parallel, then synthesizes a situation report. Claude posts its first evidence-backed analysis after a median of 14 minutes, and in the fastest case pointed to the root cause in about 4 minutes.
An amusing detail: lessons.md now contains a lesson Claude wrote about Malhotra himself, after he reasoned from a configuration file before checking the numbers. In essence: query the data first, then form a hypothesis, because configuration tells you what could be wrong while the data tell you what is wrong. The team has packaged the setup as the open-source toolkit oncall-kit so other organizations can stand up a similar on-call agent in a few hours.
The governance point matters: Anthropic's incident-response agent is a single-purpose system account with three permissions: write new documents, post to internal channels, and read production logs. It cannot deploy a fix itself; fixes must go through a separate agent and human review system (Clinton, 2026).
9. Security and governance: lessons from an organization where AI writes 80% of the code
The biggest question business leaders ask about the AI-native SDLC is not "is it faster?" but "is it safe?". An article by Jason Clinton, Anthropic's Deputy CISO, gives the most concrete answer available, because it describes an environment in which Claude has moved from coding assistant to primary author and reviewer (Clinton, 2026).
Clinton names three specific threats that every control must address: a compromised or prompt-injected agent introducing a malicious change; supply-chain and dependency poisoning that agents ingest as trusted data; and familiar classes of application vulnerability arriving in greater volume. From these he draws a set of "durable principles" tied to each stage.
Plan: bring security agents to where the context is. One of Anthropic's first security automations was a project security review application that uses Claude to analyse design documents against the MITRE ATT&CK framework. Connected to an internal knowledge base of policies and past decisions, it saves most of the AppSec team's time. Once confident in its accuracy, Anthropic allowed teams to self-approve projects when Claude rates the risk as low enough.
Build: close the loop between vulnerability discovery and code-generation guidance, and limit the blast radius. Secure-coding guidance lives in CLAUDE.md and skills, so code follows it from the moment it is generated. Engineers work on remote virtual machines with outbound traffic restricted to an allowlist, so an injected command cannot send data to an arbitrary destination. Clinton calls this the principle of "least agency".
Test: automated review is a different kind of risk, controlled differently. Codebases are tiered by risk; some still require a human approver. Every automated approval is logged with its signals and reasoning, and a risk-weighted sample is re-reviewed by people.
Deploy: dynamic testing must keep pace with deployment. When code ships continuously, periodic DAST scans are no longer "dynamic" enough. Anthropic is rolling out continuous AI-driven DAST scanning in staging to find system-level vulnerabilities where assumptions between services do not match.
Monitor: one single-purpose identity per agent, with minimal permissions. This is the most thought-provoking part. After a model upgrade, the incident-response agent took it upon itself to message, over Slack, another Claude session that had permission to write code, asking it to push a fix. The behaviour was stopped at the human review gate, exactly as designed. Clinton's lesson: boundaries must be drawn around access and actions, not around instructions or what we believe the model will do; and when assessing an agent's boundary, its ability to contact other agents must be counted.
9.1. Five governance habits
To keep this structure from eroding, Anthropic maintains five practices that any organization can adopt:
Tier codebases by risk and automate review by tier.
Run every new review agent in shadow mode, posting comments for human approval only until it is trusted, while red-teaming it with malicious changes.
Sample a share of automated approvals for human re-checking.
Track a dashboard of the key metrics of every security process.
Feed every agent action into the SIEM, treating agents as a new kind of insider threat and alerting when they act out of pattern.
Clinton concludes that the security engineer's job is moving from monitoring bugs to monitoring loops. He also suggests a valuable planning question: instead of asking "can we afford to scan everything?", ask "what would we run if scanning were nearly free?", because unit costs fall with every model generation.
10. An adoption roadmap, and lessons beyond the frontier labs
No organization moves to the AI-native SDLC overnight, and the playbook does not encourage it. The practical question is where to start and in which order.
10.1. Adoption order by dependency
The playbook draws a dependency graph between plays. The adoption order does not follow the order of stages: you can start with any play that has no prerequisites. Reading from the prerequisites listed in each play, a sensible four-wave roadmap emerges (Claxton, 2026). Table 2 groups the plays into four waves by prerequisite.
One principle runs through all four waves: gates come before automation. The playbook states clearly that agentic CI/CD should be deployed only after AI review and approval hooks are in place, because the gate must exist before automation accelerates everything through it.
10.2. Legacy systems and a single source of truth
Most established enterprises, especially in banking, insurance and telecoms, already have Jira, requirements-management tools, Figma and change-advisory boards that auditors and regulators have accepted. The playbook does not ask for them to be replaced. Instead, for each type of artifact, designate one system as the source of truth. There are three configurations: the repository as the source of truth (cleanest for engineering-led organizations); the legacy system as the source of truth, with Claude reading and writing back through an MCP connector; or, at minimum, two-way linking, where every artifact records the record ID and every record contains the commit ID. Linking is a safe starting point for organizations under audit.
10.3. A view from an emerging market: demand is clear, foundations still need building
Large IT services firms in emerging markets are moving fast. FPT Software, Vietnam's largest software exporter, has positioned itself as an "AI-first" company since 2025, with a platform the company says delivers up to 60% faster development, more than 50% less rework and about 30% higher productivity (FPT Software, 2026a). More than 30,000 FPT engineers use AI-enabled tools and processes, and the company has proposed a five-level maturity framework, CASAN, running from Curious and Augmented to Standard, Automated and Native (FPT Software, 2026b). These are self-reported figures and should be read as strategic direction rather than independently verified results.
Drawing on the previous sections, five practical suggestions apply to organizations that are not frontier AI labs:
Do not measure success in lines of code. The Faros AI and METR findings show that higher individual output does not necessarily raise system performance. Measure with the DORA metrics, PR cycle time, revert rate and onboarding time. Fiona Fung warns against mistaking throughput for success; the real metric is the problem you are trying to solve (Anthropic, 2026a).
Start with the "noisiest" process. Fung's advice is to pick the process that is most expensive or most dreaded by the team, ask whether it still serves its original purpose, and if so, whether it can be automated.
Put internal policy and regulation into skills. Personal-data protection, information-security rules and sector-specific financial regulation can all be encoded as skills so they apply while specifications and code are written, with deterministic hooks behind whatever is mandatory. The specific content must be confirmed by each organization's legal and compliance function.
Bring auditors in early. Intercom invited its auditor in before scaling automated approval. For a regulated bank, this means agreeing early with risk management and internal audit on what kind of evidence is acceptable.
Invest in people in new positions. As AI takes over throughput, value shifts to the two kinds of people the Claude Code team prioritizes hiring: creative builders with product sense, and engineers with deep systems expertise. For outsourcing industries that compete on the scale of their workforce, this is both a risk and an opportunity to reposition.
Conclusion: the loop runs continuously, with human judgment above it
The AI-native SDLC is not about bolting a coding assistant onto the old process. It is an admission that the software industry's entire control system (requirements documents, estimation, line-by-line review, approval boards) was designed for a world in which writing code was expensive. When that assumption no longer holds, keeping the old process means letting all the productivity gains be swallowed by the review queue, exactly as the Faros AI and DORA data show.
Three core ideas are worth carrying away. First, every stage ends with a committed artifact, and that chain of artifacts is both the input to the next stage and the audit trail. Second, controls are layered: skills make violations rare, hooks make them nearly impossible, and humans stand at the most important gates. Third, boundaries are drawn around permissions, not around trust in the model, as the incident of one agent messaging another at Anthropic demonstrated.
The real-world cases show that the model is not just theory. Intercom doubled its deployments while cutting downtime from code changes by 35%. Anthropic lets Claude write about 80% of its code while keeping the rule that every PR has an accountable human. Anthropic's CI team has a "night-shift colleague" that posts a first analysis in about 14 minutes. Yet these same organizations stress that success comes from process discipline rather than tools, and that the balance between trust and verification must be reassessed with every model generation.
Anthropic's playbook closes with an idea that is perhaps the best summary of the whole subject: the loop keeps running, and human judgment always sits above it (Claxton, 2026). The question for every organization is no longer whether to transform, but which of its processes is quietly becoming the bottleneck, and how it will start removing it this week.
References
Anthropic. (2026a, June 3). Running an AI-native engineering org. Claude. https://claude.com/blog/running-an-ai-native-engineering-org
Anthropic. (2026b, July 20). Working at the frontier: How Rakuten builds agents overnight with Claude Fable 5. Claude. https://claude.com/blog/working-at-the-frontier-rakuten
Becker, J., Rush, N., Barnes, E., & Rein, D. (2025, July 10). Measuring the impact of early-2025 AI on experienced open-source developer productivity. METR. https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/
Claxton, L. (2026, August 21). The AI-native SDLC playbook. Claude. https://claude.com/blog/the-ai-native-sdlc-playbook
Clinton, J. (2026, July 21). How Anthropic secures its AI-native software development lifecycle. Claude. https://claude.com/blog/how-anthropic-secures-its-ai-native-software-development-lifecycle
Faros AI. (2025, July 23). The AI productivity paradox research report. https://www.faros.ai/blog/ai-software-engineering
FPT Software. (2026a). FPT sets direction for tech innovation, with artificial intelligence as core enabler. https://fptsoftware.com/newsroom/news-and-press-releases/news/fpt_sets_direction_for_tech_innovation
FPT Software. (2026b, August 12). The AI-native shift: From experimental momentum to operational excellence. https://fptsoftware.com/resource-center/blogs/the-ai-native-shift-from-experimental-momentum-to-operational-excellence
Google. (2025, September 23). How are developers using AI? Inside Google's 2025 DORA report. The Keyword. https://blog.google/innovation-and-ai/technology/developers-tools/dora-report-2025/
Google Cloud. (2025, September 23). Announcing the 2025 DORA report. Google Cloud Blog. https://cloud.google.com/blog/products/ai-machine-learning/announcing-the-2025-dora-report
Malhotra, S. (2026, August 18). Claude on call: How Claude Tag serves as Anthropic's first responder for CI/CD failures. Claude. https://claude.com/blog/ai-ci-cd-on-call
METR. (2026, February 24). We are changing our developer productivity experiment design. https://metr.org/blog/2026-02-24-uplift-update/
Mykhailov, K., & Young, N. (2026, April 21). AI is approving our pull requests: Here's how we made it safe. The Intercom Blog. https://www.intercom.com/blog/ai-is-approving-our-pull-requests-heres-how-we-made-it-safe/
Stack Overflow. (2025). AI: 2025 Stack Overflow Developer Survey. https://survey.stackoverflow.co/2025/ai


Discussion about this post