“Vibe coding” made sense for a brief period. It captured the novelty of building software by describing what you wanted and letting a model handle the rest. But the term now feels too informal relative to what the market is actually doing. Andrej Karpathy, who popularised “vibe coding”, subsequently argued that the more accurate label is “agentic engineering”: a workflow in which agents based on large language models (LLMs) increasingly manage implementation, while humans provide oversight, review and judgement.
This shift is not merely semantic. It reflects a technical and organisational threshold. OpenAI Codex can work on multiple tasks in parallel within isolated environments, read and modify files, run commands and propose pull requests. GitHub Copilot, in agent mode, can analyse a codebase, execute terminal commands, run tests and submit draft PRs. Anthropic’s Claude Code was launched with the explicit objective of enabling developers to delegate complex engineering tasks from the terminal, and is now sold with enterprise controls, spending limits, analytics and configurable policies.
The result is a new division of labour. Software professionals are moving from writing prompts to orchestrating agents. The engineer’s role is increasingly to define the task, establish environment boundaries, inspect the evidence produced and decide when the machine’s work is sufficiently reliable to be integrated. Karpathy’s own formulation, the “March of Nines”, explains why: a demo that works “almost always” is far from the reliability required in production. In enterprise contexts, the hard part is not generating code, but governing autonomous systems so they behave as reliable software delivery machines.
“Vibe coding” described an early consumer phase of AI-driven software generation: the user described a feature, the model produced code, the person corrected the output. This approach lowered barriers to entry but obscured the difference between a “novelty” workflow and a production workflow. The gap is now evident.
Modern systems do not merely answer programming questions: they take scoped assignments and execute them across an entire tool chain. OpenAI Codex clearly embodies this shift — it runs tasks in separate cloud sandboxes, can handle many tasks in parallel and provides evidence via terminal logs and tests. GitHub’s coding agent starts from an issue, creates an environment via GitHub Actions, submits commits in a draft PR and allows human review before workflows execute. Anthropic’s Claude Code was introduced to delegate complex engineering tasks from the terminal, then expanded with enterprise controls for policies, permissions and usage analytics. This is the operating model of an engineering teammate, not a code completion tool.
Karpathy’s new term matters because it refocuses attention where it is needed in enterprise teams: system design, oversight and failure management. Agentic workflows are not magic: they are orchestration problems. They require decomposition, environment checks, test harnesses, rollback paths and measurable reliability. This is precisely where the informal language of vibe coding no longer holds up.
A hobbyist can tolerate ambiguity and failures. A bank, an airline, a semiconductor company or an insurer cannot. When agents begin interacting with build systems, production repositories, CI pipelines and regulated data, engineering discipline returns to centre stage.
Roadmaps demonstrate that this transition is real. GitHub defines agent mode as “the next evolution of AI-assisted coding”, describing an autonomous programmer that analyses the codebase, modifies files, runs commands and tests, monitors failures and loops until the task is complete. OpenAI Codex is positioned as a software engineering agent, not a developer chatbot. Anthropic has pushed the model further still: Claude Code for delegated engineering work, then packaged for Team and Enterprise with spend caps, policies, analytics and a compliance API.
Their own research illustrates what multi-agent software work means today: a team of 16 agents produced a 100,000-line Rust C compiler in approximately 2,000 Claude Code sessions. These are not marginal experiments: they are the first operating systems for AI-native engineering teams.
Tool adoption confirms the category. Cursor surpassed $100M ARR in 2025; further reports cite $2 billion annualised in 2026. Even allowing for statistical noise, the trend is unmistakable: companies are paying to transform coding into workflows delegated to autonomous agents.
The cultural signal matters too: seeing Linus Torvalds experiment with AI does not mean Linux will become machine-written, but it does mean that even the most sceptical figures recognise AI’s utility in bounded contexts.
For enterprise leaders, the novelty is not that AI writes code. That chapter is closed. The novelty is that AI can now take engineering tasks with defined boundaries, work through them with enough autonomy to change team structure, delivery speed and governance requirements.
Software development therefore becomes a management problem, not merely a staffing organisation problem. Repository policies, approval workflows, sandboxes, audit logs, spending controls and agent performance baselines are all required — just as they are for human contributors.
The consequence is a value shift: less emphasis on writing code line by line, more on architecture, oversight, security, review and systems thinking.
The term “agentic engineering” matters because it identifies the real threshold the industry has crossed. “Vibe coding” was about access. Agentic engineering is about control. Once code generation became cheap and ubiquitous, the scarce capability became oversight: what to delegate, how to define guardrails, how to read the evidence and how to decide whether the output is trustworthy.
The standard is no longer to describe software: it is to supervise autonomous systems that build it for you.