Learn
Start with Foundations for the core concepts, choose a curriculum for an ordered path through a subject, or use a guide for a specific workflow. Curriculum stages state their prerequisites, intended outcomes and readiness checks. Browse between curricula to choose a subject, not to advance to the next lesson.
Foundations, curricula and guides
Foundations come first. Choose a curriculum by its prerequisites, not its position in this list.
One sentence followed from raw text to a predicted next token: tokenisation, token IDs, embeddings, attention and sampling, and what each step decides about cost and behaviour.
Follow a document assistant from a user goal through model decisions, authorised tools, observations and verification, with a visual agent loop.
An agent is a model plus a harness. What the harness is, the seven subsystems every one of them implements, and why the hardest parts are context, verification and the credential boundary.
Designing the system that prompts the agent, rather than prompting it yourself: what a loop contains, what the first measurement of real adoption found, and why the evidence for the value claims does not yet exist.
Pausing an agent for human approval: how interruption and checkpointing actually work, what persistence does not guarantee, and the evidence that approval gates decay into rubber stamps.
When to split agent work, how adaptive routing differs from adding workers, and what published research says about coordination failures, verification and cost.
Separate model proposals, tool attempts and real outcomes; follow an uncertain write through a redacted trace and turn the failure into a regression test.
A staged path from modelling a domain in tables to evolving a live schema under traffic, covering normalisation, storage internals, index design, the query planner, transactions and migrations, with a verifiable capability at each stage.
A staged path from using an LLM API correctly to shipping an evaluated, guard-railed RAG or agent system, with a verifiable capability per stage.
A staged path from Linux fundamentals to running highly available, observable services on Kubernetes, with a verifiable capability at each stage.
A staged path through the Messages API, tool use, Claude-specific evaluation, MCP, Claude Code permissions, and production cost, latency and failure.
A runnable document-assistant course covering model interfaces, reducers, retrieval evaluation, bounded delegation and persistent approval, with an offline lab and an interactive state diagram.
Version control and collaboration, from commits to team workflows.
Define, design, build, evaluate, deploy, monitor and iterate.
How to use these
The stages are ordered by dependency, not by difficulty, so skipping one usually means the next stage makes less sense rather than being harder. Each stage ends with a check written as something you can do, not something you have read. If you cannot do it, the stage is not finished, however much of the reading you have got through.
The paths overlap deliberately. Availability and failover appear in both the database and infrastructure paths, from different sides; retrieval in the AI path assumes the indexing material from the database path. Where a topic is covered better elsewhere, the stage says so and links across rather than repeating it.
Start with a practical exercise
The document-assistant lab runs locally without a model account. Follow message state, score retrieval failures, then approve or reject a proposed action. Its interactive diagram is a teaching simulation; the Python exercises test the actual checkpoint and outbox behaviour.
Extend your learning
These are suggested project directions, not additional completed courses. Use the linked reference material to frame an experiment and keep its limits explicit.
- Document ingestion and retrieval: preserve source locations while parsing a document, then test questions whose evidence is missing.
- Evaluation design: separate development questions from held-out questions and report failures, not just an average score.
- Tool contracts: validate arguments, bound attempts and test a denied operation without executing it.
- Model Context Protocol: trace the client/server boundary and identify which component authorises tool access.
- Failure diagnosis: distinguish the application, replication and coordination paths before proposing recovery steps.