Anthropic's AI-Native SDLC Playbook Leaves Architecture Enforcement Unaddressed

What the playbook proposes

A recent post on dev.to examines Anthropic's newly published AI-native software development lifecycle playbook and largely endorses it. The playbook's premise is that agent-written code has shifted the bottleneck: generation is fast now, while planning, review, security sign-off and release still move at human pace. As the dev.to author frames it, once agents produce most of the diff, that mismatch resolves one of two ways — review queues pile up until the velocity gains evaporate, or code lands with thinner scrutiny than it needs. Neither is tolerable in a regulated environment, and neither is attractive anywhere else.

Anthropic's answer is structural. Each stage commits an artifact the next stage consumes — an intent document, a spec, a plan, the diff with its tests, the PR carrying review findings, the incident record — so the commit chain doubles as the audit trail. Human attention concentrates on the gates between stages instead of being spent rebuilding context at every handoff.

An escalation from advisory to deterministic

The analysis singles out the playbook's progression of control mechanisms: CLAUDE.md files holding versioned, PR-reviewed conventions read at every session; Skills, which encode policy once and apply it broadly but remain advisory; Hooks, the deterministic layer that blocks actions before they complete; and evals plus CI that regression-test the configuration itself. The distinction the author draws is that guidance makes violations rarer, while deterministic checks make them nearly impossible — and when the largest agent vendor effectively tells enterprises that mandatory policies need a machine-enforced backstop, that debate is settled.

The gap: architecture doesn't reduce to paths

The playbook's hook examples are path-scoped — protecting a generated-code directory, running formatters, keeping credentials out of diffs — and they work because rule and trigger coincide. Architectural decisions don't. Constraints like a service running PostgreSQL rather than SQLite for concurrency reasons, dependencies pointing inward, tokens issued only through a single auth boundary, or a deprecation applying to checkout but not yet billing each depend on the decision, its scope and the proposed action simultaneously. A rule can bind absolutely in one subsystem and be irrelevant in another, and a newer decision can supersede an older one for part of the codebase. That is evaluation, not string matching.

ADRs as the fourth control

Most teams already record these decisions as architecture decision records, which fit the playbook's artifact chain naturally. The proposal is to compile the ADR corpus into structured, scoped, precedence-aware constraints and resolve them deterministically against every proposed change, letting the verdict drive whatever hook the harness offers.

Two design constraints matter. First, retrieval is useful context but similarity search must not be the arbiter — when one ADR supersedes another, precedence has to win every time, not embedding rank. Second, because the check runs before the action, every verdict produces evidence of which decision was evaluated and why it passed or was blocked, turning drift prevention into a mechanism rather than an aspiration. The author also argues the policy layer needs persistence beyond any single session, independence from any one agent harness, and real governance semantics such as exceptions with expiry and a queryable verdict history.

Why it matters

The playbook itself notes, in discussing parallel sessions, that controls must increasingly live in shared repository configuration because no engineer can personally supervise every concurrent agent stream. Hooks already give operational guardrails that home; architectural policy is the unfinished remainder. Lined up, the resulting control surface reads: intent governs what gets built, tests whether it works, security whether it is safe, and architecture whether the implementation still matches the system's intended shape.

The recommended move is additive rather than adversarial — keep the artifact loop, keep skills and hooks, add compiled ADR constraints on top. One caveat worth weighing: the author is building Mneme, a product aimed squarely at this gap, so the critique doubles as a pitch. The argument about advisory versus deterministic enforcement holds either way, and teams adopting agent-heavy workflows will have to settle the same question soon.