Module 1: The Stage — Why This Course Exists

Time to read: 8 minutes Time to apply: 5 minutes (self-assessment) Prerequisites: None — start here

What Most People Do Wrong

Most people who sit down with an AI coding agent for the first time do the same thing I did: type a prompt, get code back, copy-paste, and call it collaboration. It works for small things — a shell script, a one-off transformation, a regex — and that initial success creates a dangerous feeling: I know how to do this now.

You don't. Neither did I.

The first session feels productive because the agent does all the typing. The real problem shows up in session 10, session 20, session 50 — when you realise you've been treating the agent like a search engine that writes code instead of a collaborator that learns. Every session starts from zero. The agent doesn't know your Python version, your build system, or the fact that you fixed the same bug last week. You're paying inference costs for the model to rediscover everything you already figured out.

This methodology exists because I hit that wall and spent months figuring out what makes an agent actually useful at scale.

What You'll Learn

By the end of this course, you'll know:

The 13 modules that turn unpredictable LLM output into predictable, reliable systems
When to use an agent and — just as importantly — when not to
How to set up your first session so it compounds instead of resets
Why skills, memory, and verification matter more than prompting

But before we get to any of that, you need to understand the fundamental question this entire methodology answers.

The Only Question That Matters

Every time you consider using an AI agent for a task, there's one question you must answer honestly:

> Does this task need unpredictable output?

If the answer is no — if the task can be done with deterministic code, a shell script, or a lookup table — then an agent is the wrong tool. Full stop.

Agents are powerful because they can handle ambiguity, variation, and open-ended problems. They are expensive because of the same reasons. Every agent call is a gamble: you're paying for inference, waiting for generation, and reviewing output that might be wrong with total confidence.

This course teaches you the patterns that make that gamble pay off. But Phase 0 — this page — teaches you when to walk away from the table.

The Cost Of Using An Agent Unnecessarily

Let me be direct about what happens when you reach for an agent for everything:

Dimension	What happens
Your time	You wait for streaming output instead of running a 20ms command
Your attention	You review every output for hallucinations because sometimes they're plausible
Your infrastructure	You pay for inference on every call, including the ones that could be `grep` or `awk`
Your reliability	The same prompt gives different results on different days
Your debugging	You can't reproduce a bug because the output depends on model temperature

The people who get the most value from AI agents aren't the ones who use them for everything. They're the ones who are selective — who ask "should an agent do this?" before "can an agent do this?"

What The Rest Of This Course Covers

Module 2: The Waste Principle — A decision framework for knowing when NOT to use an agent. Three specific traps and how to identify them. A Try-It-Now exercise that may save you more time than the rest of the course combined.

Then the 13 modules:

Module 3: Boot — The first session that makes every other session work
Module 4: Skills — Reusable procedural knowledge
Module 5: Memory — Durable context across sessions
Module 6: Decision Protocols — Autonomy without chaos
Module 7: Tool Composition — Right tool for each job
Module 8: Orchestration — Multi-agent workflows
Module 9: Pipelines — Agents that run while you sleep
Module 10: Resilience — Never-stop loops
Module 11: Verify — Trust but verify
Module 12: Compounding — The feedback loop
Module 13: Governance — Boundaries, enforcement, and accountability for autonomous agents

Try It Now

Think about the last three things you used an AI agent for. For each one, answer:

Could this task be done with a 10-line bash script or a single API call?
Would deterministic output be more useful than an LLM's best guess?
If the agent produced a wrong answer, how long would it take you to notice?

If you answered yes to question 1, yes to question 2, or answered question 3 with "I wouldn't" — you already have a candidate for the Waste Principle in the next module.

Verification: You should have at least one concrete task in mind that you're now questioning. That's the goal.

What's Next

Phase 1: The Waste Principle — The decision framework that separates agent work from script work. Before you learn what agents can do, learn what they shouldn't.