Advertisements

Practical Graph Engineering with Claude

Advertisements
Turn fragile linear prompts into multi-agent graphs that fan out, verify, and converge
1
1/5
(68) Ratings
1 students
Created by Dr. Amar Massoud
Advertisements

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
This course includes:
5 total hours on-demand video
0 articles
0 downloadable resources
50 lessons
Full lifetime access
Access on mobile and TV
Certificate of completion
Advertisements

Course content

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.

Who this course is for:

  • Software engineers with three or more years of experience who use an agent tool daily and have hit the wall where longer prompts stop helping
  • AI engineers building agent pipelines who need verification and convergence machinery they can defend to a skeptical reviewer
  • Tech leads deciding how their team should structure AI-assisted workflows, who need a vocabulary and a set of patterns the whole team can share
  • Staff engineers under pressure to cut the cost of AI-assisted work without losing output quality, who need measured before-and-after evidence rather than intuition
Advertisements
E85E02393BF1ABCDEF4F
Advertisements
Advertisements
Free Online Courses with Certificates
Logo
Register New Account