The Man Who Coined 'Vibe Coding' Says The Next Big Thing Is 'Agentic Engineering'

Agentic engineering: the next phase after vibe coding

A new phrase is gaining traction in AI software circles. OpenAI co-founder Andrej Karpathy says "agentic engineering" is the label that best captures where AI development is headed. The idea marks a shift from casual, prompt-driven collaboration with large language models to building and deploying AI agents that can carry out coding tasks more independently.

"Many people have tried to come up with a better name for this to differentiate it from vibe coding. Personally, my current favorite is 'agentic engineering'," Karpathy wrote in a recent post on X. He argues the term reflects not only that agents can write code, but that there is an emerging art, science, and expertise in how to design, evaluate, and manage them.

That framing is resonating across teams that have spent the past year experimenting with AI-powered development tools. As models improve and workflows mature, many developers are looking beyond prompt recipes and toward systems that can plan, execute, and iterate on complex tasks with less handholding.

From a meme to a mainstream phrase

Karpathy popularized "vibe coding" early last year to describe a new style of building software alongside large language models. In his words, "There's a new kind of coding I call 'vibe coding', where you fully give in to the vibes, embrace exponentials, and forget that the code even exists. It's not really coding — I just see stuff, say stuff, run stuff, and copy paste stuff, and it mostly works." The meme captured a reality for many developers who found themselves chatting with AI, testing snippets, and leaning on model-generated scaffolding.

The phrase spread quickly as teams tested AI-assisted editors, documentation copilots, and automated refactoring tools. Companies building these tools attracted significant funding, signaling broad interest in the space. One AI app-building startup raised $330 million in a late-stage round at a multibillion valuation, and AI code editor Cursor announced a Series D round and said it surpassed $1 billion in annualized revenue.

Those headlines underscored a larger point. AI is becoming a core part of everyday development, and the culture around how we write and manage code is evolving fast. Vibe coding described the early hands-on, exploratory phase. Agentic engineering points to a more structured practice.

What agentic engineering means

Agentic engineering is the practice of designing, deploying, and governing AI agents that can plan and carry out software tasks with minimal human prompts. Rather than repeatedly nudging a model with a sequence of instructions, teams define higher level goals and guardrails, then let agents break work into steps, call tools, and evaluate their progress.

In practical terms, it bridges AI assistance with traditional engineering rigor. Agents work across the development lifecycle, from reading requirements to generating code, tests, and documentation, then iterating based on feedback. Human oversight remains crucial, but the locus of effort moves from manual prompting to orchestrating agents and measuring outcomes.

• Autonomy over prompting. Agents plan, decompose tasks, and self-correct while developers define objectives and constraints.
• Tool use and integration. Agents call APIs, run code, search docs, and interact with issue trackers or CI systems to complete multi-step work.
• Evaluation loops. Continuous checks, tests, and rubrics help agents verify their own outputs and recover from errors.
• Guardrails for safety. Policies, sandboxes, and access controls protect codebases, data, and infrastructure.
• Human-in-the-loop. Developers review plans, diffs, and test results, intervening where judgment or domain expertise is required.

Karpathy favors the term because it highlights the craft required. There is technique in how you specify goals, design agent roles, select tools, and set evaluation criteria. That technique is where engineering discipline meets AI capability.

Why the shift is happening now

Several trends are pushing teams beyond prompt-only workflows. Models are more capable, context windows are larger, and retrieval can bring relevant code and documentation into the conversation. On top of that, tool calling and function execution make it possible for agents to do more than generate text.

Businesses also expect measurable productivity gains, not just demos. That means moving from ad hoc usage to repeatable pipelines that improve quality, speed, and cost. Agentic engineering responds to that need by packaging AI into systems that can be monitored and audited.

• Maturing model capabilities. Better reasoning and longer contexts support multi-step tasks and codebase-scale understanding.
• Richer ecosystems. Editors, CI pipelines, and issue trackers now expose hooks agents can use to act, not just suggest.
• Operational demands. Teams want reliability, traceability, and metrics, which fit agent orchestration more than casual prompting.
• Investment momentum. Significant funding for AI dev tools signals demand for production-ready workflows and outcomes.

The net effect is a shift from quick wins to sustained practice. The excitement around vibe coding helped normalize AI assistance. The push toward agentic engineering aims to make it dependable.

How development teams can adopt agentic patterns

Agentic engineering does not require a big-bang overhaul. Most teams start small, then expand scope as confidence grows. The key is to treat agents like software components that need clear contracts, strong tests, and observability.

Focus first on bounded tasks where agents have good feedback loops and available tools. Write policies that define what agents can and cannot do. Establish checkpoints where humans review changes before they merge or deploy.

