Learn Agentic Engineering: A 3-Week Roadmap

The grid’s three weeks are really three capability levels, and the honest gate between them is not time — it is whether the previous rung is boring yet. If accepting and rejecting agent diffs still surprises you, you are not ready for hooks and swarms.

Vibe coding is fluency: you describe intent and steer a coding agent through edits, keeping the loop tight enough to catch nonsense. Vibe engineering is control: commands, checkpoints, MCP tools, and repeatable Ralph loops so the same task runs reliably, not just once by luck. Agentic engineering is orchestration: sub-agents, sandboxing, and swarms coordinating on a large codebase — covered conceptually in What Is Agentic AI?.

The capstone at the top is not a fourth skill. It is proof you can combine the lower three into something that survives a real user.

At a glance

Start by mapping which agentic coding tools exist and the foundations that make any agent useful: an AGENTS.md (or CLAUDE.md) that states stack, conventions, and guardrails, plus the context you feed each task. Tools here are interchangeable on purpose — Cursor, Copilot, Codex, and Google’s Antigravity all expose the same core loop: describe, generate, accept or reject, repeat.

The two projects on this rung are deliberately different risk classes. Project 1 is YOLO — a throwaway spike where speed beats gates, so you learn the agent’s failure modes without endangering anything. Project 2 is a commercial MVP — the first time you feel the cost of skipped verification. That contrast is the lesson: same tools, different blast radius, different discipline.

The skill you are actually building is a fast reject reflex. An agent that writes 200 lines is worthless if you cannot spot the three that silently weaken a check.

Rung two turns lucky one-off runs into repeatable workflows. Slash commands capture prompts you reuse; checkpoints let you branch and roll back agent state; Ralph loops run an agent with fresh context each iteration, reading state from disk and committing only what passes tests. This is where Claude Code Workflow — CLAUDE.md, hooks, and subagents — becomes concrete.

MCP (Model Context Protocol), skills, and plugins connect the agent to real systems: your database, issue tracker, or internal APIs as typed tools rather than copy-paste. The failure mode to respect: an agent given a mutating tool without idempotency can double-apply an action on retry. Team debugging on this rung means shared conventions and traces, not everyone prompting in isolation.

The capstone here, Project 3 (a SaaS platform), forces the question rung one dodged: can two people and an agent change the same codebase all week without breaking main?

The top rung is coordination. Multi-agents and sub-agents split work into scoped specialists (tests, security, docs); hooks fire deterministic code around agent events (pre-commit checks, post-edit lint). Zoom into one gate: a patch touching auth or payment hits preCommit, runs real tests, and returns { allow: false } — the agent cannot skip that decision. Sandboxing — often Docker per agent — bounds what any run can touch, which is what makes unattended loops safe to leave overnight.

Large-codebase workflow is the real exam: navigation, targeted retrieval, and migrations across thousands of files where no single context window holds the whole repo. This is where context engineering stops being optional. Swarms and orchestrators delegate across agents with a single owner of merge order — without that owner, you get conflicting commits and no source of truth.

The honest warning: most teams never need a swarm. One strong agent with good hooks and sandboxing outperforms five uncoordinated ones. Reach for orchestration only when you can name the specialist boundary a single agent cannot cross.

Strip the tool names and the roadmap is four projects of rising blast radius: YOLO spike → commercial MVP → SaaS platform → capstone. Each one forces the discipline the previous tools made possible. YOLO teaches failure modes; the MVP teaches verification; the SaaS platform teaches team and workflow control; the capstone teaches orchestration under a real deadline.

Skills without a shipped project are trivia. If you can explain MCP but have never watched a retried tool double-charge a test account, you have read the rung, not climbed it. Build the smallest thing that exercises each new capability, then ship it to someone who will complain.

The order is not arbitrary: each project’s failures are only survivable because the earlier rung’s control exists. Ship a SaaS platform in pure YOLO mode and you will spend week four in incident review.

Ignore the calendar. Promote yourself off a rung only when its work is boring and repeatable, not merely once-successful. New to agents? Live on rung one until rejecting diffs is reflexive. Shipping solo features reliably? Add rung-two control — commands, Ralph loops, MCP. Running a team or a large repo? Invest in rung-three hooks, sandboxes, and (only if forced) orchestration.

The anti-pattern the grid encourages is rung-skipping: chasing swarms for the résumé while still surprised by a bad diff. Autonomy must never outrun your verification — the same rule that governs the workflow control styles. When your revert rate or escaped-defect count climbs, you have climbed one rung too high; drop back and rebuild the control you skipped.