Agent-Ready Products: CLI, MCP Server or Skill

What's inside

1. Level 1: Inside the Agent Loop: What Happens on a Tool CallFree
   Learn how a coding agent turns a user request into tool calls: it reads the tool definitions in its context, picks one, fills in its arguments, reads what comes back and decides what to do next.
2. Level 2: Tool Selection: Names and Descriptions DecideFree
   See how an agent chooses between tools using only their names, descriptions and parameter schemas, and why vague or overlapping descriptions cause wrong picks.
3. Level 3: Context Cost: Every Tool Takes Up Space
   Measure what tool definitions and tool output cost in the context window, and how that cost affects accuracy, speed and money.
4. Level 4: Output an Agent Can Actually Read
   Design tool output that an agent can parse and act on: predictable structure, stable field names, identifiers it can pass to the next call, and explicit truncation.
5. Level 5: Errors an Agent Can Recover From
   Write error responses that tell the agent what went wrong, whether retrying makes sense and what to do next, instead of stack traces or bare failure codes.
6. Level 6: Why Human-Friendly Interfaces Fail Agents
   Go through the interface habits that help people but break agents: interactive prompts, pagers, browser logins, implicit state, locale-dependent output and 'are you sure?' dialogs.
7. Level 7: Diagnosing Tool Failures from Agent Transcripts
   Read real agent transcripts to find whether a failure came from tool selection, context cost, unreadable output or unrecoverable errors.
8. Level 8: CLI, MCP Server and Skill: What Each Really Is
   Build an accurate picture of the three interfaces: where each runs, how the agent finds it, what loads into context and when, and which clients support it.
9. Level 9: A Decision Method for Choosing the Interface
   Apply a repeatable method that weighs context use, reach, authentication, distribution and maintenance to choose a CLI, an MCP server, a Skill or a combination.
10. Level 10: Meet the Example System and Choose Its Interfaces
    Get to know the course's running example, an invoicing and payments API with an existing human-oriented CLI, and use the decision method to plan its CLI, MCP server and Skill.
11. Level 11: Auditing the Existing CLI for Agent Use
    Check the example system's current CLI against the agent failure patterns and produce a prioritised list of fixes.
12. Level 12: Machine-Readable Output: JSON, Streams and Schemas
    Add a stable JSON output mode to the CLI, with data on stdout, diagnostics on stderr and a documented schema that agents and scripts can rely on.
13. Level 13: Stable Exit Codes and Structured Errors
    Define a small, documented set of exit codes and matching structured error output so an agent can branch on failures without guessing.
14. Level 14: Help Text an Agent Can Follow
    Rewrite the CLI's help and command structure so an agent can find the right subcommand and call it correctly on the first try.
15. Level 15: Non-Interactive Use and Unattended Auth
    Make every command runnable without a terminal: no hidden prompts, TTY detection, flags and environment variables for every input, and credentials that work without a browser.
16. Level 16: Safe Defaults, Dry Runs and Explicit Confirmation
    Protect destructive commands such as voiding invoices or issuing refunds with dry runs, explicit confirmation flags and idempotency, so an agent can work quickly without causing damage.
17. Level 17: MCP Architecture as of the 2026-07-28 Revision
    Learn how hosts, clients and servers fit together, what the tool, resource and prompt primitives are for, and what changed when the 2026-07-28 revision made the protocol stateless.
18. Level 18: Your First MCP Tools: Schemas, Results and Errors
    Expose the example system's core operations as MCP tools with tight input schemas, structured output and tool errors the agent can act on.
19. Level 19: Resources and Prompts: When Not to Use a Tool
    Decide when the example system's data belongs in a resource or a workflow belongs in a prompt rather than a tool, and account for uneven client support.
20. Level 20: Transports: stdio vs Streamable HTTP
    Choose between a local stdio server and a remote Streamable HTTP server for the example system, and design for the stateless request model in the 2026-07-28 revision.
21. Level 21: Authorising Remote MCP Servers with OAuth
    How a remote MCP server over Streamable HTTP authenticates users under the 2026-07-28 specification: OAuth discovery, the Client ID Metadata Documents that replace Dynamic Client Registration (deprecated in that revision but still allowed for compatibility), issuer validation, and how much of this each client actually supports in October 2026.
