Graph Engineering Is Replacing Prompting — Boris Cherny Says Agents Should Build Themselves

Boris Cherny, creator of Claude Code, made a statement this week that's reshaping how agentic developers think about their work:

"I'm not prompting my agents anymore. I'm building 'graphs' and 'loops' — they're building my agent. In 3-6 months, we'll all be doing graph engineering for our agentic systems."

That came from a 10-minute talk that circulated widely on X this week (~511K views on one thread). If you've been spending your time writing elaborate system prompts, this is the thesis that says you're optimizing the wrong thing.

What "Graph Engineering" Means

The framing: a single linear prompt → response loop is a straight line. Most multi-step agent builds are also straight lines — step one, step two, step three, each waiting for the last to finish. Graph engineering is the deliberate construction of a graph of agentic nodes — tasks, loops, branches, conditionals, checkpoints — where the agent itself traverses and assembles the path.

Concretely:

• Nodes are units of work: a task, a tool call, a verification step, a decision point.
• Loops are the feedback cycles that make agents self-correcting — run tests, observe failure, retry, route to a fixer.
• Graphs are the structure that lets work fan out in parallel and reconverge, instead of serially waiting.

The insight from Cherny's talk (and from lilian weng's harness-engineering work and graph-of-thought research): agents get reliable not from a better prompt, but from a better structure — with feedback loops that catch their mistakes.

The Shift in a Sentence

• Prompting era: "Write a better system prompt so the agent does the right thing."
• Graph era: "Build a structure of loops and checkpoints so the agent figures out and verifies the right thing — and recover when it doesn't."

Prompts still matter. They're how you describe nodes. But the unit of control is moving from prose to structure. A loop that re-runs tests until they pass is worth more than 500 words of "please be careful and verify your work."

Practical Graph Patterns

You can start doing this today in any capable harness:

1. The verify loop — agent writes code → runs tests → if red, feeds failures back into a fix node → repeat. Claude Code's hooks and auto-poke in jcode are built for exactly this.
2. The review branch — main work node + a parallel reviewer node that runs a fresh context over the output (a pattern the site covers in code review agents).
3. The checkpoint graph — decompose a task into nodes with explicit handoffs; if a node fails, route to a repair node instead of restarting.
4. The confidence gate — before "done," require the agent to re-check against a list of acceptance criteria. Jcode formalizes this as confidence stepping — forcing a re-check when confidence jumps suspiciously.

Why This Matters Now

The tools are catching up. Hooks, permission auto-modes, background tasks, todo lists with confidence ratings, and cross-session messaging are all harness features that enable graphs and loops — not better prompts. Claude Code's new auto mode is one piece; jcode's swarms and self-dev are another. The harness is becoming the product, and graph engineering is the skill you'll need to use it.

If Cherny is right that this is where everyone's headed in 3-6 months, the developers ahead of the curve are the ones already reframing their agent projects as graphs to engineer, not prompts to write.

---

Via @0xCodez on X. Related: Graph of Thought, Agentic Prompting.