Agentic Engineering: The Post-Vibe-Coding Paradigm

What Is Agentic Engineering?

Agentic engineering is building software by orchestrating AI coding agents. You define the architecture, decompose work into agent-sized tasks, and review everything. The agents handle implementation: reading files, running commands, writing tests, committing code, and iterating on failures.

Karpathy's framing: "Agentic because the new default is that you are not writing the code directly 99% of the time, you are orchestrating agents who do and acting as oversight. Engineering because there is an art and science and expertise to it."

The defining feature of the tools behind it: they can both generate and execute code. Claude Code, OpenAI Codex, Cursor, and Devin do not suggest code. They run it, test it, observe the results, and iterate. That loop is what makes them agents rather than autocomplete.

From Vibe Coding to Agentic Engineering

Vibe coding was the consumer phase of AI-assisted development. Karpathy coined it in February 2025 to describe "fully giving in to the vibes" and accepting AI-generated code without reading it. 92 percent of US developers started using AI coding tools daily. Collins Dictionary made it Word of the Year.

The problems showed up fast. 45 percent of AI-generated code contains security vulnerabilities (arxiv 2505.19443). Code duplication increased 48 percent. Refactoring activity dropped 60 percent. Daniel Stenberg shut down cURL's bug bounty because of AI-generated spam reports.

The GLM-5 paper titled "From Vibe Coding to Agentic Engineering" formalized the transition as a paradigm shift: from intuitive, human-in-the-loop prompting to goal-driven agents capable of planning, executing, testing, and iterating with minimal human intervention.

Simon Willison drew the clearest line: if an LLM wrote the code but you reviewed it, tested it, and can explain how it works, that is software development. Vibe coding means accepting code you do not understand. Agentic engineering formalizes that distinction into a repeatable practice.

Conductor to Orchestrator: The Role Evolution

O'Reilly and Addy Osmani frame the engineer's role evolution in two stages. Understanding which stage you are in determines which tools, workflows, and skills matter most.

The Conductor Model

You work closely with a single AI agent on a specific task, like a conductor guiding a soloist. You remain in the loop at each step: steering the agent's behavior, tweaking prompts, intervening when needed, iterating in real time. This is how most developers work with AI today. Synchronous, interactive sessions in an IDE or CLI.

The Orchestrator Model

You oversee multiple AI agents working in parallel on different parts of a project. You set high-level goals, define tasks, and let specialized agents carry out implementation independently. Results arrive as completed pull requests. Some early adopters already delegate 10 or more PRs daily to AI agents. Anthropic projects that agents could generate 80 to 90 percent of code with humans providing the 10 percent of critical architectural guidance.

Core Practices of Agentic Engineering

Four practices define the discipline. Each solves a specific failure mode of unstructured AI coding.

Context Engineering: The Foundation

Context engineering is the art of filling the agent's context window with the right information. If the agent does not understand your project's architecture, testing conventions, or business constraints, no amount of prompt engineering fixes it.

The primary artifact is a project-level instruction file. CLAUDE.md for Claude Code, AGENTS.md for the cross-tool standard, .cursorrules for Cursor. Anthropic's guidance: keep it under 300 lines, focus on what causes mistakes if missing, and use progressive disclosure so the agent loads details only when needed. Never send an LLM to do a linter's job. Reserve context tokens for architecture, business logic, and project-specific knowledge.

# CLAUDE.md

## Architecture
Next.js 15 App Router. Server components by default.
Client components only for interactivity.

## Commands
bun run dev          # Dev server on port 3000
bun run typecheck    # TypeScript strict mode
bun run test         # Vitest suite

