Anthropic Wrote the AI-Native SDLC Playbook in August. We Wrote Ours in January.

Claude's new playbook and our CRAFT methodology landed on almost the same six-stage shape independently. Here's where they line up, where they don't, and the one part we still have to finish.

Skip: The playbook problem in reverse

Anthropic published a piece last month called the AI-Native SDLC Playbook. Six stages: Plan, Design, Build, Test, Deploy, Maintain. Each one produces a committed artifact the next stage reads: an intent doc, a spec, a plan, a running record of institutional knowledge, review findings. Governance built out of hooks that act as approval gates, subagents, parallel sessions, continuous evals, and monitoring thresholds for whatever's already in production.

Read it cold and it's a genuinely good piece of work. It's also, if you've been reading this newsletter since April, a description of something we already built.

Normally when a piece like this comes out, the instinct is to read it as validation. Somebody with more reach than us just told the world that the shape we've been running is the right shape. That instinct isn't wrong, but it isn't the interesting part either.

The interesting part is the dates.

We started designing CRAFT in the fall of 2025. It went live in pilot with client teams in January 2026. We made it public that same month, and by April we were publishing the actual artifacts: the Intent Contract, the Decision Record, the Fortify Gate. Anthropic's playbook came out in August. That's not a small gap. That's seven months between us running this in production on other people's businesses and one of the labs that builds the tools writing down the theory.

We didn't build CRAFT by reading a lab's playbook and implementing it faster. We built it by watching client engagements go sideways in the same specific ways, over and over, and designing a system to catch those failure modes before Anthropic had a name for any of them. Chuck's going to walk through exactly where the two line up, because the overlap is real and worth taking seriously.

But it's convergent, not derivative.

Chuck: What actually lines up

Skip's right that the overlap is real.

Anthropic's Plan stage produces an intent.md: a written answer to what you're building, for whom, and what success looks like, before anyone touches a keyboard. That's the Intent Contract, artifact for artifact. We published the exact template back in April, and by then it had already been running with client teams since January. Same three fields doing the same job: forcing the team to answer "what are we building and for whom" in writing before the first line of code, instead of assuming everyone in the room already agrees.

Their Design stage produces a spec.md: a more granular technical breakdown that sits between the intent and the actual build. That one doesn't have a clean CRAFT equivalent. Our Rationale phase captures decisions and the reasoning behind them through the Decision Record, but it's not the same artifact as a standing technical spec, and we're not going to pretend it is just to keep the mapping tidy. Four of the six stages line up well. This one is closer to an open question than a match.

Their Build stage leans on a CLAUDE.md file for institutional knowledge the model needs and would otherwise have to re-derive every session. We wrote about our version of that same problem in April too, under a less elegant name: how we feed Claude enough context to not embarrass us. Different file, same job.

The model doesn't know what you already decided unless you write it down somewhere it will actually read.

Their Test and Deploy stages run on hooks that act as approval gates: nothing ships until it passes a defined check. That's our Fortify Gate, published in May. Rollback plan, known failure modes, a definition of done that isn't "it compiles." Theirs is implemented as a literal hook in the tooling. Ours is a checklist a human runs. Same law underneath: no scale without fortification.

None of this is us copying their playbook or them copying ours. It's two teams staring at the same failure mode, a model that can generate code faster than any team can absorb context, and arriving at structurally similar answers because there aren't that many good answers to that specific problem. That's a stronger signal than either of us writing the playbook alone would have been.

Skip: Where it actually breaks down

Anthropic wrote a playbook for one company running its own delivery. Every stage, every gate, every artifact assumes a single codebase, a single team, a single set of institutional norms that CLAUDE.md can capture because there's one institution to capture. That's a real problem and they solved a real version of it.

CRAFT has to work across businesses we don't own. A wealth management firm. A field service company running trucks and a dispatch board. A client whose entire engineering org is four people. Every one of those teams has its own context, its own risk tolerance, its own definition of what "ships" means. The Intent Contract has to work the same way in all of them without us being in the room for most of the work. That's a multi-tenant version of the problem Anthropic solved single-tenant, and multi-tenant is the harder version. Not because their solution is weak.

Because the problem changes shape once you stop controlling the one team it has to run inside of.

We can't adopt their playbook wholesale and call it done, even where the artifacts line up one for one. The parts that transfer, transfer well. The parts that assume one company answering to itself don't. Pretending otherwise is exactly the kind of thing we'd call out if someone did it to us.

Chuck: Where we actually have work to do

Anthropic's Maintain stage is built around continuous evals and monitoring thresholds they call control bands: one, two, and three standard deviations out from expected behavior, with a defined response at each threshold. It's a real statistical discipline for knowing when a system in production has actually drifted versus when it's just noise.

CRAFT's fifth law is that learning is mandatory, and Telemetry is the phase that's supposed to carry that: measurement of outcomes, not activity. What we've built there is real, but it isn't that. We know whether the thing we shipped did what we needed it to do. We don't yet have a formal answer for what a control band looks like on a client's operational metrics, or what the automatic response is when something crosses one. That's not a small gap.

Skip: Why that's good timing, not a hole

That gap is exactly the shape of the thing we're building right now, not a place CRAFT falls short.

InTech Operate is the newest offering on our list this fall, and it's deliberately not finished. It's the piece that manages what's already in place instead of building something new, which means it's the piece that has to answer the question Chuck just raised: what does drift look like on somebody else's business, and what do you do about it automatically instead of waiting for a human to notice. We hadn't locked that design when Anthropic's playbook came out. We're locking it now, with their control-band framing sitting on the desk next to the client data we're already collecting.

That's a better position than either finishing Operate before the playbook existed, which would have meant redesigning it after the fact, or finishing it after, which would have meant admitting we needed someone else's framework to get there. We get to build it informed, while it's still genuinely in motion. I'd rather be here than either of those.

Chuck: What it says, stepping back

Two teams, working the delivery problem from opposite ends, independently landed on close to the same six-part shape: a written intent before work starts, explicit decisions, calibrated automation, a gate before anything ships, and a measurement layer after. That convergence is a better argument for CRAFT being structurally right than any client result we could cite, because it happened without either of us checking the other's homework.

The value was never in having the six stages named correctly. It was in running them on real client work for seven months before anyone outside InTech had a public framework to compare us against: finding out which parts broke under real pressure, and fixing those parts before they had a name.

It also raises the bar. Before August, "measure outcomes" was a defensible answer for the Telemetry phase because nobody had published a sharper one. Now somebody has, in public, with specifics.

We're finishing Operate against that bar, not around it.