What Is Agentic Software Engineering? The Complete Guide (2026)

The Complete Guide to Agentic Software Engineering

In early 2026, Andrej Karpathy gave a name to something practitioners had been doing for months: agentic engineering. The discipline of designing systems where AI agents plan, write, test, and ship code under structured human oversight.

But here's the thing most people get wrong about it: agentic engineering isn't about letting AI write your code. It's about letting AI write your code properly.

I've spent 20+ years building production systems for companies like Credit Suisse, Milkrun, and dozens of others across three continents. The last two years, I've been deep in AI-assisted development — first as a practitioner shipping real products, then as a trainer helping engineering teams adopt these tools. As an Anthropic Claude Community Ambassador (one of 60 worldwide), I've had a front-row seat to how this space is evolving.

Here's what I've learned: the teams that get agentic engineering right ship faster and build better software. The ones that don't end up with expensive technical debt they can't maintain.

This guide is the methodology I teach in my workshops, distilled into something you can start using today.

The Problem: Why "Just Use AI" Doesn't Work

Everyone's using AI coding tools now. ChatGPT, Copilot, Claude Code, Cursor — the barrier to writing code has basically collapsed. Anyone can generate thousands of lines in an afternoon.

But software isn't code. Software is architecture, edge cases, authentication flows, database migrations, production monitoring, and the hundred other things that happen between "it works on my machine" and "it works for 50,000 users."

I've seen developers generate 50,000 lines in a week. Then spend two months trying to figure out why none of it works together.

Vibe coders ship demos. Engineers ship products.

Agentic software engineering is what bridges that gap.

The Definition

Agentic software engineering is a development methodology where AI agents handle implementation tasks within a structured framework of human-defined specifications, quality gates, and architectural decisions.

In simpler terms: you do the thinking, the AI does the typing, and there's a system that makes sure nobody cuts corners.

I've mapped this progression in detail in my article on the 5 levels of agentic software development (from "spicy autocomplete" to fully autonomous dark factories). The methodology below is what moves you from Level 2 to Level 3 and beyond.

It's not:

• Autocomplete on steroids (that's Copilot circa 2023, or Level 0)
• "Build me an app" with a single prompt (that's vibe coding)
• Fully autonomous AI that doesn't need humans (that's Level 5, and very few teams are there yet)

It is:

• A repeatable methodology for using AI agents in production software development
• A set of practices that prevent AI-generated code from becoming tomorrow's legacy nightmare
• The discipline of knowing when to let the AI run and when to pull it back

The Framework: Spec → Phases → Plan → Implement

This is the methodology I teach. It's not theoretical — it's what I use every day and what I've trained teams at Equal Experts and dozens of other companies to use.

Step 1: Spec (Define What You're Building)

Before you write a single prompt, you need a Product Requirements Document. Not a novel — a clear, structured description of what you're building, why, and what "done" looks like.

I do this with voice-to-text. Open a new file, turn on dictation, talk through the feature. Architecture decisions, what needs touching, edge cases, acceptance criteria. Then feed it to Claude Code and ask it to structure your notes into a proper spec.

The spec is your source of truth. Every AI agent involved in implementation should be working from this document.

Step 2: Phases (Break It Into Milestones)

A 10,000-line feature doesn't get built in one shot. Break the spec into phases — logical milestones that can be implemented, tested, and reviewed independently.

Each phase should be small enough that you can review the AI's output meaningfully. If you can't read and understand everything the AI produced in a phase, the phase is too big.

Step 3: Plan (Design Before Coding)

For each phase, have the AI create an implementation plan. Not code — a plan. What files need changing, what the approach is, what the test strategy looks like.

This is where I use Claude Code's plan mode. Feed it the spec, the phase definition, and ask it to create a detailed implementation plan. Then review the plan before any code gets written.

The plan is your code review before the code exists. It's dramatically faster to fix an approach at the plan stage than to rewrite code after implementation.

Step 4: Implement (Execute With AI Assistance)

Now you let the AI write code. But not in a single session that runs for hours accumulating confusion. Here's the approach:

Clear your context. Start a fresh Claude Code session. Point the agent at the plan file and the spec. Let it implement using subagents — Claude spawns subagents per task while the main agent coordinates.

The key insight: treat Claude sessions like containers. Keep artifacts (plans, specs, guardrails). Reset the agent itself. Fresh context from actual files beats accumulated conversation every time. Long contexts lead to hallucination.

Why This Works (And Why Vibe Coding Doesn't Scale)

The Spec → Phases → Plan → Implement framework works because it maintains engineering discipline at every step. The AI handles the high-volume, repetitive parts of development. The human handles the parts that require judgment, context, and accountability.

Vibe coding skips straight to Step 4 without Steps 1-3. In my 5 Levels framework, this is the difference between Level 2 (doing AI-assisted coding without a methodology) and Level 3+ (directing AI agents within a structured process). Vibe coding works great for prototypes, demos, and side projects. It falls apart the moment you need:

• Multiple developers working on the same codebase
• Code that needs to be maintained for more than 6 months
• Production reliability under real user load
• Compliance, security, or audit requirements

The tools changed. The discipline didn't.

Getting Started

If you're an individual developer, start with one feature using this methodology. Write the spec. Break it into phases. Plan before coding. Compare the output quality to your usual approach.

If you're a team lead, pick one sprint and have the team try the framework on a real feature. Measure the outcomes — not just speed, but code review time, bug rate, and how maintainable the result is.

If you want to go deeper, I run workshops on exactly this methodology. Half-day masterclasses for individuals, full-day sessions for teams. The workshop is hands-on — you build something real using the framework, not just watch slides.

Learn about the workshops →

About This Guide

I'm Dominik Fretz — software engineer, Anthropic Claude Community Ambassador (one of 60 worldwide), and founder of Harbour Edge Intelligence. I've been building production software for 20+ years and teaching agentic engineering through workshops across Australia. I'm based in Sydney and Townsville.

Connect on LinkedIn | Book a discovery call →