Skip to content
Playbook · edition 1.7 · 58 pages · free, no email

Keep your quality while AI writes more of your code.

AI writes more of your code every month and you are still the one who has to read all of it. Two ceilings, six practices and the lifecycle around the code, all of it from running an AI-operated delivery process on a live product past 165,000 lines as at 2 August 2026, including the parts that went badly, which are the useful parts.

No email required. Nothing gated. If you take all of it and never speak to us, the playbook has done its job.

Cover of The AI SDLC Playbook, full edition: two ceilings, six practices, and the lifecycle around the code.

The six practices on a page

Each has a first move you can make this week and a first number to watch. None needs our software. Press a practice to read it.

  1. First move
    Write the sentence a customer would say when it works
    First number
    Journeys defined, and journeys completing
  2. First move
    List what your coverage number excludes
    First number
    Coverage of changed lines
  3. First move
    Add “Waiting” and “Blocked” states and move items where they belong
    First number
    Active share of elapsed time, per stage
  4. First move
    Sort blocked items to the top, with their age
    First number
    Blocked now, and the median age
  5. First move
    Recompute the number you would be most embarrassed to find wrong
    First number
    Places a metric is typed (target: one)
  6. First move
    Make one guard fail on purpose and see whether it catches it
    First number
    Share of changes blocked by each rung

The full edition

The page below is the short version. The full edition is the one to keep: 18 chapters and 7 appendices, one for each practice with how to start, how to measure it and the anti-patterns, and the failure from our own record that taught us the rule. Then the lifecycle around the code, the pilot in which one real requirement needed 12 manual interventions, the 60 findings behind it, a self-assessment, a 30, 60 and 90 day plan, and 9 templates. 6 figures, and the whole playbook on page 2. Every chapter opens with what you will be able to do and ends with something you can do in ten minutes.

Three pages of it as they are, so you can judge the level. Press a page to open it full size.

  • Page 2 of the playbook: the six practices on one page, each with what it defends against, the first move and the first measure, and a table of where to start for what you have today.

    Page 2. The playbook on a page, and where to start for what you have today.

  • A chapter page of the playbook showing the six-rung reviewer ladder as a figure, with the table of what each rung establishes.

    A chapter page. Each chapter opens with what you will be able to do, the one idea to keep, and a ten-minute exercise.

  • The 30, 60 and 90 day plan from the playbook as three columns: make it visible, make it enforced, make it systemic.

    The plan. Thirty days of measurement and no new tooling, then enforcement, then a process that examines itself.

Who it is for

  • Engineering leads

    You own how work reaches production and need the gates, the board and the metrics to hold as AI writes more of it. Part II, and the reviewer ladder.

  • Founders and owners

    You cannot read every change and need to know the product works for a person. Practice one, the self-assessment, and the thirty-day plan.

  • The process owner

    You hold the gates and hear every “this check is wrong”. Part III, the metric definitions, and the record of what broke in ours.

1The two ceilings

Coding was never the only process in building software, just the one that got faster first. Requirements, design, security review, testing and release are most of the real work, and none of them sped up because generation did. Point AI at “write the feature” without touching the rest of the lifecycle and you have handed a slower pipeline more raw material than it can absorb.

Your reviewer is your throughput

AI can 10× how much code gets written. It cannot 10× how much a human can safely review. If every line still passes through one person's eyes, that person's reading speed is your real ceiling — no matter how fast the model is.

It degrades exactly where you are going

AI is excellent on day one: a blank file and an afternoon get you a week of senior work. Real products cross into six figures of lines, where parts depend on each other in ways nobody wrote down. The model does not get worse — the blast radius of confidently wrong grows with the codebase, and nothing tells you unless something is built to.

Generation capacity rises steeply while review capacity stays flat; the widening gap becomes unreviewed code.AI tooling adoptedmonths latervolumecode generatedcode safely reviewedthe gap shipsanyway
The gap is not idle work. It is code that ships having been read less carefully than the code before it. We think that is what the 1.7× figure is measuring, though the study reports the association and not the cause.

