Coherence Graph

We just fixed a leaking pipe in our house.

Now we’re in the process of fixing the water damage and mold the leak created without us knowing. We only found out when there was noticeable water in the garage because my wife was mindful enough to look.

Water flowing through the pipes in your house is like the information flowing through work—the chats, the emails, the meetings, the tickets, the designs, the code reviews.

Information can leak; or stop; or burst; or flow seamlessly through the system. It’s not just about making sure information is flowing cleanly through the work. You also need to pay attention when things change.

Managing the flow of information is a constant process. Only when you’re tapped into the work can you sense the signals of incoherence.

Use intuition to sense changes.

Use integration to find misalignment.

Use iteration to resolve points of tension.

Coherence drift happens when information silently degrades without awareness.

If you don’t pay attention, the degradation can turn catastrophic, like water damage causing structural issues, mold, and costly losses.

The “process” I’m running today is nothing like the one I used a year ago. I put process in quotes because I don’t even think of it as a process anymore. It’s more intuition-driven than anything else. Part of it is by design because I believe in developing a feel for each company, team, and product, and using that feel to develop a system of work to maximize value creation, quality refinement, and strategic momentum.

But part of it is a byproduct of AI.

Execution is cheap now. Writing code by hand is like building a desk by hand. You do it because you enjoy the slow process of creation through craft, not because it’s the best way to do it. Sad, I know, but it’s where we are. I love writing code, but I’m directing and reviewing it now instead of typing the characters.

I moved up the abstraction chain. I manage information to create a shared understanding across the team, product, and codebase.

My job is to maintain coherence.

Coherence in the product so users know what the product does and how to use it.

Coherence in the system so the technical foundation is stable and the work is clear.

Coherence in the team so everyone shares an understanding of the product system.

Coherence is different from understanding. If multiple people hear the same information in a meeting, they can walk away with separate understandings.

Coherence is a shared mental model of the context surrounding an idea.

Designers are remembered for their understanding, not their mockups.

Engineers are remembered for their understanding, not their functions.

A craft isn’t about the artifacts. It’s about the understanding developed through the process of creating said artifacts. Without doing the work of design or writing code, you create coherence debt as you bypass the friction. It accumulates, it grows, it compounds as you rely more heavily on AI doing the execution.

But it doesn’t have to be this way.

AI democratized creating artifacts, but not creating coherence. That’s its own craft.

Humans can work with AI and maintain coherence in products, systems, and teams.

The Coherence Graph is how I work with AI to turn information into understanding and understanding into coherence. I leverage all intelligence, human and AI, leaning into the strengths of each. And I never sacrifice my own critical thinking.

Because I didn’t spend two decades learning skills, gaining experience, and collecting knowledge to write one-sentence prompts and blindly follow high-powered machines. I care too much about the craft, about thinking, about the slow labor of quality work.

Coherence Graph follows a five-step process:

1. Capture the context.
2. Integrate all thinking.
3. Resolve the tensions.
4. Build in iterations.
5. Compound the coherence.

Capture

Software is a collection of files and folders deployed to a server. Work is managed in a version-control system to track changes and make it easy to collaborate on iterations.

New work is built as branches off of the latest commit on the main branch. Each new thread diverges from the current state to work in its own isolated environment. Once the work is complete, reviewed, and approved, it’s merged back into the main branch and deployed to the production environment.

In the same way, new ideas create branches from your current understanding, which is like the production version representing the latest information you have. Each time we improve our knowledge, our current understanding is updated. Coherence is created when the understanding is consistent and shared across the product, the team, and the system.

Capture is the first step in the process. You start by reflecting your current understanding into an external system. Get it out of your head and onto paper, so to speak. This is the practice to help you identify the gaps in your knowledge. Knowing what you do know helps you find out what you don’t know.

This is a human endeavor.

You can’t outsource understanding to AI.

I love to start with writing. There’s no better way to test your knowledge on a topic than to force the words out. You don’t understand something if you can’t articulate your thoughts. When I write and can’t find the right words, I just list everything I can think of, including questions and what I don’t know.

Linear is the hub. I make sure everything ends up in Linear—feedback, ideas, tasks. There are a lot of integrations with other tools, so funneling information in is easy.

Capture needs:

1. A single system to hold the work.
2. Easy ways to add new information.
3. Consistent usage across the entire team.

Integrate

