Andrew Stellman argues that the many overlapping names for AI-assisted software work cause confusion about responsibilities and standards. He proposes the umbrella term “AI-driven development” (AIDD) to describe the whole discipline: AI-generated output plus the human-owned verification and accountability that must accompany it.
Why the current names fall short
Names matter: in programming naming makes concepts real, and a poorly chosen name can mislead for a long time. Several names have emerged that each capture a piece of the work, but none of them by itself names the full responsibility and verification process.
Vibe coding
“Vibe coding” is an exploratory, prompt-first approach: prompt quickly, get code, iterate. The term was coined by Andrej Karpathy and is a useful, creative technique for rapidly generating code. Stellman supports vibe coding as a technique but warns that relying solely on it can mean losing oversight of the architecture and intent: the AI can make decisions that lead to a product that doesn’t meet its requirements. To help decide when to step away from vibe coding, Stellman developed the Sens-AI Framework, which guides when more research and critical review are needed.
Prompt engineering and loop engineering
“Prompt engineering” names the skill of crafting clear, contextual instructions for models. It was once the central AI skill and even a job title, because how you ask an AI changes what you get back. However, many find the term limiting because it implies a one-request-at-a-time workflow.
“Loop engineering,” a term associated with Addy Osmani, describes that skill at scale: instead of manually entering each instruction you design a loop that dispatches tasks to agents, checks results, and supplies the next prompt automatically. Loop engineering is prompt engineering at scale — the prompts remain, but they are produced by the system rather than typed each time. It names the machinery, but not whether that machinery produces working software versus confident-looking but incorrect output.
Agentic engineering
“Agentic engineering,” a term used by Andrej Karpathy and mentioned by Boris Cherny of Claude Code, describes directing agents to do the coding work rather than writing code yourself. This shifts engineering toward management: if you run thousands of agents, you are responsible for what they ship. Stellman emphasizes that you cannot offload accountability to agents; a human still owns the result.
Spec-driven development
“Spec-driven development” means writing specifications, acceptance criteria and tests before generation, and not considering the work done until the code meets the spec. It belongs to the same family as test-driven and behavior-driven development. Since AI has made code generation cheap, most of the cost of building software shifts to checking whether generated code is correct, so spec-driven practices become more important: write the requirement first, then generate to that standard.
What these names cover — and what they omit
- Vibe coding: the exploratory end — quick prompt, iterate, intentionally loose.
- Prompt engineering: the skill of producing the right instruction for the model.
- Loop engineering: the machinery that automates prompting at scale.
- Agentic engineering: fleets of agents and their architecture; it implies managerial responsibilities.
- Spec-driven development: the verification half — the standard the work must meet.
Each name correctly identifies a part of the work. None of them, however, names the whole assembly: generation, verification, and human ownership. That gap is what “AI-driven development” is proposed to fill.
What “AI-driven development” means
AIDD is an umbrella over the entire process: AI-based generation, specification-driven verification, defect taxonomy and human ownership of the final product. The point is not to name the specific machinery but to name the discipline and the responsibility that applies regardless of specific tools — like how “test-driven development” or “behavior-driven development” describe enduring practices rather than particular tools.
Practical habits that belong under AIDD, according to Stellman:
- Write the spec or contract before generation so the work has clear acceptance criteria.
- Use multiple models or reviewers, since models fail differently and one’s confident answer can be another’s miss.
- Adopt a shared vocabulary for defects (e.g., wrong against spec; technically correct but the wrong behavior; unspecified behavior).
- Keep a human in the final judgment seat: people must be the ones to push back against AI output and decide what “right” looks like.
Skipping these steps risks producing what Stellman and others call “vibe slop”: output that looks finished and convincing but is unchecked and often incorrect.
Can one name cover very different ways of working?
Stellman addresses the concern that one umbrella name might be too broad. He argues the common element across the range is ownership: whether you are vibe coding a prototype or directing tens of thousands of agents in production, somebody must own the result. The amount of verification required varies with stakes, but the presence of responsibility does not. That shared invariant — AI generates, a human owns — is what a single name can honestly describe.
Conclusion
All the existing names — vibe coding, prompt engineering, loop engineering, agentic engineering and spec-driven development — are valid and useful. They describe different parts of the workflow. “AI-driven development” is proposed as the name for the whole discipline: the generation plus the verification plus the human accountability. AI reduced the cost of generating code, but it did not remove responsibility; whoever directs the AI still must ensure the final product meets requirements.
