Vibe Coding Is Dead: The Rise of Agentic Engineering

Vibe coding is dead. The term Andrej Karpathy coined in February 2025 was retired by its own author a year later, and its successor has a different center of gravity: agentic engineering. You specify the outcome, the constraints, and the definition of done; agents plan, write, and test against them; you review the evidence. The change is more than vocabulary. Leverage moves from prompting to specification — and the next bottleneck moves with it, from generation to the production system around the agents. That system is the software factory, and in Your Agents Need a Factory we look at how it decides what ships.

Named in 2025, retired in 2026

Andrej Karpathy named vibe coding in February 2025, and the definition spread fast: prompt a model, accept what comes back, iterate on feel. Within a year the phrase had reached developer forums and boardroom decks.

Then he retired the term before it cooled. The New Stack reported in February 2026 that Karpathy now calls the work agentic engineering (The New Stack). The description is easy to recognize: you specify the outcome, the constraints, and the definition of done. Agents plan, write, and test against them. You review the evidence. What sounded like a rebrand was actually a reclassification — a line between hobbyist play and professional practice.

The ladder of autonomy

The shift is easier to see as a ladder. Each level hands the agent more of the work and asks less of your hands.

Level one is autocomplete: the editor suggests, you decide. Level two is an agent drafting while you review every line. Level three is an agent writing whole features while you read the diff. Level four puts agents on review duty, with you spot-checking what they flag. Level five is the dark factory, a term borrowed from lights-out manufacturing: no human writes or reviews code, and the specification is the only human artifact.

The ladder is useful because it separates two questions people usually conflate: how much an agent can do, and how much of that you should let it. The first is a model question. The second is a risk question.

Where real teams sit

Level five stays rare, and the data says it will for a while. Bain’s Technology Report 2026, based on a survey of 293 senior technology leaders, found that 6 percent of companies expect full autonomy in development. Another 41 percent expect risk-tiered pipelines, where agents run routine work and people keep the changes that could hurt (Bain & Company).

Most teams live at levels two through four, and the marketing has not caught up with them. Vendors sell autonomy. Teams buy review speed. The middle of the ladder is where the discipline pays off: at level three, an agent writes a feature and you read the diff; at level four, agents review each other and you check what they flag. Both require the same thing — a specification precise enough that a wrong result is visible.

What the work becomes

In the middle of the ladder, the skill that matters changes. You decompose a problem and write acceptance criteria precise enough to verify. You judge what the agent produced against them, and you design the loops that catch regressions before a customer does.

The professional path comes down to four practices: write detailed specs, review diffs for correctness and security, design automated evaluation loops, and manage agent permissions across a codebase. Eval design is the practice engineers most often skip — it is also the one that separates teams that trust their agents from teams that merely tolerate them.

The tools can look identical from the outside. The discipline is what changed.

The software factory, not the noise

Kordyline exists because of what happens one step up the ladder. When the work moves from writing code to specifying it, the system around the agents decides how much you ship. Dashboards multiply, context scatters, and the strongest engineer on the team becomes the integration layer by default.

We are building the alternative. We are creating the software factory, so that you can focus on products and ship new features fast: specifications agents can act on, quality gates that verify without a human staring at every diff, and evidence you can read when something goes wrong. Fewer places to look, clearer answers, and a day that stays on the product.

We are early, and we will share more as we build. Next in the series: Your Agents Need a Factory, where the pipeline — signals in, verified software out — comes into focus.