Skip to content
ReadMe Daily

Search articles, problems, patterns and every cheat sheet topic.

The AI-Native SDLC, Explained With Examples

What an AI-native software development lifecycle looks like, walked through one small feature from brief to production, with the failure modes to watch for.

· 12 min read

An AI-native software development lifecycle is one where AI does the first draft of most of the work at every stage — the plan, the code, the tests, the release notes, the incident summary — and the engineer's job shifts from producing that work to specifying it clearly and verifying it properly.

That one sentence hides the whole difficulty. Writing code was never the slow part of software; deciding what to build and being confident it works were. AI-native development makes the fast part nearly free, which means the slow parts now dominate completely. Teams that understand this redesign their process around specification and verification. Teams that do not simply generate bad software faster.

AI-assisted is not the same as AI-native

Nearly everyone is AI-assisted now. Google's 2025 DORA report surveyed close to 5,000 technology professionals and found AI adoption at 90%, with a median of about two hours a day spent working with it. But adoption is not the same as redesign. Most of that 90% is an autocomplete inside an otherwise unchanged process.

AI-assisted AI-native
Where AI sits Inside the editor, suggesting lines Across the lifecycle, producing whole units of work
Unit of work A function, a block A branch, a pull request, a migration
What the human writes Most of the code The brief, the constraints, the acceptance checks
What the human does most Types Specifies, reviews, decides
Context the AI has The open file The repo, its conventions, its tests, its docs
Main bottleneck Typing speed Review and verification capacity
Process changes needed None Substantial

The last row is the honest one. You can be AI-assisted on a Tuesday afternoon. Being AI-native means changing how work is described, reviewed and merged.

One feature, all the way through

Abstract descriptions of this are useless, so here is a single small feature carried through an AI-native lifecycle: let customers export their invoices as a CSV file. The codebase is an ordinary billing application — a Node.js API, a React front end, Postgres.

Stage 1: intent, written down before anything is generated

The most common failure in AI-native work happens in the first thirty seconds, when somebody types this:

Add a CSV export for invoices

That is not a brief, it is a wish. The model will invent answers to every question you did not ask: which columns, which date format, whether it streams or buffers, what happens with 400,000 invoices, who is allowed to call it. You will then discover those invented answers one at a time in review, which is the slowest possible place to discover them.

The AI-native version writes the brief down first, as a file in the repo so it can be reviewed, versioned and fed to every later stage:

# Feature: invoice CSV export
 
## Goal
A customer can download their own invoices as CSV from the billing page.
 
## Must be true
- Only invoices belonging to the authenticated customer are included.
- Columns: invoice_number, issue_date, due_date, currency, net, tax, gross, status.
- Dates are ISO 8601 (YYYY-MM-DD). Money is decimal with 2 places, never a float.
- Works for an account with 500,000 invoices without exhausting memory.
- Fields are escaped so a value containing a comma, quote or newline survives a round trip.
- A leading =, +, - or @ in a text field is neutralised (CSV injection).
 
## Out of scope
Scheduled exports, XLSX, exporting other customers' data for support staff.
 
## Acceptance
Tests exist for: authorisation, escaping, the injection cases, a 500k-row
streaming test, and an empty-result export that still emits the header row.

Notice how much of that is not a feature description at all. It is the set of decisions a reviewer would otherwise have had to make, one comment at a time, after the code already existed. Writing it first is the single highest-leverage change in an AI-native process, and it is the part teams skip most.

Stage 2: plan before diff

With a brief, the next step is not "write the code". It is asking for a plan and reading it. A plan is a few hundred tokens and takes ninety seconds to check; a wrong implementation is a thousand lines and takes an hour to unpick.

A good returned plan is specific about where things go and what it will touch:

1. src/services/invoices/exportCsv.ts — new. Async generator yielding CSV rows.
2. src/db/invoices.ts — add streamInvoicesForCustomer(customerId) using a
   cursor, not findAll(), so memory stays flat.
3. src/routes/billing.ts — GET /billing/invoices.csv, auth middleware,
   Content-Disposition attachment, pipes the generator to the response.
