Clawdemy Lessons

Overview of lesson 4: tool descriptions that drive selection, actionable error design, least-privilege distribution, and building an MCP server.

Overview of lesson 1: the four parts of every agentic system, the workflow versus agent decision, and the three trade-offs architects weigh.

Overview of lesson 3: guaranteed output shape with tool schemas, nullable fields for honest absence, and validation loops with retry judgment.

Overview of lesson 6: escalation criteria that hold up, human review budgeted by segment, independent review, and multi-pass checking.

Overview of lesson 5: coordinator and subagent design, decomposition judgment, parallel delegation, structured failure, and provenance.

Overview of lesson 8: the capstone assignment, its three phases, the ten-point rubric, and why the written defense is the real deliverable.

Overview of lesson 2: the CLAUDE.md hierarchy, path-scoped rules files, shared slash commands, plan mode as a risk call, and diagnosing config drift.

Overview of lesson 7: headless Claude Code in CI, machine readable output, inherited project config, and the independent reviewer pattern.

The final lesson: watch the full multi-agent pipeline run end to end, map each report to its agent, and run the open-source system in a safe simulation.

Zoom out from the agents to the wiring: the orchestration that decides who runs next, and the shared state that carries each agent's work to the one after it.

The last loop: the system records each decision at once, then on a later run, once the outcome is known, reflects on the call and feeds the lesson back.

Overview of lesson 4: how a separate agent turns the judge's verdict into a concrete plan, builds on the decision, and runs on the cheaper model.

Overview of lesson 5: three risk voices with different priorities stress-test the trader's plan, then a separate manager on the deep model makes the final call.

Overview of lesson 3: how two agents argue the same evidence with opposite mandates, the turn limit that ends the debate, and the separate judge that decides.

Overview of lesson 2: how a real analyst agent uses tools to fetch its own data in a loop, and the structural signal that tells it to stop.

Overview of lesson 1: how a real, free multi-agent system splits a workflow into specialist roles, and why only the two judges get the most capable model.

Overview of the first-repo lesson: learning outcomes, prerequisites, reading map, time estimates, and the topics it covers and leaves for later.

Orientation for the git worktrees lesson: scope, learning outcomes, prerequisites, a reading map, and what the lesson deliberately leaves out.

Brief for the git foundations lesson: the two load-bearing ideas, learning outcomes, prerequisites, and what the lesson deliberately defers to later.

Brief on git recovery: how restore, reset, revert, and reflog each map to an area of git's three-area model, plus when each command is safe.

Overview of the closing git lesson: stable foundations, patterns evolving today, marketing claims to ignore, and three habits for staying calm as git evolves.

Overview of the four git team workflows, five load-bearing ideas, prerequisites, a three-pass reading map, and what the lesson does not cover.

Overview of the remotes lesson: the four load-bearing ideas, a three-pass reading map, prerequisites, and what it does and does not cover.

An overview of formal git releases: tags, semantic versioning, release notes, and how releases work in each workflow, with a three-pass reading map.

Pre-lesson orientation for the deeper rebase lesson: scope, learning outcomes, prerequisites, a reading map, and what the lesson deliberately leaves out.