Code is no longer the bottleneck
The expensive step in your business is about to get cheap. That's not the problem. The problem is that everything around it was designed for when it was expensive. Anthropic released The AI-Native SDLC Playbook last week — a stage-by-stage guide to how engineering teams now plan, design, build, test, deploy and maintain software with AI in every step.
It's written for engineering leaders. Most SMB owners will skip it.
Skip it and you'll miss the most useful thing published about AI this year.
Because the argument underneath it has nothing to do with code.
The one line worth stealing
Their opening claim: code is no longer the bottleneck.
Teams are producing code faster than anyone thought possible a year ago. But the approvals, the handovers, the sign-offs, the review meetings — all unchanged. So the gains stall.
Then they name the three consequences, and this is the part that applies to every business in Australia:
The bottleneck moves sideways. The build step collapses to hours. The steps either side of it still run at human speed. Nothing gets faster.
The controls stop matching reality. Checking every line by hand made sense when a person wrote every line. It doesn't survive the new volume.
Governance gets more expensive. Exceptions still route through a committee that meets on Thursdays.
Now swap "code" for whatever your expensive step is.
The quote. The report. The care plan. The proposal. The compliance pack. The scope of works.
That step just got cheap. Your process around it didn't.
Your business already has an SDLC
You don't call it that. But you have one.
Something gets requested. Someone works out what it means. Someone builds it. Someone checks it. It goes out. Someone deals with what comes back.
Six stages. Same as theirs. Here's what the playbook's shift looks like in operational language.
Stage | How you run it now | What AI-native looks like |
|---|---|---|
Request | Client rings, someone takes notes, it sits in an inbox until Wednesday | The person closest to the problem describes it to AI in their own words and walks away with a written one-page brief |
Scope | The senior person interprets the brief, often days later, often differently to last time | Brief and scope collapse into one working session, with your standards applied while it's written — not discovered in review |
Build | Done from experience, quality varies by who's on it | Produced against a written plan, using your documented way of doing it |
Check | Someone senior reviews it if they have time | The work is checked against a defined standard before a human sees it |
Deliver | Sign-off happens where it always happened | Routine work flows; a named human still approves the things that carry real risk |
Learn | The lesson stays in someone's head | The correction gets written down once and applied automatically from then on |
Note what didn't change: a human still owns every decision that requires judgement.
The playbook is blunt about that. Approval gates don't disappear. They move to where they matter, and they stop clogging up where they don't.
Three things they got right that most SMBs get wrong
1. Write the intent down, in the originator's own words
Their first artefact is a plain-language file describing what's wanted, why, and under what constraints. Written by the person who had the idea — not translated by three people first.
Most SMBs run on a request that starts in a phone call and gets reinterpreted at every handover. What reaches the person doing the work is several steps removed from what the client actually asked for.
That's where your rework comes from. Not from the doing. From the interpreting.
2. Institutional knowledge becomes a file the AI reads
The playbook's most transferable idea: the things your best operator knows — the conventions, the commands, the mistakes people keep making — get written into a file that the AI reads at the start of every session. When someone makes the same mistake twice, the correction goes into the file.
This is Skills in Anthropic's language. It's Tacitree in ours.
Same principle either way: knowledge that lives in a head is a dependency. Knowledge that lives in a file is an asset. One walks out the door. The other compounds.
If you get one thing from that entire playbook, get this one.
3. Give the AI a way to check its own work
This is the step almost every SMB skips.
Engineering teams give the AI a test to run, a build to pass, a screenshot to compare against. It fixes its own errors before a human ever sees the output.
Most SMBs give AI no way to check anything. Which means a person checks all of it. Which means that person is now the bottleneck — and they were the one you were trying to free up.
Define what "correct" looks like, in a way that can actually be checked, and the review load drops. Skip that and you've just moved the work.
The governance part matters more here, not less
If you're in aged care, in trades, in anything with a regulator, this is where the playbook earns its keep.
Every stage ends by writing something down that the next stage picks up. The chain of records is the audit trail: who asked for what, what the AI produced, who approved it.
You already need that trail. You're probably assembling it by hand after the fact.
Done properly, the trail is a by-product of the work rather than a separate job. And your compliance rules get applied while the work is being done — not found in a review three weeks later when fixing it is expensive.
The non-technical route in is Cowork rather than developer tooling. The stages are the same; the tools differ by who's doing the work.
The uncomfortable bit
Your process was optimised around your expensive step.
That step is getting cheap. Which means the process is now the cost.
Buy an AI tool and drop it into that process and you'll get a faster version of the same bottleneck. You'll feel productive. Your cycle time won't move.
Smart AI in a broken process is still a broken process.
Three moves for this month
Pick your expensive step. The one thing that takes longest and holds everything else up. One, not five.
Map what sits either side of it. How long does the work wait before it starts, and after it's finished? For most businesses we audit, the waiting is longer than the doing. That's the real number.
Write down one thing that only lives in someone's head. How you price a variation. What makes a care note compliant. What you check before a job is called finished. One page. That page is where your AI capability starts.
The playbook closes on a line worth keeping: <q>The loop keeps running. Human judgement stays above it.</q>
That's the whole design. AI runs the loop. You stay above it.
If you want help finding which step is actually your constraint — and what to fix before you automate anything — that's exactly what the AI Discovery Workshop is for. Fixed price, fixed scope, one clear answer at the end.
No jargon. No hype. No sales pitch.