# Agentic Engineering

> Learn agentic engineering: how professionals build real software with coding agents like Claude Code, Codex and Cursor. 24 short animated lessons distilled from 80+ talks and 40+ articles by the people who build these tools. Free and open source — and your agent can take it too.

Each lesson below is a Markdown file with a summary, key takeaways, practices for coding agents, a full transcript and cited sources (talks link to exact timestamps). Content is CC BY 4.0.

## Lessons

### Module 1: The shift

- [Lesson 1: From vibe coding to agentic engineering](https://learn-agentic-engineering.pages.dev/lessons/vibe-coding-to-agentic-engineering.md): In late 2025 coding agents crossed a line: they started doing what you asked, almost every time. This lesson defines agentic engineering, separates it from vibe coding, and shows what you still own when code becomes cheap.
- [Lesson 2: How a coding agent actually works](https://learn-agentic-engineering.pages.dev/lessons/how-coding-agents-work.md): Claude Code, Codex, Cursor and Amp look different, but underneath they're the same thing: a model, a few tools, and a while loop. Once you see the loop, you'll understand why agents succeed, why they fail, and what you control.
- [Lesson 3: What agents are great at, and where they fail](https://learn-agentic-engineering.pages.dev/lessons/what-agents-are-good-at.md): Agent intelligence is jagged: superhuman on some tasks, baffling on others. The pattern isn't random. Agents fly where results are easy to verify and stumble on judgment, design and long, unchecked runs. Learn to delegate by verifiability.

### Module 2: Working with one agent

- [Lesson 4: Context is everything](https://learn-agentic-engineering.pages.dev/lessons/context-engineering.md): Almost every best practice for coding agents comes from one constraint: the context window fills up fast, and quality drops as it fills. Learn the smart zone and the dumb zone, why fresh sessions beat long ones, and the four moves of context engineering.
- [Lesson 5: The core loop: explore, plan, implement, verify](https://learn-agentic-engineering.pages.dev/lessons/explore-plan-implement-verify.md): The people who build coding agents rarely type a feature request and hit enter. They explore first, agree on a plan, implement in a fresh context, and verify. Here's that loop, why planning has the most leverage, and how to make plans that can actually be checked.
- [Lesson 6: Specs agents can execute](https://learn-agentic-engineering.pages.dev/lessons/writing-specs-for-agents.md): A coding agent fills every gap in your request with its best guess, drawn from average code on the internet. A good spec closes the gaps that matter: the goal, what done looks like, the constraints and what's out of scope. Here's how to write one, without writing it yourself.
- [Lesson 7: Talking to agents](https://learn-agentic-engineering.pages.dev/lessons/prompting-coding-agents.md): Good prompts aren't clever. They answer one question: how is the model supposed to know what I mean? Learn the habits of people who prompt agents all day: point to where knowledge lives, show a gold standard, state constraints and exit criteria, and use the short phrases that carry a lot of discipline.
- [Lesson 8: Close the loop: let agents check their work](https://learn-agentic-engineering.pages.dev/lessons/verification-closing-the-loop.md): Ask people who ship with agents for their single best tip and you hear the same thing: give the agent a way to check its own work. Tests, types, a running app, a browser. Without a check, “looks done” is the only signal, and you become the bottleneck.
- [Lesson 9: Reviewing agent code](https://learn-agentic-engineering.pages.dev/lessons/reviewing-agent-code.md): Agents write code faster than anyone can read it, and review has become the new bottleneck. Practitioners disagree about reading every line, but they agree on how to review well: scale depth to blast radius, review your own work first, use a fresh-context reviewer, and turn repeated comments into rules.
- [Lesson 10: When the agent goes off the rails](https://learn-agentic-engineering.pages.dev/lessons/when-agents-go-wrong.md): Every agent goes off the rails sometimes. The skill isn't avoiding it; it's noticing early and recovering cheaply. Learn the warning signs, the recovery ladder from a quick interrupt to throwing the work away, and the habits that make recovery cheap.

### Module 3: Your toolkit

- [Lesson 11: CLAUDE.md and AGENTS.md: memory files that work](https://learn-agentic-engineering.pages.dev/lessons/claude-md-agents-md-memory-files.md): Your agent starts every session with amnesia. A memory file, CLAUDE.md or AGENTS.md, is how it learns your project: commands, conventions and gotchas. The best ones are short, grown from real mistakes, pruned as models improve, and shared with the team.
- [Lesson 12: Tools, CLIs and MCP](https://learn-agentic-engineering.pages.dev/lessons/tools-clis-and-mcp.md): An agent is only as capable as its tools, but more tools isn't better: every tool definition costs context. Learn why the shell is the universal adapter, what MCP is for, when a CLI beats an MCP server, and how to design tools that agents actually use well.
- [Lesson 13: Skills, commands and hooks](https://learn-agentic-engineering.pages.dev/lessons/skills-commands-hooks.md): A brilliant agent isn't the same as an expert one. Skills package your team's know-how into folders the agent loads only when needed. Commands save prompts you reuse. Hooks guarantee things happen every time. Here's what each is for, and how to grow them from real work.
- [Lesson 14: Git is your safety net](https://learn-agentic-engineering.pages.dev/lessons/git-for-coding-agents.md): Agents make mistakes fast; git lets you undo them faster. And every coding agent is fluent in git, including the parts nobody remembers. Use commits as save points, history as research material, bisect for bug hunts, and branches to keep work isolated.

### Module 4: Scaling up

- [Lesson 15: Subagents: delegate to a fresh context](https://learn-agentic-engineering.pages.dev/lessons/subagents.md): A subagent is a fresh copy of your agent, sent off with its own context window to do messy work and report back only the answer. Used for context control, not role-play, subagents keep your main session sharp: exploring, running noisy tests, reviewing with fresh eyes, or trying several designs at once.
- [Lesson 16: Running agents in parallel](https://learn-agentic-engineering.pages.dev/lessons/parallel-agents-worktrees.md): Heavy users run five, ten, even hundreds of agents at once. But your attention doesn't parallelize, and naive parallelism creates conflicts and duplicate work. Learn how to isolate agents with worktrees, pick tasks that don't collide, and keep the orchestration tax under control.
- [Lesson 17: Long-running agents and loops](https://learn-agentic-engineering.pages.dev/lessons/long-running-agents-ralph-loop.md): Agents went from running thirty seconds before derailing to working for hours. The trick isn't one giant session; it's loops: fresh contexts, one task at a time, state kept in files and git, and a check the loop can't argue with. From the Ralph loop to nightly slow loops, here's how to let agents work while you're away.
- [Lesson 18: Harness engineering: build the factory](https://learn-agentic-engineering.pages.dev/lessons/harness-engineering.md): Harness engineering means: every time an agent makes a mistake, engineer it out of the system for good. OpenAI used it to ship a million lines with zero hand-written code. Learn the difference between soft and hard constraints, how to make your environment legible to agents, and why lights-off factories still fail.

### Module 5: Quality, safety, teams

- [Lesson 19: Codebases agents can work in](https://learn-agentic-engineering.pages.dev/lessons/agent-friendly-codebases.md): Bad codebases make bad agents, and agents can make a codebase bad fast: they copy whatever patterns they find, good or bad. Learn the principles that keep a codebase agent-friendly: make the shortest path the right path, deep modules, one way to do each thing, enforced architecture, simple code, and continuous cleanup.
- [Lesson 20: Evals: measure, don't vibe](https://learn-agentic-engineering.pages.dev/lessons/evals-for-agents.md): Did that new prompt, skill or model actually make things better? Most teams vibe-check. Evals turn that into a measurement. Start by reading traces and counting failure modes, then build small, binary checks from real failures, validate your judges, and read the transcripts before trusting any score.
- [Lesson 21: Security: prompt injection and the lethal trifecta](https://learn-agentic-engineering.pages.dev/lessons/prompt-injection-lethal-trifecta.md): Agents follow instructions, including instructions hidden in web pages, issues and logs written by strangers. If an agent can also reach private data and send things out, an attacker can steal that data. Learn how prompt injection works, Simon Willison's lethal trifecta, why filters and prompt begging fail, and the defenses that actually work.
- [Lesson 22: Agentic engineering in teams](https://learn-agentic-engineering.pages.dev/lessons/agentic-engineering-in-teams.md): Individuals can rewire their workflow overnight; teams can't. The teams that win with agents change how they work rather than sprinkling AI on top, share their know-how as skills and memory, keep humans accountable, and measure honestly: speed and quality together.

### Module 6: The engineer you become

- [Lesson 23: The engineer you become](https://learn-agentic-engineering.pages.dev/lessons/the-engineer-you-become.md): Kent Beck says 90% of his skills went to zero and 10% went up a thousandfold. Which 10%? Vision, judgment, design, domain knowledge, and real understanding. Here's how to keep learning when agents write the code, pay down cognitive debt, and build the skills that compound.
- [Lesson 24: What comes next](https://learn-agentic-engineering.pages.dev/lessons/what-comes-next.md): Agents went from finishing your lines to working for hours in about two years, and the curve hasn't flattened. Here's where the people building these tools think it's heading, why the bottleneck is moving from “can we build it” to “should it exist”, and a simple playbook for staying current.

## Notes

- [12 things the people building coding agents agree on](https://learn-agentic-engineering.pages.dev/notes/what-builders-agree-on.md): Distilled from 126 talks and essays by the people who build and use coding agents like Claude Code, Codex and Cursor. Each point links to the original source and a 4-minute animated lesson.

## For agents

- [Install as an agent skill](https://learn-agentic-engineering.pages.dev/agents/): `npx skills add Haple/agentic-engineering`
- [Full course in one file](https://learn-agentic-engineering.pages.dev/llms-full.txt)
- [Structured course data](https://learn-agentic-engineering.pages.dev/api/course.json)

## Optional

- [All sources](https://learn-agentic-engineering.pages.dev/sources/): 82 talks and 44 articles
- [Source code](https://github.com/Haple/agentic-engineering)