Those were written in July 2026. The industry has since measured the same thing:

Published figures, directional rather than audited. Three of the four come from the same 2026 analysis; the first is a separate preprint. Every one is linked so you can weigh it yourself.

2Green tests can sit over a broken product

Our test suite passed. Coverage was at 80%, the figure on our published board as at 2 August 2026. Every gate reported success — and two screens were failing to load, with exactly one of nine customer journeys completable end to end.

That is not a criticism of testing; it is the definition of it. A test encodes an expectation, and an expectation is something a person had. The failures that hurt are the ones nobody expected, which is precisely the set no test covers. More tests push the boundary outward, and the boundary never closes.

The practice: add one check that asks whether a real person can finish the job on the running system, and let it block a release.

It is the one signal that cannot be satisfied by writing more code to satisfy it. If you do nothing else on this list, do this.

3Gates must tighten as the codebase grows

What was good enough at 5,000 lines is not good enough at 165,000. The number of ways a system can be broken grows faster than the system does, so a fixed quality bar is a falling one — and it fails quietly, which is the worst way to fail.

The practice: make at least one threshold a function of size.

Coverage requirements, review depth, how much of the system a change may touch without extra scrutiny. This is unpopular with anyone who wants a stable definition of done, and it is the only version that stays honest as the product grows.

4Idle is a status to report, not hide

Every delivery process has idle time. Processes that hide it do not have less of it; they have the same amount plus a reporting layer that obscures where it went.

The practice: put “idle, zero done” on the board in plain text when it is true.

It changes behaviour faster than any stand-up, because it is visible without anyone having to raise it — and raising it is exactly what people avoid doing.

We also got this one wrong, and it is the best example we have. Our scorecard printed a share of elapsed time spent working: 28% on 2 August, then 3% on 28 October. Both were withdrawn on 31 October 2026. The scorecard divided the average time a resolved ticket took by that time plus the average age of the tickets still open. They are different tickets. On 28 October the “idle” side was the average age of about two dozen open tickets, not time spent waiting inside the resolved ones, and it grows by itself as a backlog ages. It said nothing about how much time anyone or anything spent working. The ticket system records two times per ticket, created and resolved, so it cannot say how long a ticket was worked on or waiting. A correct per-ticket figure needs the state changes recorded.

What we can measure is the work itself, from Claude’s own logs. Between 5 September to 31 October 2026 Claude worked on 51 of 57 days, about 100 hours in all, and about a fifth (20% to 22%) of that ran on a branch that names a ticket. The rest was the website and other work no ticket records, so a ticket board saw a fifth of it. The figures and how they were read are on the board page. The practice stands, and so does its price: record the state changes, or you will measure something else and believe it.

5Blocked should be the loudest thing on screen

Blocked work is the most expensive state in any pipeline and usually the least visible. It surfaces at the next stand-up, or in a status report, or three weeks later when someone asks why a feature never shipped.

The practice: blocked work shows the day it blocks, at the top, before anything green.

6Recompute metrics, do not remember them

A number updated last Friday is a story, not a fact. Any metric maintained by hand drifts from reality at exactly the rate that makes it dangerous: slowly enough to keep trusting, fast enough to be wrong when it matters.

The practice: derive every number from the work record, and show the ones that do not flatter you.

Ours, on the position as at 2 August 2026, reports that 43% of work was later redone — a figure we publish with the caveat that there is no published industry norm to compare it against, so treat it as our own watch item and not as a benchmark you have beaten. The same board shows queueing time rising as more work ran in parallel; we can show the direction and not a magnitude we would defend, so take it as a direction. Publishing both is not humility, it is self-interest: a board that can only show good news tells you nothing on the day something goes wrong, which is the only day you urgently needed it.

7Multiply reviewers, not the reviewer

