Agentic Systems Course
A multi-agent research-and-writing pipeline in Claude Code that catches its own mistakes — built as the teaching spine for a course on designing agentic systems.
The problem
Most “agentic AI” content teaches prompting tricks, not system design. Nobody shows you what happens when you actually wire multiple agents together to produce something you’d stake your name on — a report, a brief, a piece of published content — and then watch it fail in the specific ways multi-agent systems fail: a revision pass that quietly deletes a section nobody asked it to touch, a fact-checker that’s too trigger-happy and burns your review budget on false alarms, a citation that points to the wrong source after the third editing pass.
That’s the same problem any team putting agents in front of research, reporting, or content workflows runs into once they move past a demo. A single well-prompted agent can draft something plausible. Making that output trustworthy enough to ship — with verification, an audit trail, and a system that knows when to stop revising versus when it’s making things worse — is a different and much less-discussed problem. I built this to work through that problem directly, using it as the anchor project for a Udemy course on agentic AI implementation rather than a one-off toy.
The approach
At its core is a single slash command, /research-writeup, that runs a full pipeline end to end: an orchestrator decomposes a research question into 3–5 sub-questions, fires parallel researcher subagents at them, builds a priority-tagged outline (each section marked “must” or “nice,” which later tells the critic how harshly to judge a gap), hands the outline and findings to a writer subagent, and saves the draft. From there it gets adversarial on purpose — a fact-checker and a critic run in parallel against the draft, checking claims-to-sources and outline fidelity respectively, and the orchestrator applies explicit rules to decide REVISE or ACCEPT (any unsupported claim, more than two overstated claims, or a high-severity critic finding triggers revision).
The part that makes it more than a linear pipeline is the revision loop: up to three surgical revision passes, each followed by re-verification that adds a third agent, a regression-critic, whose only job is diffing the previous draft against the new one to catch what the revision broke — a silently dropped section, a reworded quote, a claim reattributed to the wrong source, a new sentence with a dangling “this.” Termination isn’t open-ended: a catastrophic-rollback rule reverts to the original draft if a revision pass makes things more than 50% worse, a convergence rule ships once flagged issues hit zero, and a non-converging rule stops the loop early once it’s clear more passes won’t help. Two hooks run automatically on every save — one checks word count, citation resolvability, and date/ID consistency in real time; the other snapshots every version with an auto-generated diff, which is also how the regression-critic gets its “before” copy. The pipeline has produced real multi-thousand-word cited research articles this way — on multi-agent orchestration best practices and on the state of agentic implementation tooling — not just test runs.
What I learned
The versions/ folder in this project is itself a small case study, because every agent, hook, and command file is kept at every iteration with unified diffs and a written rationale for each change, from v1 (orchestrator + researcher + writer, no verification at all) up through v3.2. The lesson that mattered most: verification agents need calibration as much as the thing they’re verifying. An early run showed 6 of 10 final-pass “high severity” flags were false positives — mostly a critic penalizing paragraph-level citation density that was actually fine at the section level. Fixing that wasn’t about writing a better prompt in the abstract, it was about watching a real failure and tightening the critic’s rules until the false-positive category disappeared entirely.
The second lesson was that the verifier that catches issue #1 usually isn’t the verifier that catches issue #2. The original critic checks the draft against the outline; it has no idea what the previous version of the draft looked like, so it’s structurally blind to regressions introduced during revision. That gap only became visible once a revision pass took a HIGH-severity count from 11 to 21 — the fix taught in the course was a system, not a smarter prompt: a dedicated regression-critic with diff access, plus a hard rollback rule for when a revision pass goes badly wrong rather than trusting the loop to self-correct.
Where this could go
The pattern here — a generator, an independent verifier, a second verifier scoped specifically to catch what revision introduces, and a versioned audit trail of every draft — generalizes past research articles to any team producing AI-assisted output that has to be trustworthy on the first read: compliance and audit reporting, competitive intelligence briefs, technical documentation, customer-facing content at scale. The research notes gathered alongside this project (a running library of findings on Claude Code Agent Teams, subagent-vs-team architecture, and skill design) already point at the next step: swapping independent parallel subagents for a genuine agent-team topology where verifiers can message each other and debate, and giving different reviewer agents domain-specific context the way a “Code Owners” model assigns different reviewers to different systems — rather than one generic critic checking everything against one generic bar.
At team or org scale, the honest takeaway is that the review discipline is the product, not the drafting. Any organization deploying agents to produce reports, content, or analysis will eventually need exactly this kind of layered verification with a rollback path — the alternative is agents that produce polished-looking output nobody has actually checked.
Takeaway
The hard part of agentic systems was never getting an agent to draft something — it was building the machinery that knows when to trust the draft, when to revise it, and when to admit a revision made things worse and back out.
Text summarized and optimized using Anthropic’s models and reviewed by a human.