You begin with your current understanding of the work, like the current version of your product in the production environment. It represents everything you know and don’t know, marking a path for discovery.

It’s the initial node you branch from.

Integrate is where you branch out, starting new threads and engaging with multiple perspectives to expand your thinking.

The work is collaborative. You engage with customers, stakeholders, team members, AI, and any other data points that enhance your understanding. Each thread updates your current understanding you detailed at the start of the work in the Capture step. The work compounds as you reflect back your learnings to fuel the next thread.

When an engineer works on a new feature, they work in a new branch. They have to reconcile the current state of the product with the new changes they’re introducing.

Questions emerge:

• What work am I going to add?
• What work am I going to reuse?
• What work am I going to update?

Integrating information is the same. There’s the state of what you currently understand, and the new information you’re assessing to find out how it fits in and what it changes.

Integrate generates a lot of artifacts. You have meeting notes, AI chats, emails, and anything that represents the change log of information.

When you work on a new branch of code, you create commits for each change. A commit is a named, isolated demarcation of changes, reasoning, and progress.

We do it in code, but not in understanding.

The Linear issue can serve as the context hub to write each commit. But that’s not the real work because meeting notes don’t matter unless you determine how they change your current understanding. It’s like the popular world of personal knowledge management where you capture and store everything you come across without leveraging it to inform your thinking, decisions, or actions. Stale information creates entropy in a system.

Integrate focuses on expansion, tension, friction. You go wide before you go deep.

Resolve

A branch of work in software becomes a Pull Request, which is an artifact that shows what changed, why it changed, and presents the historical log of work progress. Engineers (and AI) review the changes, propose comments, and work collaboratively with the author to resolve any issues. Once the work is approved, it’s merged into the main branch and becomes the new current state of the product.

Capture creates the initial context.

Integrate expands the understanding.

Resolve merges threads by resolving assumptions, answering questions, reducing uncertainty, and limiting scope to reflect a new expression of understanding.

This is the most critical part because it requires judgement and decisions.

It needs human and AI participation.

Humans provide judgement through diverse knowledge, experience, and perspective.

AI provides rapid analysis and synthesis through speed, intelligence, and knowledge.

Before AI, derisking technical work before the project required relying on engineering domain knowledge. You would review the proposed solution and they would map the code flow in their head.

• This functionality already exists.
• We’d have to add a new API endpoint.
• That part of the codebase is really messy.

Gaining 100% confidence requires writing the code, which you can’t afford to do at this point, so you rely on an engineer’s intuition and knowledge of the codebase.

AI changes that.

Claude can review the entire codebase and list every change down to the file and lines of code that need to change. In minutes.

Capture and Integrate help you resolve the tricky problems with design and strategy, but engineering is now a different equation. You can resolve issues with full fidelity because AI models are good enough to write the code. No matter what overhyped articles tell you about not needing engineers anymore, you do.

Someone has to maintain oversight, quality, and coherence when AI writes code. If you don’t, you create coherence drift and coherence debt. And it compounds.

Resolve ends with the current understanding reflected back into Linear. The issue will have words and sketches and an implementation plan attached, answering all the questions and unknowns you can at this point.

Then you’re ready to build.

Build

All the steps before set the stage to create working software in rapid iterations.

Build is where you take the context you created and start a new thread of work to deliver in tight iterations.

The new AI instance doesn’t need to investigate. It just has to write code according to the collaborative specification you created in the Linear issue. You provide the direction to instantiate the execution. And then you review it to maintain coherence.

When I spent most of my time shaping work before the build, I focused on the problem first. I explored wide in order to converge on a tightly focused problem. I incorporated technical perspectives to make sure there weren’t rabbit holes lurking in the shadows, waiting to ambush the team and force timelines (or scope) to slip. The result was a holistic understanding of what we’re trying to do and how we’re approaching it.

The point of planning is to prepare yourself to adapt, not to stick to a rigid plan. As Dwight D. Eisenhower said, “Plans are worthless but planning is everything.” The plan sets a direction like a way-finder. When things inevitably change, the depth of understanding built from planning helps you make decisions.

When the engineers hit roadblocks, my knowledge in the shaping process—namely, my understanding of the problem—made it easy to determine trade-offs and find new ways to solve the problem and stay on time.

But, given the right context, Claude can detail every change required in minutes. Engineering knowledge shifts upstream to setting direction and downstream to reviewing outputs and maintaining understanding.

