The phrase "coding is solved" has earned itself a place in the discourse. Boris Cherny, head of Claude Code, has been associated with the framing. Andrej Karpathy gave us "vibe coding" as the cultural shorthand for describing intent in natural language and letting the model produce the implementation. ADLC.io and others are now naming the successor pattern: the Agentic Development Lifecycle, where agents execute and humans govern.

I think the diagnosis is mostly right. Coding, understood as the manual translation of clear intent into executable syntax, really is being compressed into something close to free. What I want to argue is that most of the people celebrating this haven't yet noticed the failure mode it produces, and that the failure mode is one enterprise software has seen before, at smaller scale, with predictable consequences.

The old software disaster was scarcity. The tool never got built. The backlog never cleared. The engineering team never had capacity. Anyone who has run a Q2C transformation knows this disaster intimately. You wait three quarters for a CPQ change because the implementation team is buried, and by the time the change ships, the pricing model it was designed for has already evolved.

The new disaster is the opposite shape. It is abundance without comprehension. Every department generates its own tools. Every analyst builds a workflow helper. Every sales operator generates a quote calculator. Every finance lead spins up a reconciliation bot. Every customer success team has a dashboard nobody else can read. This sounds like liberation, and in a meaningful sense it is. But scaled across an enterprise, it produces something I want to give a name to.

Call it generating sediment.

The sediment problem

Sediment is what accumulates when a lot of small artifacts are produced quickly, by different actors, without a shared substrate of governance. Each individual artifact may be fine. The problem is what they look like in aggregate, six months later, when nobody can answer basic questions.

Which app calculates the canonical revenue number? Which workflow writes to the production order table? Which generated service is holding a long-lived API token in plaintext? Which dashboard is reading from a stale replica? Which agent-built integration is silently retrying and double-posting on failure? Which of the seventeen "discount approval" tools is the one finance actually trusts?

If you've spent any time in enterprise revenue systems, you recognize this pattern. It's what happens to a CRM after five years of unmanaged custom fields and triggers. It's what happens to a billing stack after three acquisitions and no consolidation effort. It's what happens to any system of record when the cost of adding new behavior drops faster than the discipline of governing it.

The thing that's new is the speed. CRM cruft accumulated over years because building a custom object took someone a week and required a ticket. Agent-generated cruft can accumulate over a quarter because building a custom object takes a product manager twenty minutes and requires no one's permission. The sediment forms faster than the organization can metabolize it.

What ADLC actually has to solve

This is why I think the framing of "agents execute, humans govern" is genuinely useful and also genuinely incomplete. It captures the right division of labor at the level of an individual development loop. It does not yet describe what governance means at the level of an organization producing thousands of small generated systems concurrently.

The interesting work in ADLC isn't in the generation step. Generation is the easy part. The hard parts are the ones the SDLC was always supposed to handle and that compress poorly:

Source of truth hierarchy across generated artifacts. When ten teams generate ten "customer health" tools that each compute the number slightly differently, which is authoritative? The classic enterprise answer is that you declare a system of record and force everything else to defer. The agentic answer has to be the same, and it has to be enforced through architecture rather than convention, because convention won't survive the volume.

Provenance and reversibility as substrate. Every generated artifact needs to carry, at minimum, what specification produced it, what context it was built against, what it has authority to mutate, and how to roll back its actions. Compound engineering is the right instinct here, but the artifact that compounds isn't just the prompt library or the eval suite. It's the audit ledger underneath every action a generated system takes in production.

A real distinction between intent and obligation. Business users can absolutely own intent. They are usually closer to the work than the engineering team. But intent expressed in natural language and compiled by an agent into a system that mutates production data is not the same kind of object as a Jira ticket. The system the agent produced has obligations: to other systems, to customers, to auditors, to the organization's commercial truth. Treating those obligations seriously is what separates ADLC from vibe coding at scale.

This is the same architectural pattern I'm working through in my own portfolio project on AI gateway infrastructure: control planes that treat audit, mutation events, snapshots, and operator/agent symmetry as substrate rather than features. The cross-domain consistency is the point. Whether you're routing LLM requests, mutating CPQ data, or coordinating a fleet of agent-generated internal tools, the pattern that survives contact with production is the same. Make every action traceable. Make every mutation reversible. Make the contract between human and agent operators legible enough that you can answer the question "what did this do, on whose authority, and how do I undo it" in seconds rather than weeks.

The career reframe

The standard take on "coding is solved" is that the endangered role is the routine implementer: take a ticket, produce CRUD code, move on. That's true as far as it goes. But I think it understates how much new work is being created in the same motion.

The high-value role in an ADLC organization isn't the typist. It's the person who can hold the line on coherence as generation accelerates. Spec architects who write specifications precise enough for agents to build against. Domain modelers who define the canonical objects everything else has to defer to. Eval designers who turn judgment into executable tests. Security and integration engineers who decide what authority a generated artifact is allowed to exercise. Memory architects who turn organizational learning into structured context that makes the next build better than the last.

This is the same shift the printing press caused, and the spreadsheet caused, and the personal computer caused. The lower craft becomes cheap. The higher craft becomes more valuable, and more abstract, and harder to hire for.

Coding is no longer a moat, and that is a good thing. Coding as scarcity bottleneck is dying, also good. The discipline of building durable systems out of fast, fluent, fallible generation is the work that remains, and that work is barely a decade into being understood.

The barbarian version of agentic development is generation without governance. The civilized version is the organization that can produce ten thousand small systems and still answer, on any given Tuesday, exactly what each of them is doing in production. That second organization is the one that wins. The first one drowns in its own abundance, eventually, in ways that look a lot like the failure modes enterprise software has been generating for thirty years, just compressed into a much shorter timeframe.

Be worried when generation outpaces governance. The implementation layer just got cheap. Everything else just got more important.