Clawdemy Lessons

Overview of lesson 8: your job is a bundle of tasks, AI touches tasks not titles, and exposed means reachable by AI, not doomed. A tool, not a prophecy.

Overview of lesson 7: the copyright fight over AI, whether training on others' work was allowed, and who owns what a model makes. A debate, not a verdict.

Overview of lesson 6: the four-part map of generative AI risk, the levers that answer each square, and why safety is a tuned choice, not a property.

Overview of the final lesson: tell a mistake from a lie, learn what a hallucination is, and build the habits that keep your footing when anything can be faked.

Overview of lesson 5: one true story shaped for three readers, a machine that interviews you first, persona rehearsal, and the polish or fabrication line.

Overview of lesson 4: the two filters for handing a task to AI, four signs of task fit, four consequence questions, and a verdict for your own task.

Overview of lesson 3: system prompts that persist, retrieval from your own documents, who tailors an assistant, and machines that see and speak.

Overview of lesson 2: the task, instructions, context anatomy, why the same question gets different answers twice, two upgrades, and personas.

Overview of lesson 1: the prediction machine idea, the 2022 turning point, three breaks from older AI, and the two questions this track answers.

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.