
[100% Off] Practical Graph Engineering With Claude
Turn fragile linear prompts into multi-agent graphs that fan out, verify, and converge
What you’ll learn
- Diagnose the three failure signatures of a collapsing single-context prompt chain and explain the mechanism behind each
- Decompose a monolithic task into bounded nodes whose output you can name in one sentence
- Write JSON Schema contracts on every node boundary so orchestration code consumes objects instead of parsing prose
- Run parallel fan-outs and merge results with deterministic reducers, choosing pipelining over barriers by default
- Build the diamond topology — scout, fan-out, reduce, synthesize — with shared state and disjoint worker outputs
- Design adversarial verifier nodes and multi-lens skeptic panels that kill plausible-but-wrong findings before they ship
- Construct loop-until-dry convergence cycles with dedup keys that make convergence real rather than cosmetic
- Assign model tiers by node role to cut graph cost substantially while proving output quality is unchanged
Requirements
- Daily working experience with Claude Code or a comparable agent CLI, and the specific frustration of prompts that stop improving as they get longer
- Comfort in a terminal and the ability to read and write JavaScript — we write orchestration scripts, not application code
- A basic working understanding of JSON Schema: fields, types, and required keys
- Familiarity with git, since finished graphs are committed, diffed, and evolved like any other code
- No prior multi-agent, orchestration, or distributed-systems experience is assumed or needed
Description
This course contains the use of artificial intelligence.
You know the feeling. You open a session with a clear goal, you write a careful prompt, and for the first ten minutes it is genuinely impressive. Then it starts re-reading files it already covered. It contradicts a finding it made twenty messages ago. The specificity drains out of every answer until you are getting confident paragraphs that say nothing. So you do the only thing the tooling suggests — you write a longer, more detailed prompt — and it fails in exactly the same way, just later. This is not a prompting problem. No amount of instruction repairs an architecture where one context window has to hold the goal, the evidence, the reasoning, and the draft all at once. The window fills, the goal gets crowded out, and the model starts imitating its own earlier sloppiness.
The fix is structural. Instead of one agent doing everything in one place, you build a graph: small, scoped nodes that each do one bounded job, explicit edges that carry validated data between them, and orchestration code that decides who runs, when, and with what. Nodes that have no dependency on each other run at the same time. Claims produced by one node are attacked by an independent verifier that never saw the reasoning behind them. Discovery loops keep spawning finders until two consecutive rounds turn up nothing new. Cheap models handle extraction, expensive models handle judgment, and you can prove the difference on the invoice. By the end of this course, you describe a goal in one paragraph and Claude authors the orchestration script for it, which you review against a checklist, run, and commit as a reusable asset.
What makes this course different is that it refuses to teach on toy examples. There is exactly one project, and we rebuild it eight times. Relaystack is a 42-person developer-tooling company in Manchester whose engineering team runs its AI work on one long prompt per task; relayboard is their task-board web application, and it is our codebase for all 284 minutes. In Section 2 we run their monolithic audit prompt live and watch it collapse, on camera, with the failure signatures annotated as they appear. Every section after that is a specific architectural upgrade applied to that same pipeline: bounded nodes, then schema contracts, then parallel fan-out, then the diamond skeleton, then routers and adversarial verifiers, then convergence loops and context isolation, then model tiering and self-authored graphs. You see the same problem solved eight ways, and you see exactly what each upgrade bought.
The numbers in this course are real recorded runs, not illustrations. A four-angle fan-out produces 86 raw findings that a deterministic reducer collapses to 60 unique ones, removing 26 overlaps. A three-lens skeptic panel then takes a finding that looks certain — an authorization hole with no check anywhere in the handler — and refutes it unanimously by locating the middleware two files away, while one of those lenses turns up a real bypass nobody was looking for. A convergence loop runs until dry across five rounds, 13 then 7 then 3 then nothing twice, surfacing 23 findings the single pass never reached. A retiering pass then does something more useful than saving money: it shows the cheap tier finding every one of the same real blockers and inventing 11 false ones the expensive tier refutes by running the code. When something fails, we let it fail on screen and read the failure.
Half the lectures are hands-on labs, and each one lands immediately after the concept it exercises, while the terminal state is still fresh. You build a contract-checked two-node pipeline and deliberately break the schema to watch validation catch it. You build a triage router with a confidence fallback and feed it ten mixed issues. You build a stateful diamond, kill the run halfway through, read the state object to see precisely what completed, and resume without redoing the finished work. Three graded assignments and four quizzes track the four acts, and every assignment ships a fully worked solution — a real script, a real run log, a real verdict, not a list of tips.
You finish with a capstone: an autonomous release-readiness graph for relayboard that runs three parallel branches with per-finding verification, wraps them in a convergence cycle, tiers every node by role, and produces a go or no-go verdict with its blocking findings cited. It is parameterized, committed to version control, and runs against any repository you point it at. More durably, you leave with the decision playbook behind it — the four questions to ask of any agent task, the seven canonical ways graphs go wrong, and the symptom-to-fix map that tells you which one you are looking at.
Author(s): Dr. Amar Massoud








