
Why Graph Engineering will 10x your Claude/Codex
What this covers
Greg Eisenberg goes solo to explain a term he keeps seeing on X. He places graph engineering next to prompt engineering, which is about asking better questions, and context engineering, which is about supplying better information. Graph engineering, in his framing, concerns the structure of the work around the model. He builds the vocabulary from jobs, arrows, and state, the shared record of what the system knows so far. He also separates knowledge graphs, which help AI reason across relationships rather than return the nearest text chunk, from agent graphs, which govern how work moves between steps.
The main worked example is whether to launch an AI bookkeeping product for Shopify merchants. A planner splits the question into five research angles: customer pain, competitive landscape, distribution, pricing pressure, and risks. Parallel lanes run those angles, a skeptic challenges claims that are stale, unproven, or confuse pain with willingness to pay, and a merge step turns the surviving evidence into a recommendation to pursue, pause, or kill, with a first customer and a test for the week. He calls this the diamond pattern. The argument is that one chat pass lets a single model research, interpret, recommend, and grade its own confidence.
The later sections cover range and restraint. He shows three levels of implementation, from manual lanes through file-writing Claude steps (plan.md, review.md and so on) to LangGraph and n8n. Ready-made graphs follow for customer support, content creation, and coding. Some positions are pointed: more agent workers can just mean confident repetition of the same wrong idea, the tool should come after the workflow is understood, and oversized graphs are a trap. Human approval should be strict where mistakes are expensive. He also says the lasting payoff is accumulated memory, which he calls a moat, and that the graph produces better evidence rather than making the decision.
Graph engineering is a practical framework for decomposing AI workflows into parallel steps, checks, and approvals rather than linear chat-based interactions, enabling better quality output and institutional memory.
- Linear chat-based AI workflows conflate planning, research, grading, and recommendation into a single pass, creating high decision risk
- Structuring workflows as parallel research lanes plus explicit checking and approval steps produces better evidence and repeatable institutional knowledge
- The tool matters less than understanding the workflow structure first; manual execution of a well-designed graph outperforms automated execution of a poorly designed one
This asset isn't compiled yet
You're seeing its claims, ranked. Compile it to build the argument threads, weight them, and check each claim against your library — the full view.
A graph in the context of workflow is defined as jobs connected by arrows, where each job is a step in the workflow, arrows show what happens next, and the shared notes moving through the workflow (called state) represent what the system knows so far.
“When people say graph, they basically mean jobs connected by arrows. Each job is a step in the workflow. The arrows show what happens next. And the shared notes moving through the workflow are the state, which is just a fancy way of saying what does the system know so far?”
The real compounding value of graph engineering isn't just that one task improves—it's that work starts producing memory: every customer research graph creates better customer notes, every content graph creates better examples and audience insights, every support graph creates better product feedback, and this accumulated context becomes a moat.
“The real compounding value of gra- graph engineering isn't just that one task gets better. It's that your work starts producing memory. What do I mean by that? I mean that every customer research graph creates better customer notes. Every content graph creates better examples and audience insights. Every support graph creates better product feedback. And that's where the context becomes the moat because the graph produces the work, but it also produces the memory that makes the next graph smarter.”
Knowledge graphs help AI understand how information and relationships connect within a body of knowledge, enabling reasoning across different entities and topics rather than just retrieving the nearest matching text chunk.
“A knowledge graph helps AI reason over relationships over things. For example, this customer works at this company, this company uses this product, this product connects to this tool, this support issue relates to this feature, and this feature is owned by this team. Knowledge graphs help because AI reason across relationships in messy data.”
Content creation workflows naturally have dependencies where some steps must occur in sequence (thesis before script, script before visuals) while other steps can happen in parallel (research for examples can happen simultaneously with research for counterarguments).
“Some of those steps have to happen in order. Some of those steps have have to happen in order. You probably want the thesis before the script. You probably want the script before the Excalidraw. But other pieces can happen at the same time. One re- One researcher can look for examples while another looks for counterarguments. One could study the audience angle, while another looks for practical workflows.”
When asking a single AI model to evaluate a startup idea in one chat pass, that single model decides what matters, researches the market, interprets evidence, writes the recommendation, and grades its own confidence—creating substantial decision risk if the analysis informs years of work.
“One model in one pass decided what mattered, researched the market, interpreted the evidence, wrote the recommendation, and graded it in its own confidence. That's a lot of trust to put into one blob of text. In some cases, you might spend years of your life based on this one question that you asked, and you might be working on the wrong thing.”
For your first graph, start manually without automation: give each job its own lane (customer research lane, competitor research lane, distribution research lane), run the checker lane, run the merge lane, and only automate after the manual version proves it produces better work.
“For your first graph, you can actually run it manually behind the scenes. I don't know why more people don't do this. The important thing is the structure. Give each job its own lane. One lane does customer research, another lane does competitor research, another lane does distribution research. Then the checker lane attacks the evidence, then the merge lane turns the surviving evidence into a recommendation. That is already graph engineering. It's like level one of graph engineering.”
Prompt engineering focuses on how to ask AI better questions, context engineering focuses on giving AI better information, but graph engineering focuses on designing the work structure around AI so the entire workflow doesn't live inside one messy chat conversation.
“Prompt engineering is how you ask the AI for a better question, and context engineering is how you give AI better information. But graph engineering is how you design the work around the AI, so the whole thing stops living inside inside one messy, giant AI chat.”
The tool should come after understanding the workflow; automating a workflow you don't understand creates a mess, whereas understanding the workflow first makes automation obvious and clean.
“The tool is not the point. Uh the tool should come after the workflow. If you automate a workflow you do not understand, you get a mess. If you understand the workflow first, automation then becomes super obvious”
Use graph engineering when the work has multiple steps, multiple sources, multiple possible paths, checks, risk, or approvals—but not for simple tasks like brainstorming 10 names or summarizing a short email.
“When should you use graph engineering? Well, use it when the work has multiple steps, multiple sources, maybe multiple paths, checks, risk, or approvals. Honestly, if you're asking AI to brainstorm 10 names for a new project, you probably don't need a graph. If you're asking AI to summarize a short email, you probably don't need a graph.”
Customer support workflows naturally decompose into a graph: classify the issue type, check customer account context, search documentation, draft a response, check the draft for accuracy and risk, and finally route to human approval for high-stakes issues (refunds, angry customers, legal risk).
“A simple support graph might start by classifying the issue. Is it billing? Is it product confusing? Maybe it's a bug, or cancellation risk, or maybe it's something else. Then the graph checks account context. So, is it a new customer? Are they high value? Have they written in before? Are they frustrated? Then it searches the docs, or internal policies. You might have like a whole wiki for your company, maybe a notion board, maybe it goes and explores that. Then it drafts a reply. Then a checker reviews the reply for accuracy, tone, and risk. Then a human approves anything involving refunds, account changes, angry customers, legal risk, or promises that a company just might regret later.”
The skeptic role in a graph should challenge weak findings by asking: what claims are actually supported by evidence, which evidence is stale, which competitors are being ignored, where are we confusing pain with willingness to pay, and where did the AI sound confident without proving anything?
“The skeptic asks, what claims are actually supported? Which evidence is stale because you're going to have data that is just old. Which competitor is being ignored? Where are we confusing pain with willingness to pay? Where did the AI sound confident without proving anything?”
More agents don't automatically mean better output—sometimes more agents mean more noise, five AI workers confidently repeating the same wrong idea, or the system spending more time coordinating than thinking.
“There is one mistake that I want to warn against, which is more agents don't automatically mean better output. Sometimes actually more agents mean more noise. Sometimes it means five AI workers confidently repeating the same wrong idea. Sometimes it means the system spends more time coordinating than thinking.”
The merge step takes surviving evidence (findings that passed the skeptic's challenge) and synthesizes it into a recommendation that answers: Should we pursue this? Should we pause? Should we kill it? What is the wedge? Who's the first customer? What should we test this week? What evidence would actually change our mind?
“Then comes the merge. The merge step takes the surviving evidence and turns it into a recommendation. Should we pursue this? Should we pause it? Should we kill it? What is the wedge? Who's the first customer? What should we test this week? And what evidence would actually change our mind?”
A good graph should remove fake waiting, separate workers from checkers, require human approval where mistakes are expensive, stop when the answer is good enough, and leave behind useful state (meeting notes, evidence, drafts, sources, decisions) for later reuse.
“A good graph should remove fake waiting and it should separate workers from checkers. And really it should be human approval where mistakes are expensive. And it should stop when the answer is good enough. Shouldn't need to continue. And it should leave behind the useful state, the meeting notes, the evidence, the drafts, the sources, and the decision so that you can use it later.”
The diamond-shaped workflow pattern (split into multiple parallel paths, checks work, merges back to one answer) is the fundamental structure that enables efficient graph workflows.
“A diamond starts with one question, splits into multiple parallel paths, checks the work, and then merges everything into back into one answer.”
The goal is to build the smallest graph that improves work quality, not the biggest graph possible—even when people share impressive large graphs on X.
“The goal is not to make the biggest graph possible. I've seen people on X, you know, go viral with these big big graphs, but that's not the goal. The goal is actually to make the smallest graph that improves the quality of work.”
Most people use AI in straight lines (chat: research → summary → draft → edits → titles) because chat makes everything feel sequential, but when work has multiple pieces that can happen in parallel, straight-line chat becomes slow, fuzzy, and hard to trust.
“Most people use AI in a straight line because chat makes everything kind of feel sequential. You ask for research, then you ask for summary, then you ask for a draft, and then you ask for edits, then you ask for titles. That works for really simple things, but when the work has multiple pieces, the straight-line chat starts to get slow and fuzzy and actually hard to trust.”
Customer research for startup ideas should answer: Are they using existing tools? Are they frustrated or just accommodating? Are they looking for automation, or do they prefer hiring someone to clean up the mess once monthly?
“Are they using QuickBooks? Are they using spreadsheets? Are they hiring bookkeepers? Are they annoyed at tax time? Are they looking for automation or do they just want someone to clean up the mess once a month?”
The human gate intensity should match decision cost: if the output is a private memo, the human gate can be light; if the output is a customer email, a public post, code that deploys, a refund, or anything touching production data, the human gate must be strict.
“If the output is a private memo, maybe the human gate is light. If the output is a customer email, a public post, code deploys, a refund, or anything touching production data, you got to have a human gate that's stricter.”
By the end of this episode, listeners should be able to take any AI workflow they already run (customer research, port triage, content production, startup idea validation) and turn it into a simple map of steps, checks, handoffs, loops, and human approvals.
“By the end of this episode, I want you to be able to take one AI workflow you already run, like customer research, port triage, content production, or startup idea validation, and turn it into a simple map of steps, checks, handoffs, loops, and human approvals.”
The intermediate version of graph automation uses Claude or code tools where each step writes output files (plan.md, customer.md, competitors.md, distribution.md, review.md, recommendation.md), leaving a paper trail that enables version comparison and workflow reuse.
“The intermediate version is Claude code, code acts, or repo where each step writes files. The planner writes plan.md, the researcher writes customer.md, competitors.md, and distribution.md, and the skeptic writes review.md. The merge step writes recommendation.md. What's cool about that is it leaves a paper trail and that's that's really nice. You can see what happened. You can compare versions and you can actually and you can actually reuse the structure next week or a few weeks later.”
Once you have one working graph, you transition from just prompting AI to managing AI work—evolving into an agent manager and stepping into a new level of AI leverage.
“And once you have one graph that works, you're not just prompting AI anymore, you're managing AI work. It's sort of this like next level in uh being an agent manager and and really just like stepping yourself into this new world uh deep into this new world where uh you're getting the most out of AI”
For a startup idea evaluation specifically, the planner breaks the question into five research angles: customer pain, competitive landscape, distribution opportunity, pricing pressure, and risks.
“The planner would say something like, 'To answer this well, we need to understand the customer pain, the competitive landscape, the go-to-market wedge, the pricing pressure, and the risks.'”
Competitor research should investigate not just software competitors but also incumbent solutions: accounting firms doing manual bookkeeping, freelancers on Upwork/Fiverr, App Store products in adjacent categories, and any other way customers currently solve the problem.
“Are there already Shopify bookkeeping tools? Are there accounting firms building this manually? Are App Store products solving this at all? Are freelancers on Upwork or Fiverr doing the work in a way that software could partially replace?”
Graph engineering does not magically make the decision for you—it gives you a better way to produce the evidence you use to make the decision.
“Graph engineering does not magically make the decision for you. It gives you a better way to produce the evidence you use to make the decision.”
The phrase 'graph engineering' itself emerged as AI terminology viral on Twitter, reflecting the broader pattern where new AI jargon appears every few weeks—some is hype, some is genuinely useful.
“I came on here to talk about a term I keep seeing going viral on Twitter. It's graph engineering. You've seen it. I've seen it, too. And I'll be honest, the first time I saw it, my reaction was, 'Okay, is this a real thing, or did we just invent another phrase to make everyone feel behind?' Because AI has this funny habit where every few weeks, there's this new term that goes viral. Prompt engineering, context engineering, agent engineering, vibe coding, uh loop engineering, and now graph engineering. Some of these phrases are hype. Some of them are actually useful.”