22. Level 22: Authorisation Inside Tools: Scopes and Users
    Getting a token is not the same as being allowed to act, so this level covers enforcing per-user, per-tool permissions inside the server, mapping OAuth scopes to tools, and never trusting the model to stay within limits.
23. Level 23: How Many Tools, and at What Grain
    How to decide how many tools to expose and how big each one should be, weighing a one-to-one wrapper of every API endpoint against fewer task-shaped tools, with real context-cost numbers and selection accuracy.
24. Level 24: Long-Running Work, State and a Moving Spec
    How the 2026-07-28 specification changes server design: no sessions or initialize handshake, explicit state handles passed as arguments, the tasks extension for long-running jobs, the multi round-trip pattern that replaces server-initiated requests, and deprecated Roots, Sampling and Logging. Also covers how to build when clients and SDKs lag behind the spec.
25. Level 25: When a Skill Is the Right Answer
    What a Skill is, meaning a folder whose SKILL.md file has name and description frontmatter (Anthropic released the format in October 2025 and published it as an open standard in December 2025), and when it beats an MCP server or a bare CLI or works best alongside one.
26. Level 26: Writing SKILL.md: Frontmatter and How It Loads
    How a client finds a Skill, loads only its name and description at first, and reads the body only once it decides the Skill applies. That means the description field decides whether the Skill is ever used.
27. Level 27: Progressive Disclosure with Reference Files
    How to split a Skill into layers, with a short SKILL.md that points to reference files the agent opens only when the task needs them, so detailed knowledge costs context only when it is used.
28. Level 28: Scripts Beside Instructions
    How to bundle scripts with a Skill, so that fragile or repetitive steps run as tested code the agent executes instead of commands it rewrites every time, often by calling the agent-ready CLI from earlier levels.
29. Level 29: Names and Descriptions Are the Interface
    How to treat the names and descriptions of tools, commands and Skills as the real interface across CLI, MCP and Skills: what to put in them, what to leave out, and how they compete with every other tool in the agent's context.
30. Level 30: Destructive Actions and Permission Design
    How to keep agents from doing irreversible damage in all three interfaces, using dry runs, confirmation tokens, read-only defaults, tool annotations and client approval prompts, and why annotations are hints for the client, not security controls.
31. Level 31: Prompt Injection Through Tool Output
    How data your tools return, such as user-written text, web pages and file contents, can carry instructions that take over the agent, and the limited, layered defences a tool author actually controls.
32. Level 32: Rate Limits, Cost and Logging
    How to stop an agent that loops, retries or fans out from running up API bills and tripping rate limits, and how to log agent traffic so you can see what happened and why.
33. Level 33: Versioning Without Breaking Agents
    How to change a CLI, MCP server or Skill once agents and their prompts depend on it, knowing that a changed description or output field can break an agent as surely as a removed endpoint.
34. Level 34: Designing Evaluation Tasks
    How to write realistic, checkable tasks that measure whether an agent can actually get work done with your interface, including tasks that are unclear, that need several steps, or where using no tool is the right answer.
35. Level 35: Running Evals Across Agent Clients
    How to run the same evaluation tasks automatically against more than one agent client and model, and control the differences in tool loading, approval prompts and Skill support that change the results.
36. Level 36: Measuring Tool Choice and Task Completion
    Which numbers to compute from transcripts, such as correct tool choice, argument validity, task success, steps taken, tokens used and recovery from errors, and how to read them without fooling yourself.
37. Level 37: Improving Descriptions from Failures
    How to read failing transcripts, find the cause in a description, schema, error message or output, change one thing at a time, and confirm the fix without overfitting to your own test set.
38. Level 38: Head-to-Head: CLI vs MCP vs Skill
    How to run the same evaluation set against the example system's CLI, MCP server and Skill, and compare success, context cost and setup effort with measurements instead of opinion.
39. Level 39: Evals as a Release Gate
    How to make agent evaluations part of continuous integration (CI), so changes to descriptions, schemas, Skills or MCP spec revisions are tested against agents before they ship, while keeping run costs and flaky results under control.
40. Level 40: Final Challenge: Make a Real Product Agent-Ready Exam
    A review of the whole course: take a realistic product, choose and justify its agent interface, specify its tools and safeguards, and design the evaluation that would prove it works.

Access

The first 2 levels are free with a free account. Every level, the podcast edition and the AI tutor come with All Access at £4.99/month or any Creator plan — see pricing.

Start free →