AI-Augmented Engineering: Working with Coding Agents
The daily craft of working with an AI coding agent: brief it well, drive the session, and review what it made as if a stranger wrote it.
A coding agent is a fast, literal junior engineer with no memory of yesterday and no idea what you did not tell it. This course teaches the craft inside a session: a standing brief the agent reads every time, skills for repeatable work, plans before builds, guardrails in code, and a review posture that catches the specific ways agents fail. You practice on the same tiny bookshop app as Spec-Driven Development for Dummies, with the coding agent Quill, and Eve, the built-in tutor, is one highlight away.
7 lessons · about 6 hours of reading · quizzes graded by code and by Eve
- 1CLAUDE.mdthe standing brief, read every session
- 2.claude/skills/procedures loaded on demand
- 3Task briefgoal, done, constraints, do-not-touch
- 4plan.mdplan mode before any edit
- 5Split sessionsone task per session, worktrees in parallel
- 6.claude/settings.jsonallow, ask, deny, and hooks
- 7Review checklistread it as a stranger's PR
- 8Finding to ruletest, hook, or brief line
How the course is organized
| Phase | Question it answers | Lessons |
|---|---|---|
| Brief | What does the agent need to know before it starts, and where does that knowledge live? | L0–L2 |
| Drive | How do you run a session so the agent does the right work, and how do you stop it doing the wrong work? | L3–L4 |
| Review | How do you check what it made, and how do you turn each mistake into a rule? | L5–B1 |
Modules
Start Here
The agent loop, what the agent can and cannot see, tools and permissions, and why a task without a definition of done ends wrongly.
The Brief
The standing brief in CLAUDE.md, imports and boundaries, the rule-the-agent-breaks test, and skills and subagents for repeatable work.
The Session
Task sizing, plan mode, steering and restarting, context hygiene, parallel worktrees, and guardrails in code with permissions and hooks.
The Review
Reading an agent's diff as a stranger's pull request: the six common failures, the checklist, self-review, and turning every finding into a rule.
Bonus
A realistic week of agent-augmented work, the two numbers that show whether it helps, team conventions, and the five anti-patterns.
Every lesson
Module 0Start Here
- L0Brief· 35 min Not startedHow a Coding Agent Works
The agent loop, what the agent can and cannot see, tools and permissions, why long sessions drift, and why a task without a definition of done ends wrongly.
Module 1The Brief
- L1Brief· 55 min Not startedCLAUDE.md: The Standing Brief
Write the CLAUDE.md the agent reads every session: five sections, imports for what every task needs, a line for every mistake the agent breaks, and nothing the code already shows.
- L2Brief· 50 min Not startedSkills: Packaging Repeatable Work
Turn a procedure you keep re-explaining into a skill the agent loads on demand, give it arguments and supporting files, hand isolated jobs to a subagent, and write a task brief that starts each piece of work.
Module 2The Session
- L3Drive· 60 min Not startedDriving a Session: Plan, Steer, Restart
Size the task, get a plan before any edit, watch the first three actions, steer with one sentence, restart when the session drifts, keep the context clean, and run parallel sessions in worktrees.
- L4Drive· 55 min Not startedPermissions and Hooks: Guardrails in Code
Pick a permission mode, write allow, ask, and deny rules, add hooks that block, ask, and format, and log every decision so a review finding can never recur.
Module 3The Review
- L5Review· 55 min Not startedReviewing an Agent's Diff
Read every agent diff as a stranger's pull request, spot the six ways agents fail, run the ten-question checklist, decide fix, send back, or restart, and turn each finding into a test, a hook, or a brief line.
Module 4Bonus
- B1Bonus· 30 min Not startedBonus: A Week With an Agent
Walk through a realistic week with Quill, measure wait time and review time per task, adopt the conventions that make agent work reviewable by anyone, and name the five anti-patterns and their fixes.
Meet Bramble Books, Shelf, and Quill
The same world as Spec-Driven Development for Dummies. Bramble Books is a small bookshop chain; Shelf is its TypeScript web app (inventory, orders, gift cards, customer emails); Quill is the coding agent, running on Claude Code. Omar, the engineer, learns the craft; Jun, the senior engineer, reviews his pull requests. Three change requests recur: a low-stock badge, an async/await refactor, and a nightly sales email.
| Tool | What it does | Risk tier |
|---|---|---|
CLAUDE.md | The standing brief: what Shelf is, how to test it, conventions, boundaries, where to look | Read at the start of every session |
.claude/skills/ | Packaged procedures such as release-notes and new-endpoint | Loaded when invoked or relevant |
.claude/agents/ | Subagents with a fresh context and a fixed job | Report back to the main session |
plan.md | Steps, files, commands, and what will not be touched | Omar edits, then approves |
.claude/settings.json | Allow, ask, and deny rules; PreToolUse and PostToolUse hooks | Enforced on every action |
docs/review-checklist.md | Ten questions for every agent diff | Jun reviews as a stranger |
Written as the day-to-day companion to Spec-Driven Development for Dummies. Agent configuration examples follow Claude Code's documented shapes for memory files, settings, hooks, skills, and subagents. All lesson text, examples, quizzes, the glossary, and the Bramble Books scenes were written for this course.