GuideAdvanced
Working with Coding Agents
Learn to direct coding agents as a professional craft, not improvisation. This guide covers the six pieces that separate amateur use from professional use: the craft of directing instead of writing code directly, spec-driven development, harness engineering — the environment, context, and permissions you set up so the agent can verify itself — verifying and reviewing what the agent generates, budgeting and controlling token and time cost, and governing AI-generated code within a team. By the end, you can write executable specifications, prepare an agent-ready repository, review — not just accept — what an agent produces, control how much you spend in tokens and human attention, and write the playbook that governs how your team works with agents.
- 48
- lessons
- 6
- modules
- English · Spanish
- available in
- Yes
- certificate
- Free
- access
Outcomes
What you'll be able to do
- Classify any task from your backlog as delegable, collaborative, or your own to do, using an explicit criterion: reversibility, cost of an error, and clarity of the success criteria
- Turn a real feature into a complete specification package: context, scope, non-goals, constraints, and executable acceptance criteria
- Break a specification down into agent-sized tasks, and review its plan before letting it write a single line of code
- Leave a repository agent-ready: project instructions the agent actually respects, reproducible commands, least-privilege permissions, and a feedback loop with tests, types, and a linter
- Review an AI-generated change with an explicit procedure: a confidence gradient by surface touched, an ordered reading of the diff, and a review checklist
- Decide with judgment between accepting, fixing, or rejecting and restarting a change, without getting stuck fixing something you should have discarded
- Instrument your workflow to know the real cost per task in money, time, and attention, and choose model and parallelism level with your own data
- Define stop conditions and spend circuit breakers before a task eats your whole afternoon
- Write and defend a team playbook for AI-assisted code: ownership and accountability, versioned shared instructions, PR policy and automated gates, and architecture and licensing rules
Before you start
What you need to bring
It's for you if...
- Devs who already use a coding agent (Claude Code, Cursor, Copilot, Cline) and want to move from amateur use to professional craft
- Teams that need to define how AI-generated code gets reviewed, approved, and governed before it reaches production
- Tech leads who need a playbook so several people can use agents without breaking conventions or architecture
- Devs who want to control the token, time, and attention cost of working with agents, not just the quality of the result
Requirements and materials
- Having used a coding agent at least once, and knowing how to read a diff
- Basic Git and Pull Request workflow
- A language with automated tests: the examples use Python and TypeScript
Content
The syllabus, module by module
Open any of them to see its lessons.
- 1. Introduction: what changes in your day when the agent arrives
- 2. The inverted skill hierarchy
- 3. What stays yours: judgment, design, and evaluation
- 4. Anatomy of the daily work loop
- 5. Task triage: what you delegate, what you pair on, and what you do yourself
- 6. Intent before prompt: what you write before you write the prompt
- 7. The hidden cost of a badly run loop
- 8. Project: your log and your measured baseline
- 1. Introduction: the specification is the new source code
- 2. Why long prompts stop working
- 3. Anatomy of a workable spec
- 4. Acceptance criteria that verify themselves
- 5. Decomposition: the right size for a task
- 6. Specifying against existing code
- 7. Reviewing the plan before letting it execute
- 8. Project: spec pack for a real feature
- 1. Introduction: the agent is half the system
- 2. Context engineering: what to load and what to hide
- 3. Project instructions the agent actually respects
- 4. Tools and permissions: least privilege for the agent
- 5. The feedback loop: giving it automatic signal
- 6. Reproducible commands, test data, and environment
- 7. Session management: context that survives a restart
- 8. Project: leaving a repository agent-ready
- 1. Introduction: why 'it compiles' isn't 'it's correct'
- 2. The trust gradient by type of change
- 3. How to read a generated diff
- 4. Deriving the checklist FROM your specification and turning it into a PR template
- 5. Tests as the contract, not decoration
- 6. API verification and version drift routine
- 7. When to fix and when to reject and restart
- 8. Project: run three generated changes through the procedure
- 1. Introduction: the three budgets you manage
- 2. Measuring the real cost per task
- 3. Context window economics
- 4. Choosing the model by task
- 5. Parallelism: when running several tasks at once actually pays off
- 6. Stop conditions and spend limits
- 7. Real speed versus perceived speed
- 8. Project: cost-instrumented workflow
- 1. Introduction: from personal discipline to team policy
- 2. Authorship and accountability: who signs the code
- 3. Shared, versioned, and reviewed instructions
- 4. PR policy and quality gates
- 5. Architectural drift and recorded decisions
- 6. Licensing, provenance, and data policy
- 7. Growing juniors on a team that already works with agents
- 8. Project: team playbook for AI-assisted code
Common questions
What people usually ask
No limit. It's a free guide: come in whenever you like, as often as you like.
No. Modules run from easier to harder, but you can jump to the one you need. Progress is saved per lesson.
Whatever is needed is listed under “What you need to bring”, above. If nothing is listed there, you can start from zero.
In the Club's WhatsApp group, and every two weeks there's a live with an instructor where questions get worked through.
Yes. It's issued automatically once you finish every lesson, with a verifiable code you can share on LinkedIn.
Start whenever you like
What students say
These reviews are from enrolled students who completed at least 50% of the course. We moderate reviews only on content grounds (spam, offensive language, personal data), never for being critical or negative.
No approved reviews yet.
Be the first to share your experience!