# Modern AI Software Engineering: The Orchestrator's Playbook > A practical, opinionated course for engineers who have stopped *writing* code > alone and started *directing* the systems that write it with them. --- ## What this course is Most "AI for developers" material teaches you to talk to a chat box. This course teaches you to **run a workshop**: design specialized agents, hand them contracts they can verify against, keep their memory coherent across weeks of work, and assemble the whole thing into a pipeline you can trust enough to merge from. It is built around the practitioner's reality of late 2025 / early 2026: - Agentic CLI tools (Claude Code, OpenCode) are the new IDE. - Specs are the new source of truth — not the prose kind, the *executable* kind. - Reasoning budgets, model selection, and context engineering are load-bearing skills, not optimizations. - The hard part isn't getting the model to write code. The hard part is knowing whether the code it wrote is the code you actually wanted. ## Who this is for You'll get the most out of this course if you can already: - Read and ship production code in at least one language. - Comfortable with the shell, `git`, and CI fundamentals. - Have used an AI coding assistant for more than a weekend and felt its ceiling. You do **not** need to be an ML engineer. We treat LLMs as **components**, not as research objects. ## How the course is organized Seven modules, designed to be read in order, each ending with a hands-on lab and a set of pitfalls collected from real practice. | # | Module | Labs | What you'll leave with | |----|--------------------------------------------------------------------------|----------------------------------------------------------------------------|----------------------------------------------------------------------------------------| | 1 | [Foundations & The "Thinking" Economy](modules/01-foundations.md) | [4 labs](labs/01-foundations-labs.md) | A mental model of LLMs as priced reasoning engines; rules for picking the right model. | | 2 | [Advanced Spec-Driven Development](modules/02-spec-driven-development.md)| [5 labs](labs/02-spec-driven-development-labs.md) | The ability to write specs an agent can implement *and verify against*. | | 3 | [Mastery of Agentic CLI Tools](modules/03-agentic-cli-tools.md) | [4 labs](labs/03-agentic-cli-tools-labs.md) | A configured, governed Claude Code / OpenCode setup with house rules. | | 4 | [Extending AI Intelligence](modules/04-extending-intelligence.md) | [4 labs](labs/04-extending-intelligence-labs.md) | Custom skills, MCP servers, and hooks that turn the CLI into your platform. | | 5 | [Memory Orchestration & Context Engineering](modules/05-memory-orchestration.md) | [4 labs](labs/05-memory-orchestration-labs.md) | Cross-session memory that survives compaction and onboards new agents in seconds. | | 6 | [The Meta-Agent Factory & Verification Frontier](modules/06-meta-agent-factory.md) | [5 labs](labs/06-meta-agent-factory-labs.md) | A roster of specialized agents that review each other before code reaches you. | | 7 | [The Human-in-the-Loop & Strategic ROI](modules/07-human-in-the-loop.md) | [4 labs](labs/07-human-in-the-loop-labs.md) | A defensible answer to "what is *your* job now?" and a number to put next to it. | Each module also closes with one introductory lab inline; the expanded lab files in [`labs/`](labs/README.md) take each concept further with 3–5 hands-on exercises per module. ## How to use this material - **Read sequentially the first time.** Concepts from later modules (verification, memory) only make sense after the foundations. - **Do the labs.** Every module ends with one. They are short, real, and designed to be done inside an actual agentic CLI session. - **Treat the examples as starting points, not artifacts.** Configurations rot. The reasoning behind them is what you should internalize. ## A note on tooling Examples lean on **Claude Code** as the reference agentic CLI because it is currently the most feature-complete platform for the patterns we teach (skills, MCP, hooks, sub-agents, plan mode). Where a pattern is portable, the text calls it out and shows the equivalent in **OpenCode** or another provider. The principles outlive any single tool. --- *Last revised: 2026-05.*