The Coding Station Got Faster. The Factory Did Not.

AI made writing code dramatically faster. Most companies, including mine, have not seen the business get proportionally faster. I think I know why.

Suppose coding is about 10% of the time it takes to deliver software. Make coding instant and you improve delivery by about 10%. The rest of the time sits in waiting, handoffs, rework, setup, missing context, dependencies between teams and managing risk.

We sped up the coding station and left the rest of the factory alone. That is why AI feels transformative at the keyboard while the organization barely moves.

Five problems

1. Work gets cut into small stories for human coordination before AI has looked at the whole problem and the whole codebase.
2. Context is copied across wikis, tickets, repositories, meetings and people's heads, and then it drifts.
3. Teams keep asking other teams for interpretation or approval because ownership and interfaces are unclear.
4. Unsafe or undocumented codebases absorb AI speed as defects, rework, incidents and cost.
5. The process rewards sprint activity and local completion more than intent-to-value, reliability and unit economics.

The result is predictable. Teams get faster at producing fragments without getting faster at delivering ambitious outcomes.

Large intent, small blast radius

The principle I want to run on is large intent, small blast radius. People own the ambition, the choices, the constraints, the economics and the risk. AI owns the codebase analysis, the decomposition, the implementation, the tests, the documentation and the routine coordination. Releases stay small and reversible.

Here is what that means in practice.

The mission is the unit of delivery. A mission is an ambitious, measurable outcome with one accountable owner and one empowered team. Stories can still exist. They get generated from the mission after AI has analyzed the code. One major mission per team at a time wherever we can.

One executable mission package. Objective. Success and failure signals. Non-goals. The happy path. Truths the system must never violate. Known traps. Interfaces and contracts. The choices made and the ones rejected. Tests. A cost and reliability envelope. Release and rollback. Owners. Write it once, in version control, and generate the ticket, the status and the release notes from it. Single writer, many projections.

Spend human time on choices. More specification should mean better decisions, and longer documents do not get you there. A short workshop that produces a prototype, the contracts, examples and acceptance tests beats weeks of prose. AI can fill implementation gaps. It must never invent business truths, security assumptions or irreversible product decisions.

Contracts instead of check-with-others. Every important service publishes an AI-readable contract: owner, interfaces, invariants, what can change, tests, cost and known traps. Changes inside the contract need no meeting. Changes that break it go straight to the owner.

Make the codebase safe for AI

AI raises the stakes of an unsafe codebase, because it produces changes faster than people can inspect them. I think about readiness in six levels.

1. Buildable. One command to set up and build.
2. Testable. Reliable tests and curated test data.
3. Observable and reversible. Dashboards, alerts, feature flags, canaries and tested rollback.
4. AI-readable. An architecture map, owners, interfaces, invariants, traps and current runbooks.
5. Agent-operable. Automated build, verify and fix loops with security and cost checks.
6. Autonomous within limits. Low-risk changes move through policy-controlled release without a person in every step.

Nothing below level three goes into a highly autonomous lane. Every mission should leave the code safer than it found it.

Three lanes

Liquid software. Low-risk internal workflows, prototypes and business-owned apps. The platform supplies authentication, audit, data access, deployment and cost limits. Clear rules decide when something graduates to engineering ownership.

Missions. Strategic customer outcomes and major platform work.

Platform and safety. The paved road, reusable parts, hardening, security, observability and cost controls. Funded permanently and never traded away for features.

Cost is a production metric

AI spend can compound fast. Something that doubles every month and a half grows more than two hundred times in a year. So cost belongs next to latency, reliability and security, with budgets, anomaly alerts, circuit breakers and the authority to stop the line.

That also means watching AI work as one system. Every surface and every model reports into one place, tying tokens and cost to quality and outcomes. The purpose is to understand the factory and help people get better at it. I do not want token leaderboards.

The work documents itself

Every mission leaves a trace: the intent, the context, the prompts, the decisions, the code, the tests and the outcome. Stable truths get promoted into documentation automatically. That trace becomes the way we teach, coach, vet new ideas and invite more people to build safely.

A faster coding station was the easy part. Now we rebuild the factory around it.