This is the answer to the first ceiling. If every line passes through one person, that person is your throughput — and hiring another of them is slow, expensive, and the reason you reached for AI in the first place.

The practice: build a ladder. Automated checks that block on failure, then narrow human judgement only where judgement is genuinely required.

Ours is six checks: code health and secrets, tests, integration, a full rebuild with a vulnerability scan, a sampled score of what the AI actually produced, and finally whether a person can finish the job. A human still decides — on a much smaller surface.

A change passes through six gates; any one can stop it, and only a change clearing all six reaches production.changeyour product1Code health2Tests3Integration4Whole system5AI output6Real journeystopped here → back to the author
Six is the one that cannot be satisfied by writing more code to satisfy it: it asks whether a person can finish the job on the running system.

8The lifecycle around the code, and what broke

The six practices live inside a longer path. Most AI-assisted teams put AI at the code and leave the rest as it was, and the largest gain turned out to be in the stages before it: a chain from a requirement to a ticket that someone could build without asking, with every link naming its parent and a readiness gate that refuses a story whose chain is broken.

Understand
  1. S0IntakeA requirement, with an id
  2. S1Understand what existsEvidence, with its unknowns listed
  3. S2ExploreA brief
Define
  1. S3RequirementsOwner acceptsA specification
  2. S4SolutioningLead acceptsDesign and decision records
  3. S5BacklogEpics and stories, each falsifiable
  4. S6Readiness gategateReady, or bounced. Fails closed
Build
  1. S7Build in a fenceOwn copy, own branch, enforced boundary
  2. S8Review and testLead reviewsSix checks, then a person
Learn
  1. S9Close and adaptRetrospective ending in decisions
  2. S10KnowledgeWhat was learned, linked to its source
Six practices run through all of it
  • 1A person can finish the job
  • 2Gates tighten with size
  • 3Idle reported
  • 4Blocked loudest
  • 5Metrics recomputed
  • 6Reviewers multiplied
Every stage names its parent by id. A person holds the decision at three places; everywhere else, a check that can fail does.
The AI SDLC eleven-stage lifecycle, S0 Intake to S10 Knowledge. For each stage, three columns: what AI does well, what needs fencing, and what stays human. For example S7 Build: AI writes code and tests, the fence is a remit and boundary check, and a person keeps oversight. The same table is printed below the picture.
The same eleven stages, by what AI does well, what needs fencing and what stays human. Read across a row: the middle column is the check that makes the left one safe to rely on, and the right one is the decision we do not hand over.
Read it as a table
The eleven stages: what AI does well, what needs fencing, what stays human
StageWhat AI does wellWhat needs fencingWhat stays human
S0 IntakeClassify & deduplicateGuard inventivenessVerify intent & value
S1 UnderstandSummarize codebaseGuard narrative driftValidate picture
S2 ExploreExplore & draftConstrain scopeDefine goals
S3 RequirementsDraft & check citationsVerify citationsScope & acceptance
S4 SolutioningPropose optionsEnforce design patternsCore design decision
S5 BacklogSlice into storiesAvoid untestable slicesPriority & backlog
S6 Readiness GateCheck dependenciesBlock if incompleteRelease readiness
S7 BuildWrite code & testsRemit & boundary checkOversight
S8 Review & TestMulti-lens first passReview verificationThe merge decision
S9 Close & AdaptSummarize retroVerification of claimsAdjust process
S10 KnowledgeLink knowledgeTracked source linksCurator approval

We redesigned our own lifecycle this way in October 2026, then ran it on itself. The record is in the full edition, including the parts that went badly. One real requirement went through the whole chain on 22 October 2026 and needed 12 manual interventions: 6 were factory defects, fixed during the run; 4 more were still open when we wrote it up and were fixed the next day (ODSF-264, ODSF-265, ODSF-266, ODSF-267, closed 23 October 2026); 2 were human gates working as designed. We have not re-run the pilot, so we cannot yet say the same path now needs fewer. The log of findings from the build stands at 60 as at 28 October 2026. The most common shape among them is something reporting success for a reason that was not success: a boundary check that found nothing to enforce, a ticket marked done for work that never landed, a build that hit its turn limit and reported ok.