4. src/services/invoices/csv.ts — new. escapeCsvField() handling quotes,
   commas, newlines and the formula-injection prefixes.
5. Tests alongside each. Fixture generator for the 500k-row case.

This is where you catch the expensive mistakes. If step 2 had said findAll(), you reject the plan in five seconds. In an AI-assisted workflow you would have found that in production, when a large customer's export took the API server down.

Stage 3: build in verifiable steps

The build stage is the part people imagine when they hear "AI-native", and it is the least interesting. The agent writes the code. The thing that matters is the size of the step between checks.

// src/services/invoices/csv.ts
const NEEDS_QUOTING = /[",\n\r]/;
const FORMULA_PREFIX = /^[=+\-@\t\r]/;
 
export function escapeCsvField(value) {
  let field = value == null ? "" : String(value);
 
  // A leading =, +, - or @ makes a spreadsheet treat the cell as a formula.
  if (FORMULA_PREFIX.test(field)) {
    field = `'${field}`;
  }
  if (NEEDS_QUOTING.test(field) || field !== field.trim()) {
    return `"${field.replace(/"/g, '""')}"`;
  }
  return field;
}

Ten lines, one job, independently testable. An agent given the whole feature at once will happily produce 600 lines that look right and fail on the fourth bullet of your brief. Given one bounded piece with a test to satisfy, it produces something you can actually check. Short cycles beat long ones, for exactly the same reason they do with human engineers.

Stage 4: verification is now the real job

If AI writes the code, the tests cannot be an afterthought written by the same process that wrote the bug. In an AI-native lifecycle, tests are the executable form of the brief, and they are where your scepticism lives.

test("a comma, quote or newline survives a round trip", () => {
  const value = 'Acme, "Ltd"\nBerlin';
  const parsed = parseCsv(`field\n${escapeCsvField(value)}\n`);
  expect(parsed[0].field).toBe(value);
});
 
test("a formula prefix is neutralised", () => {
  expect(escapeCsvField("=cmd|' /c calc'!A1")).toBe("'=cmd|' /c calc'!A1");
});
 
test("export streams without buffering the whole result", async () => {
  await seedInvoices(500_000);
  const before = process.memoryUsage().heapUsed;
  await consume(exportInvoicesCsv(customerId));
  expect(process.memoryUsage().heapUsed - before).toBeLessThan(64 * 1024 * 1024);
});
 
test("a customer cannot export another customer's invoices", async () => {
  const response = await request(app)
    .get("/billing/invoices.csv")
    .set("Authorization", bearer(customerA));
  expect(rowsIn(response.text)).not.toContainInvoicesOf(customerB);
});

Those four tests are the four lines of the brief that would actually hurt you. Generating tests with AI is fine and saves real time; accepting them without reading them is not, because a test that asserts the current behaviour of buggy code passes forever and tells you nothing.

The useful habit here is to make the agent prove it, not claim it. "I've added the tests and they pass" is a sentence, not evidence. The run output is evidence.

Stage 5: review shifts from lines to decisions

Review is where AI-native teams jam up. If one engineer can open five well-formed pull requests a day, a team of six produces thirty, and review capacity becomes the constraint on the entire organisation. Shouting "review faster" does not work.

What works is splitting review into two jobs:

  • Machine review handles what machines are good at: diff-level bugs, missed error handling, inconsistent naming, unhandled edge cases, obvious security slips. Run it automatically on every pull request, before a human opens it.
  • Human review handles what only a human can: is this the right thing to build, does it fit the architecture we want in two years, is this abstraction load-bearing or decorative, does this change what we promise customers?

The pull request description should make the second job fast. It should say what the brief was, what the agent decided and why, what was not done, and what the reviewer should look at hardest. A good AI-native PR body ends with something like "the streaming change alters connection-pool behaviour under load — that is the risky part, look there first."

Stage 6: ship and operate

The same pattern continues past the merge. Release notes drafted from the diff and the brief. A canary deploy where the thing watching the error rate can also read the diff that caused it. When an alert fires at 03:00, a first-pass summary that correlates the spike with the deploy, names the three likeliest commits and links the relevant logs — so the human who wakes up starts from a hypothesis rather than a blank terminal.

None of this removes the on-call engineer. It removes the first twenty minutes of every incident, which is usually spent assembling context that a machine can assemble faster.

The context layer: why this works at all

An agent that does not know your conventions will invent plausible ones, and plausible-but-wrong is the characteristic failure of this whole way of working. The fix is boring and mechanical: write the conventions down, in the repo, in a file the tools read automatically.

AGENTS.md has become the common format for this — a Markdown file at the root of the repo, stewarded under the Linux Foundation and read by most major coding tools. Claude Code reads CLAUDE.md for the same purpose, as the Claude cheat sheet sets out. The content matters more than the filename:

## Commands
- `npm test` — unit tests. `npm run test:e2e` needs Docker running.
- Never run migrations against staging. Ask.
 
## Conventions
- Money is `decimal`, never a float. Use the Money helper in src/lib/money.ts.
- Timestamps are UTC in the database, formatted at the edge only.
- No new dependencies without asking.
 
## Gotchas
- src/legacy/* is generated. Edit the generator, not the output.
- The invoices table is sharded by customer_id. Any query must include it.

That last line is worth more than a thousand words of prompting. It is the kind of knowledge that lives in a senior engineer's head and nowhere else, and writing it down helps the humans too. This is why the DORA researchers describe AI as a mirror and a multiplier: a team with clear conventions, fast tests and loosely coupled services gets a large multiplier, and a team with none of those gets their absence reflected back at them at speed.

Where it goes wrong

Failure What it looks like What to do
Plausible-but-wrong Confident code that misses a requirement nobody stated Write the brief and acceptance checks first
Review bottleneck PRs pile up; reviews become rubber stamps Machine review first, humans on decisions
Volume without value Lots of merged changes, no improvement in outcomes Measure delivered outcomes, never lines or PR count
Unverified tests Tests generated from the buggy code, asserting the bug Read every test; write the hard ones yourself
Context rot AGENTS.md describes last year's architecture Update it in the same PR that changes the thing
Skill erosion Nobody on the team can debug the generated code Keep humans doing the hard debugging
New attack surface Prompt injection via issue text, logs or fetched pages Follow the OWASP LLM Top 10; treat all fetched content as untrusted

That last row is genuinely new and often overlooked. The moment an agent reads a GitHub issue, a web page or a log line and then acts on it, that text is an input to a system with write access to your repository. The normal rule applies with full force: data from outside is never instructions. The general principles in how to secure a website — validate input, least privilege, never trust the client — map onto agent design almost unchanged.

Adopting it without a big-bang rewrite

In order, because each step makes the next one worth doing:

  1. Write the context file. One afternoon, AGENTS.md, the commands and the three gotchas that bite every new joiner. It pays back immediately, including for humans.
  2. Make the test suite fast and trustworthy. Everything downstream depends on verification being cheap. If the suite takes forty minutes or is flaky, fix that before anything else — you are about to lean on it very hard.
  3. Adopt briefs for one team. Nothing else changes. Just stop starting work from a one-line prompt.
  4. Put machine review in CI so humans never see the trivial findings.
  5. Then raise the unit of delegation — whole features, migrations, refactors.

Doing step 5 first is the characteristic mistake, and it produces exactly the outcome sceptics predict: a flood of confident, unreviewable, subtly wrong code.

Checklist

  • Every piece of work starts from a written brief with explicit acceptance criteria.
  • The plan is reviewed before the diff exists.
  • Conventions, commands and gotchas live in a context file that is updated with the code.
  • Tests are read by a human, and the hardest ones are written by a human.
  • Claims of success are backed by command output, not by assertion.
  • Machine review runs before human review, and humans review decisions rather than lines.
  • Agent-visible external content is treated as untrusted input.
  • Success is measured in delivered outcomes, not in volume of generated code.

The through-line is simple. AI-native development does not mean the machine does the thinking. It means the thinking moves to the two ends — a clear statement of what is wanted at the front, and genuine verification at the back — while the middle gets very fast. Teams that only speed up the middle are not AI-native. They are just producing more of whatever they were producing before, including the mistakes.

Further reading