Upstream participation maintains the structural integrity of the codebase.

Downstream participation maintains the structural coherence of the codebase.

Doing the work in every prior step supports this process by making sure AI writes the code in small iterations, allowing you to review and understand each output.

Small iterations reduce the surface area of changes, making it easier to reason about.

The work is released and coherence maintained because you, the human, were an active participant in the journey. You just shifted your focus from the pre-AI times.

Compound

Each time work is merged into the main branch, it expands what’s possible. New functionality is added so a customer can unlock new value; a bug is fixed so a feature that wasn’t working now works; old code is removed to reduce complexity and make room for something better; a function is refactored to improve performance.

Work, like understanding, compounds.

But compounding can go in both directions.

You can compound growth and you can compound decline.

Vibe-coded software compounds complexity and incoherence. Without a steward of quality and control, the AI does the most efficient thing and writes new code without considering how it all fits together. A principal engineer is always considering how the parts of the system integrate. You can do this with AI writing the code, but it requires directional intuition and quality control.

You feed understanding back, building future work from what came before. This is how all of human knowledge grows over time. If you update the Linear issue with the current understanding, and refine it through the process, you compound coherence.

But it only works if you’re there each step.

The Practice

To illustrate the practice of the Coherence Graph, I’m going to walk through a recent example where I used this process.

1. Capture

I think this is the problem.

Goal: Create

Input: Signal

A stakeholder created a Linear issue for creating a new usage dashboard for users. The issue wasn’t a specification. It represented our current understanding of the idea.

Output: Current Understanding

2. Integrate

We’ve explored multiple perspectives.

Goal: Explore

Input: Current Understanding

We began exploring the idea from multiple directions. They shared AI-generated mockups I used to sketch refined versions in an app I like called tldraw. We discussed the sketches on a call and iterated on them until they were ready. I updated the Linear issue with the screenshots of the sketches and a write-up describing the updated understanding. I pointed Claude at the issue to write an investigation prompt. I ran that in Claude Code to iterate on a plan.md file until the implementation was figured out.

Output: Expanded Understanding

3. Resolve

This is now our best shared understanding.

Goal: Decide

Input: Expanded Understanding

I updated the original Linear issue with the implementation plan. Realizing the scope of the work was larger than one issue, I had Linear AI convert the issue to a project, move the issue description to the project overview, and create one initial issue in the project to build the first prototype.

Output: Shared Understanding

4. Build

We’ve tested our understanding against reality.

Goal: Implement

Input: Shared Understanding

A fresh Claude Code session can now start from the Linear issue. It doesn’t need to rediscover any context. It scopes the focus of the session to purely building it in tight iterations so I can review each step. Work is reviewed with humans and AI in collaboration until the quality bar is met and coherence is maintained across the product, the team, and the system. Claude also provides useful insight into how to break down the work.

Output: Validated Understanding

5. Compound

The next iteration begins smarter than the last.

Goal: Learn

Input: Validated Understanding

The finished project becomes part of the Coherence Graph. The implementation, decisions, design rationale, and code now serve as context for future work.

Output: Improved Understanding

The Throughline

Between the 15th and 18th centuries, the Scientific Revolution emerged with a focus on observation, experimentation, and the mathematical description of nature.

Francis Bacon, an English statesman, lawyer, and philosopher, wrote Novum Organum, a 1620 treatise to lay out a new method for scientific inquiry and knowledge. Bacon, always a lover of analogies, shared a new one:

Those who have handled sciences have been either men of experiment or men of dogmas.

The men of experiment are like the ant; they only collect and use; the reasoners resemble spiders, who make cobwebs out of their own substance.

But the bee takes the middle course: it gathers its material from the flowers of the garden and of the field, but transforms and digests it by a power of its own.

The same analogy works today, applied to the new context in which we’re living.

Humans represent the ant, collecting and using what we find as we gain experience and skills through our professional journeys.

AI represents the spider, spinning complex and elaborate webs from internal mechanics we don’t wholly understand.

To thrive in the new world of hybrid intelligence, be like a bee. Leverage your unique skills, experience, and knowledge to combine it with the powerful technological power of AI to create something grander.

Don’t rely on purely one or the other.

Find the middle ground—the balance.

Create your Coherence Graph.

Move information through the system, create shared understanding, and persist coherence across all intelligence, human and AI.