## Conventions
- All mutations through server actions in actions.ts
- Database: Drizzle ORM, schema in src/lib/db/schema.ts
- Auth: Clerk middleware on /dashboard/* routes
- Never commit .env files

## Agent Workflow
- Run typecheck after every code change
- Commit working states before risky changes
- Write tests before implementation
- If stuck for >3 attempts, ask for human input

For code retrieval during agent execution, WarpGrep provides semantic search that returns only the files relevant to the current task. Instead of loading a 500-file repository into context, the agent searches for exactly what it needs. Agentic context engineering covers the runtime side of this problem in depth.

Task Decomposition: Agent-Sized Work

The granularity of tasks determines whether agentic engineering works or wastes money. Too broad, and the agent loses context midway. Too narrow, and you spend more time coordinating agents than you save.

Addy Osmani's workflow: start with a spec.md containing requirements, architecture, and testing strategy. Break work into one function or one feature at a time. Commit after each chunk. He calls this "waterfall in 15 minutes" because it compresses planning into rapid structured cycles. The spec is the contract. The agent works against it.

# spec.md: Add rate limiting to API routes

## Tasks (each = one agent session)

1. Create Redis rate limiter module
   - src/lib/rate-limiter.ts
   - Sliding window algorithm
   - Tests: src/lib/__tests__/rate-limiter.test.ts

2. Add rate limit middleware
   - src/middleware/rate-limit.ts
   - Read limits from DB per API key tier
   - Tests: middleware integration tests

3. Wire into API routes
   - Update src/app/api/chat/route.ts
   - Update src/app/api/usage/route.ts
   - Tests: e2e rate limit behavior

4. Add rate limit headers to responses
   - X-RateLimit-Remaining, X-RateLimit-Reset
   - Tests: header presence assertions

# Each task: self-contained, testable, one commit

Kiro from AWS formalizes this in an IDE: the agent generates user stories with acceptance criteria, a technical design document, and a task list before writing any code. This is task decomposition as a first-class workflow step, not an afterthought.

Verification Loops: Tests as Specifications

Testing is the single biggest differentiator between agentic engineering and vibe coding. With a solid test suite, an AI agent can iterate in a loop until tests pass. This turns an unreliable generator into a reliable system.

Simon Willison's pattern is the simplest form: write failing tests (red), then let the agent make them pass (green). The developer writes the specification as tests. The agent writes the implementation. The tests are the contract.

// Step 1: Human writes the test (the specification)
describe("rate limiter", () => {
  it("allows requests under the limit", async () => {
    const limiter = createRateLimiter({ max: 10, window: "1m" });
    const result = await limiter.check("user-123");
    expect(result.allowed).toBe(true);
    expect(result.remaining).toBe(9);
  });

  it("blocks requests over the limit", async () => {
    const limiter = createRateLimiter({ max: 2, window: "1m" });
    await limiter.check("user-123");
    await limiter.check("user-123");
    const result = await limiter.check("user-123");
    expect(result.allowed).toBe(false);
  });
});

// Step 2: Agent implements until tests pass
// Step 3: Human reviews the implementation
// Step 4: Commit if review passes

CodeScene found that teams targeting a Code Health score of 9.5 or higher see 2 to 3x productivity gains from agentic coding. AI needs healthy code to reduce defect risk. It will happily modify spaghetti code and make it worse. High code quality is not a casualty of agent-assisted development. It is a prerequisite for it.

Beyond unit tests, Claude Code best practices include running typecheck, lint, and build after every change. These are automated verification loops that catch drift before it compounds.

Tools and Platforms for Agentic Engineering

Each major tool implements the core patterns differently. They all share the same loop: read state, plan action, execute with tools, observe results, iterate.

Claude Code Agent Teams deserve special attention. Unlike subagents, which run within a single session and can only report back, Agent Teams members communicate directly with each other. One session acts as team lead. Teammates work independently, each in its own context window, and share discoveries mid-task.

Conductor by Melty Labs manages multiple Claude agents in isolated Git worktrees, displaying agent status on a dashboard. Claude Squad is an open-source terminal multiplexer for running Claude instances in parallel panes.

All these tools benefit from fast context management. Morph Compact compresses agent context to the minimum viable token set at 10,500+ tokens per second. WarpGrep provides surgical code retrieval so agents load only what they need.

Multi-Agent Coordination

Anthropic's 2026 Agentic Coding Trends Report identifies multi-agent coordination as a defining trend: organizations are moving from single agents to specialized agent groups working in parallel under an orchestrator.

Anthropic reported that their multi-agent system (Claude Opus as lead, Claude Sonnet subagents) outperformed single-agent Claude Opus by 90.2 percent on research evaluations. The gain comes from context isolation: each subagent maintains only the context relevant to its task, avoiding the context rot that degrades long single-agent sessions.

The sequential conductor approach: implement backend with AI, then frontend, then tests. Each step involves active human participation. The parallel orchestrator approach: delegate backend to Agent A, frontend to Agent B, tests to Agent C. Human reviews the resulting PRs and integrates. The orchestrator approach is faster but requires clearer task boundaries and better test coverage to catch integration issues.

Case Study: The 100K-Line C Compiler

In early 2026, Anthropic researcher Nicholas Carlini tasked 16 Claude agents with writing a dependency-free C compiler in Rust, capable of compiling the Linux kernel. The result demonstrates both the power and the limits of agentic engineering.

The compiler builds Linux 6.9 on x86, ARM, and RISC-V. It compiles QEMU, FFmpeg, SQLite, Postgres, and Redis. It passes 99 percent of the GCC torture test suite. Clean-room implementation, no internet access during development, depending only on the Rust standard library.

The project exposed a critical coordination failure. When agents started compiling the kernel (one monolithic task, not parallelizable), all 16 hit the same bug, produced the same fix, and overwrote each other's changes. More agents made it worse, not better. Human intervention restructured the task into parallelizable pieces. Good task decomposition is the difference between 16 agents multiplying your output and 16 agents multiplying your problems.

When Agentic Engineering Fails

Agentic engineering is not always the right approach. Understanding when it fails prevents wasted time and money.

Coordination Overhead Exceeds Benefits

Every additional agent adds messages, latency, and drift risk. If the task is simple enough for one focused developer, coordinating three agents costs more than it saves. Research found that even strong models with 98 percent per-agent success rates degrade to 90 percent or lower at the system level, with each unchecked hop multiplying failure probability.

Review Bottleneck

Individual output surged 98 percent in high-adoption teams, but PR review time increased by up to 91 percent. The time saved writing code was consumed by reviewing more code. If your team cannot review fast enough, agents create a backlog instead of delivering value.

Cost Explosion at Scale

A three-agent workflow costing $5 to $50 in demos can generate $18,000 to $90,000 monthly in production. Token multiplication, retry loops, and expanded context windows compound costs. Pilot accuracy of 95 to 98 percent drops to 80 to 87 percent under real-world pressure.

Non-Parallelizable Work

The C compiler kernel compilation failure illustrates this. When multiple agents hit the same sequential bottleneck, parallelism hurts. Debugging a single race condition, understanding deeply interconnected legacy code, making a judgment call about product direction: these tasks do not benefit from agent parallelism. Sometimes a single developer typing code is faster than coordinating three agents.

The Skill Shift

The transition is misunderstood as "from writing code to writing prompts." That describes vibe coding. The actual shift: from writing code to designing agent systems.

The valuable skills in 2026: knowing what to build (product thinking), how to decompose it into parallelizable tasks (systems design), how to set up verification (testing strategy), and how to evaluate agent output (code review). These are the same skills that made senior engineers valuable before AI, applied to a new medium.

IBM frames the paradox: AI-assisted development rewards rigorous engineering practices more than traditional coding. Better specs yield better agent output. Stronger tests enable confident delegation. Cleaner architecture reduces hallucinations. The developers who benefit most from agentic engineering are the ones who were already good at engineering.

Anthropic's report identifies eight trends reshaping software engineering in 2026, including the shift toward agent supervision, agents going end-to-end on multi-day tasks, and non-engineers using agents to build their own tools. Sales, legal, marketing, and operations teams building small automations themselves. The bottleneck shifts from technical ability to clarity of thought.

Getting Started With Agentic Engineering

You do not need multi-agent teams or expensive infrastructure. A single agent plus these practices will get you most of the benefit.

Frequently Asked Questions

What is agentic engineering?

Agentic engineering is the discipline of building software by orchestrating AI coding agents. You define the architecture, decompose tasks, set up verification loops, and review all output. The agents handle implementation, testing, and iteration. Andrej Karpathy coined the term as the professional successor to vibe coding.

How is it different from vibe coding?

Vibe coding means accepting AI-generated code without reading it. Agentic engineering means orchestrating agents with specs, tests, reviews, and checkpoint discipline. Vibe coding works for prototypes. Agentic engineering works for production.

What is the conductor-to-orchestrator model?

The conductor model: one developer, one agent, real-time collaboration. The orchestrator model: one developer, multiple agents, asynchronous delegation. Most teams start as conductors and evolve into orchestrators as their workflows and trust mature. O'Reilly covers this evolution in depth.

What tools support agentic engineering?

Claude Code (with Agent Teams), OpenAI Codex, Cursor (Background Agents), Devin, Conductor (Melty Labs), Claude Squad, GitHub Copilot Coding Agent, Google Jules, and Kiro (AWS). WarpGrep handles semantic code search. Morph Compact compresses context for long-running sessions.

What is context engineering?

Context engineering is curating the information an agent sees. It includes CLAUDE.md files with project architecture, .claudeignore rules to exclude noise, and progressive disclosure so agents load details only when relevant.

What did Karpathy say about agentic engineering?

Karpathy said: "Agentic because the new default is that you are not writing the code directly 99% of the time, you are orchestrating agents who do and acting as oversight. Engineering because there is an art and science and expertise to it. It's something you can learn and become better at, with its own depth of a different kind."

When should I not use agentic engineering?

When coordination costs exceed the benefits. Simple tasks where a focused developer is faster. Non-parallelizable debugging. Judgment calls about product direction. When the review bottleneck creates a backlog instead of delivering value.

How do I get started?

Write a CLAUDE.md for your project. Break your next feature into 3 to 5 tasks. Write tests first. Let the agent implement. Commit after each task. Review everything. Start with a single agent. Scale to subagents and Agent Teams once the single-agent workflow is solid.