Clawdemy Lessons

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.

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 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.

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 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 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 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 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 lesson on AI-authored commits and PRs: scope, learning outcomes, reading map, and prerequisites for attributing and reviewing AI code.

A learning brief on git branches: what a branch is, why branches are cheap, how HEAD moves, and when to branch versus commit directly.

Brief on cherry-pick and stash: what the lesson covers, learning outcomes, prerequisites, the reading map, and the scope boundaries it deliberately skips.

A quick orientation to commit hygiene: what belongs in a message, why commits stay atomic, and when teams adopt Conventional Commits.

Overview of the merge conflict lesson: five core ideas, prerequisites, a three-pass reading map, and what the lesson covers and skips.

A reading map of the multi-agent integration lesson: the three patterns, the lead's role, and the semantic-conflict failure mode git cannot detect.

A roadmap to the pull request workflow: the mechanical PR loop, description structure, merge strategies, review etiquette, and eight anti-patterns.

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

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

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

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 closing git lesson: stable foundations, patterns evolving today, marketing claims to ignore, and three habits for staying calm as git evolves.

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.

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

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

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

A roadmap to the API keys lesson: what a key is, the BYOK model with no Clawless markup, where keys live, the Codex OAuth path, and why keys turn red.

What CostGuard and the privacy lesson cover: a spending safety net for BYOK usage against a monthly cap, and a data path with no Clawless server in it.

Overview of the first hands-on Clawless lesson: the four screen zones, the model picker, mid-conversation switching, and what you need before you start.

Overview of the Clawless memory system: history versus memory, the four tiers, three ways memories get in, the panel controls, and the privacy rule.

A preview of the four-layer AI governance lesson: what each layer covers, why compute governance leads, prerequisites, and the placement skill you will build.

What the opening AI safety lesson covers: the four risk categories, the discipline-vs-stance frame, prerequisites, audience, and difficulty.

A guided overview of moral uncertainty in beneficial AI: the three strategies, social welfare functions, fairness criteria, and the link to outer alignment.

Overview of how game theory frames multi-agent AI risks: Nash versus Pareto outcomes, three failure modes, and four cooperation mechanisms with their limits.

A brief on why correct components yield incorrect AI systems: four complex-systems properties, Perrow normal accidents, and when layered defenses break down.

Brief on Hendrycks' four AI risk buckets, the sub-mechanisms and historical analogies inside each, and the classify-and-defend three-step move.

Overview of the deployment-time safety lesson: what robustness and monitoring failures are, their six sub-mechanisms, and the classify-and-defend protocol.

Orientation to the safety-engineering lesson: the three transferable tools (nines of reliability, eight safe-design principles, tail events) and prerequisites.

A quick orientation to the alignment problem: three failure modes (specification, proxy, deceptive) and why robustness and monitoring do not solve it.

A brief on shipping a Claude app to production: the five disciplines, the Usage and Cost Admin API, and the rollout checklist as a deploy gate.

What you will learn about Subagents (definition, four benefits, fields, creation paths) and Claude Managed Agents, plus the decision frame between them.

Editorial brief outlining deep RL's four open frontiers, how each maps to the core algorithms, the tensions among them, and the syllabus recap.

Editorial brief for the exploration lesson: three strategy families, the easy-vs-hard distinction as the main decision criterion, and the RND breakthrough.

Editorial brief on multi-task RL versus meta-RL, the three meta-RL families (MAML, RL2, PEARL), and the foundation-model parallel to academic meta-learning.

Editorial overview of the offline RL algorithms lesson: how BCQ, CQL, and IQL fix the divergence problem, plus the decision rubric and BC sanity check.

Editorial brief for the offline RL problem lesson: the fixed-dataset setting, the extrapolation-error failure mode, and the BCQ, CQL, IQL fixes to come.

Orientation for the production-grade diffusion lesson: DDIM accelerated sampling, classifier-free guidance, and the latency-quality Pareto frontier.

What to expect from the SDE diffusion lesson: prerequisites, outcomes, time, and how score matching, DDPM, and DDIM unify into one continuous-time framework.

Overview of the generative-modeling synthesis: the four paradigms recapped, systems placed on the map, and the paradigm-fluency procedure for reading releases.

A quick brief on Agent Skills (durable on-disk instructions Claude reads on demand) and Claude Code, the agent harness that makes reusable prompts shareable.

Roadmap for the agent-loop lesson: the workflow-vs-agent distinction, the 30-line loop, the stop_reason vocabulary, tool_choice modes, and loop disciplines.

A brief on Model Context Protocol (MCP): the connector request and response shapes, per-tool configuration, the L4/L5/L6 decision frame, and connector limits.