We would rather you saw the number 12 than a demo with none. It is also the most transferable thing here: build a lifecycle from parts and the first month goes on the joins between them. The pilot, step by step →

9Secure development: check what the build depends on

AI-assisted work adds dependencies faster than anyone reads their advisories: a model writes a package name and a version from memory. The cheapest place to notice an exploited dependency is where it is declared, so we added one check to the build. It reads a project’s manifests (requirements, package.json, Maven, Gradle, Cargo, CMake, Dockerfiles and compose files), asks Latticeabout CISA’s exploited vulnerabilities, and compares each declared package with the product CISA names. It runs the same way on a laptop and in CI, with make dep-scan in every product the factory builds.

Our first run, on 2 November 2026: 7 projects, 99 manifest files, 2,964 declared components, 2,523 of them pinned to a version, against 9 named exploited CVEs. 13 declared packages matched an exploited product. None was inside an affected range, 5 were outside every range and 8could not be judged. Five of those eight were the scanner’s own mistake (a client library with the server’s name), which is why it now has a separate verdict, lead. 3 remain, each with a written reason.

Read the answer as evidence, never as a verdict: it says what a manifest declares, not what is deployed, and it does not say a project is safe. Without a key you can name the CVEs you care about; with a key whose email is confirmed it reads the whole CISA list. It is a command a person runs in our factory today, not yet a gate that blocks a merge. The method, the numbers and the mistakes are in Appendix G of the full edition, and the guide to the command line, the skill and the MCP has a CI recipe. The deployment step has a check too: the same tool, without its project subcommand, reads the packages, snaps, running images (their operating system and packages) and kernel of the server a release lands on (Appendix G.6). The graph it reads is Lattice, and the package is on PyPI and in the signed apt repository.

10What to adopt on Monday

Cheapest first. The first two cost an afternoon between them, and the last takes ten minutes.

  1. Put blocked at the top of your board. A sort order change. Costs nothing.
  2. Report idle honestly for two weeks. Do not act on it yet. Just look at it.
  3. Pick one number and recompute it from source. Whichever one you would be most embarrassed to find is wrong.
  4. Add one end-to-end journey check for the single path that matters most, and let it block a release.
  5. Sample AI-written changes and score them. Ten a week is enough to see a trend.
  6. Tie one threshold to codebase size so the bar moves without anyone having to argue for it.
  7. Scan one project’s declared dependencies against two CVEs that matter to you, and read every row.

None of this requires our tooling, and we would rather you did it yourself than hired anyone. The one thing worth reading next is what happens when a team actually runs all six: our own board, as at 2 August 2026, with the rework and queueing rows left in. It is the only page here that is mostly numbers, including the ones we would rather not print.

Questions

Is it free?
Yes, and there is no email step. The web page and the full edition are open.
Do I need your software?
No. Nothing in the six practices needs it, and we would rather you did them yourself than hired anyone.
Is it a benchmark?
No. The product the numbers come from is our own, where we set the scope and chose the stack, which is the friendliest case there is. Discount it accordingly.
How current is it?
Edition 1.7, 2 November 2026. Scorecard figures are as at 28 October 2026, ticket status as at 30 October, and the board capture is 2 August. Every figure carries its date, and the ones we have not reconciled say so.
Can I share it?
Unaltered, with attribution. The cover says so.

Only once you have run the six steps yourself.

This is not the next step for anyone who arrived here two minutes ago — read the board first. If you have already worked through the list, found the number you did not want to find, and would rather not build the machinery around it yourself, that is when read access to one system is worth giving us. If the playbook was all you needed, that is the better outcome and it costs you nothing.

Talk to us