• Pick high-signal tasks. Begin with test generation, doc updates, small refactors, or bug triage where validation is straightforward.
• Define roles and scopes. Give agents narrow permissions, clear objectives, and access only to relevant code or services.
• Instrument everything. Log agent decisions, tool calls, and outcomes. Track accuracy, cycle time, and recovery from errors.
• Build evaluation harnesses. Use unit tests, static analysis, and linters as automatic checkpoints. Create rubrics for non-code tasks.
• Keep humans in the loop. Require reviews for diffs, production changes, and architectural decisions. Make escalation simple.
• Harden security. Isolate environments, manage secrets, and prevent broad write access. Audit actions regularly.
• Document behavior. Record agent prompts, constraints, and playbooks so others can reproduce and improve them.

With this foundation, teams can move from single agents to agent swarms that coordinate work. Think of specialized agents for planning, coding, testing, and documentation that hand off artifacts and checks along the way.

Karpathy's background and influence

Karpathy was a founding member of OpenAI in 2015, years before competitors like Anthropic and xAI emerged. He later led Tesla Autopilot as head of AI, working on perception and autonomy. Today he is building Eureka Labs, which describes itself as creating a new kind of school that is AI native.

His knack for naming trends has made a mark beyond research. "Vibe coding is now mentioned on my Wikipedia as a major memetic 'contribution'," he joked on X. By reframing the conversation around agentic engineering, he is pushing the community to focus on the operational side of AI development, where reliability and governance matter as much as raw capability.

Regardless of labels, his message taps into a wider shift. Teams are moving from viewing models as assistants that respond to prompts to treating agents as components that plan, act, and learn within a system. That mindset encourages design discipline and measurable outcomes.

Opportunities and risks of agentic engineering

Agentic engineering promises faster delivery and richer automation. Agents can summarize long threads, triage issues, propose fixes, and keep documentation current. They can also help enforce standards by running checks and flagging deviations.

However, handing more autonomy to agents raises important challenges. Reliability, security, and cost are top of mind. The more agents act, the more teams need strong guardrails and observability.

• Productivity gains. Multi-step automation can reduce busywork and speed up refactoring, testing, and maintenance.
• Quality control. Built-in evaluation loops help agents catch errors early, but they require careful design and tuning.
• Emergent behavior. Autonomy can surface unexpected interactions. Sandbox policies and rollback plans are essential.
• Security posture. Least-privilege access, environment isolation, and secret management are non-negotiable.
• Cost management. Tool calls, long contexts, and frequent evaluations add up. Track usage and optimize workflows.
• Cultural change. Developers shift from writing code directly to designing and supervising agents. Training and buy-in matter.

Balancing these factors is the core of the discipline Karpathy points to. It is not just about getting agents to write code. It is about building systems where agents can operate safely and predictably.

What to watch next

If agentic engineering follows the arc of other engineering practices, standards and patterns will emerge. Expect more frameworks for agent orchestration, better testing harnesses, and clearer security models. IDEs will integrate deeper agent controls, moving beyond suggestions to managed execution.

Enterprises are likely to pilot agentic pipelines in areas with tight feedback loops, such as test maintenance, documentation hygiene, or internal tooling. Over time, more complex applications will follow as trust grows and best practices solidify.

• Agent orchestration frameworks. Tools to define roles, goals, and handoffs with built-in metrics and guardrails.
• Evaluation and auditing. Standardized rubrics, coverage metrics, and traceability for agent decisions and outputs.
• Security and compliance. Policies tailored to agent access and action, plus logs that satisfy audits.
• Human oversight interfaces. Review panes for diffs, plans, and test outcomes that make supervision efficient.
• Real-world case studies. Evidence of reliability and ROI in production environments, not just demos.

All of this points to a more mature phase of AI-based development. The vibe was fun, and it helped teams get comfortable with AI. The agentic phase will be about sustainable practice.

Key takeaways

• Agentic engineering is Karpathy's term for designing and managing autonomous AI agents that can plan, write, and refine code with fewer prompts.
• Vibe coding captured the early, exploratory style of working alongside LLMs. Agentic engineering emphasizes structure, evaluation, and guardrails.
• Funding and adoption of AI dev tools suggest momentum toward production-ready workflows where agents act and are measured.
• Practical steps include starting with bounded tasks, instrumenting agent actions, enforcing least privilege, and keeping humans in the loop.
• Risks around reliability, security, and cost require engineering rigor, not just clever prompting. That is where the new discipline takes shape.

Whether or not the term sticks, the direction is clear. AI in software development is moving from ad hoc assistance to orchestrated systems. Agentic engineering is a call to build those systems with the same care and accountability that define good engineering.