The synthesis thinking framework: a practitioner's guide

This is Part 2 of a two-part series. For the executive overview, see Your AI Is a Thinking Partner. You're Using It as a Search Engine..

I developed this framework while managing sixty-plus concurrent projects through sustained human-AI collaboration: engineering teams, products and work across software architecture, organizational design, product strategy and content operations. Each project carried its own context, state and active decisions. A team working with AI agents could direct a distributed engineering effort, but it needed a shared way to reason through the work.

The synthesis thinking framework supplies that methodology. Its five modes help me examine an architecture decision, trace an integration risk and design a daily practice that can sustain work across many projects. They are part of how I lead the work.

I gave an AI agent a design document for a feature with two independent dimensions. Users needed to select both simultaneously, and every combination was valid. The agent found a similar-looking sequential workflow in the codebase and built another one.

The result compiled. Tests passed. It still failed the design requirement. The implementation had inherited a sequence from existing code without establishing that the sequence belonged in the new feature.

The failure I worry about most in AI-assisted engineering is solving the wrong problem competently. An implementation can be internally consistent and still embody the wrong relationship between the parts. The five modes give me ways to challenge that design, follow its consequences and turn a better understanding into something people can use.

1. First principles: check the requirement before copying the pattern

For the two-dimension feature, the useful question was what relationship the choices had. Could one choice restrict the other? Did the user need to see both at once? Was the sequence a domain requirement or a property of the old interface?

Consider an illustrative export screen with two settings:

FormatDetailValid?
CSVSummaryYes
CSVFullYes
JSONSummaryYes
JSONFullYes

The requirement is that changing format preserves the selected detail level, and changing detail preserves format. If users also need to inspect and change both settings at once, the interface must support that. Independence alone does not dictate a particular layout; a sequential interface could preserve all four combinations while still failing the simultaneous-selection requirement.

That distinction gives the reviewer something testable. Start at CSV/Full, switch to JSON, and check that Full remains selected. Then change detail and check that JSON remains selected. Test the reverse transitions too. A test that merely confirms the second screen opens would miss the actual requirement.

The same reasoning helped with a CSS problem. An agent was stacking negative margins, calc expressions and fixed pixel values onto a hero section. The hero sat inside a container whose width constraint existed for article readability. Removing that inherited constraint solved the layout problem with one line. The useful review question was what the container was for, before adjusting more of its properties.

Before approving a proposed design, ask the assistant to list its assumptions and connect each to a requirement, an observed constraint or a deliberate choice. An inherited implementation deserves inspection at that boundary. It may contain a constraint worth keeping; resemblance to the new task does not establish that.

2. Systems thinking: trace what loads, changes and depends on the record

For months, I used one context file per project. Current tasks, stable reference material, old session history and completed checklists accumulated together. The largest file crossed a thousand lines. Eighteen projects had files over 500 lines. Median: 178 and growing. The records were individually useful, yet the work I needed the AI to focus on today was buried among information with a very different lifetime.

Current tasks change quickly; team facts and architecture decisions change more slowly; historical records need to remain recoverable. Loading them all at the start of every session makes these different lifecycles compete for a finite input budget. The system-level problem was the loading policy and organization of the records, not the value of the history. I needed to decide what should be loaded first, what should be retrieved when needed, and how to preserve the path back to it.

A separate comparison of the March 4, 2026 Git snapshots shows the following changes in tracked projects/<project>/CONTEXT.md files:

March 4, 2026 snapshotProject context filesMedian linesLargest fileFiles over 500 lines
Before the recorded migration58183.51,0147
After the recorded migration6269.51280

The snapshots contain different numbers of projects. These counts describe the tracked project context files and their organization; they are not a model-performance benchmark.

The resulting architecture gives each kind of information a place:

  • CONTEXT.md holds current status, active decisions, blockers and pointers.
  • REFERENCE.md holds stable facts and decisions, including the reasons and sources needed to use them correctly.
  • Dated session records preserve what changed, what was checked and what remained unresolved.

Make the separation operational. Load active work first, keep stable decisions and their reasons available through clear pointers, and retrieve historical records when the current task needs them. When a record moves, verify that the next session can still find it. A shorter active file that has lost an essential pointer is a recovery failure.

My dependency check therefore includes the reader of the record, the process that updates it, and any summary derived from it. After moving a completed investigation into history, can a new session still find the decision and its reason? After changing a current reference, does the history record the change rather than silently inheriting the new account? The tiered context article works through that migration and recovery check.

3. Complexity thinking: verify against the state that now exists

I regularly integrated contributions from multiple engineers, often touching overlapping files and built against different versions of the same codebase. Each integration changed the state the next one would meet. A contribution that worked against its original base could fail after another contribution changed a shared assumption. Pairwise reviews did not establish the behavior of the accumulated system.

File overlap, dependency changes and migration order often yield to direct analysis. Other uncertainty comes from changing requirements, interacting features and people adapting their work to what has just been integrated. Those call for feedback from the evolving system as well as analysis of individual changes.

Dave Snowden's account of Cynefin distinguishes expert analysis in the complicated domain from safe-to-fail probes in the complex domain, where cause and effect are understood retrospectively. I use that distinction to choose a response: analyze a known dependency, and use a bounded experiment when the outcome depends on interactions I cannot reliably settle in advance.

My practical approach was dependency-aware ordering followed by verification against each new cumulative state. Inspect the affected files, identify shared contracts, sequence changes to reduce cascading conflicts, and verify that behavior already accepted still works. Invest in detecting surprises while they are easy to diagnose and repair.

An illustrative export change shows why the earlier checks matter. Suppose a CSV exporter already promises a header and correct quoting. A new contribution adds JSON output:

Behavior that must surviveCheck
CSV includes id,name as its headerParse the first row and compare the field names
A name containing a comma stays one fieldParse the CSV and compare the recovered record
JSON contains the same record valuesParse the JSON and compare the resulting objects

A candidate implementation can pass the new JSON test while dropping the CSV header. Keeping the old CSV assertions exposes the regression. The downloadable example checks both a correct implementation and that deliberately faulty candidate: the JSON check passes for both, and the preservation check rejects the candidate without a header.

Download the thinking-check examples to run the independent-selection and export-preservation checks with Python. The archive includes the code and a README with the command, expected results and the limits of these synthetic examples.

I encountered this problem during integration: earlier functionality disappeared while the checks I ran remained green. That experience made preservation of prior work an explicit part of my integration procedure. When investigating such a regression, inspect the actual integration diff and any conflict resolution. Git cherry-pick applies the changes introduced by selected commits; a commit's age alone does not tell you which behavior the integration will remove.

Name the behavior that must remain and test for it. Tests can detect a missing feature when they assert that feature. A suite that never checks it cannot establish its preservation. Define success and failure before a rollout, then use incremental integration and fast feedback to make course corrections while they are still inexpensive. The synthesis merging and multi-contributor workflow articles develop the procedure further.

4. Analogical thinking: transfer the relationship, then test the mismatch

Analogical thinking is where I find some of the most surprising solutions. The context-management design came from recognizing a structural parallel with a cache hierarchy: active tasks were hot information, stable reference material was warm, and session history was cold. Different access patterns called for different retrieval paths and rules for movement between tiers.

I had not set out to apply processor design to project records. The parallel became useful because it explained the contention I was seeing and suggested an architecture I could operate. I had been using the architecture for months, and the growth problem had not returned.

Test the relationships in the analogy against the system you are building:

Relationship in the analogyWhat it suggests for project contextWhere the analogy stops
Frequently accessed data gets a faster pathLoad active work firstA text file has no inherent guarantee of model attention
Other data can be retrieved when neededKeep explicit reference and history pointersThe assistant still has to choose and read the right source
Movement between levels follows a policyDefine when tasks and decisions move into historyEditing documents is not automatic hardware cache management

Those differences become design checks: verify the retrieval pointer, check that the active decision is current, and preserve the reason a later reader will need. The analogy earns its place by helping solve the actual problem and exposing where the design could fail.

Database engineering supplied a second useful habit: specify the relationships an operation must preserve, then check them. A foreign-key constraint, for example, checks that referencing values correspond to values in another table under the constraint's rules. It does not preserve every effect of every earlier transaction.

For integration, the relationship to preserve is the behavior already accepted. In the export example, adding JSON must leave the CSV contract intact. The CSV assertions enforce that requirement directly. The useful transfer from databases is the discipline of explicit invariants, with each domain checking the relationship it actually needs.

Specialists go deep. Generalists go wide. Synthesists go diagonal: they find structural parallels across disciplines and import solutions a domain-bound approach misses. An engineer who reads cognitive science, operations research and labor history alongside systems design has more patterns to draw on. Breadth expands the possibilities; a tested structural match turns a possibility into a useful design.

When you are stuck, describe the problem without its domain labels: "Sequential operations where each must preserve the integrity of previous work." Ask where that relationship appears elsewhere. Write down the source relationship, its proposed counterpart and one important difference. Then design a check around the difference.

5. Design thinking: build the operating system for the work

The context architecture left a human design problem: what would my day actually look like across sixty projects? Every day, a gap opens between what happened in conversations, pull requests and running systems and what I know. An unanswered thread can block an engineer; an unresolved dependency can become a missed deadline and a trust problem. I designed my operating routine to close that information gap before it compounds.

My daily routine puts the dependencies in order, so each stage supplies what the next one needs.

Maintain the project records. Move completed work and useful session history out of active context. Put stable facts and decisions in reference. Copy the retained material, verify it at the destination, and only then remove it from the active file. Coordinate the move with other writers so neither file changes underneath it. I use a 150-line active-context budget to force decisions about what belongs close to the work; the loading and retrieval behavior still needs to be checked.

Refresh the relevant sources. Fetch the active repositories, inspect the pull-request queue, and synchronize the tracked conversation records. Read the full relevant threads: a reply may have resolved the issue raised in the first message. Keep source locators and retrieval times so the next review can find both the evidence and subsequent replies.

Reconcile potential action items. Yesterday's open task may have been resolved in a thread, superseded by a decision or completed in a merged change. Check the live system that establishes the status, using notes to locate it. A transcript can establish what someone said; code and execution evidence establish different things.

Build a usable action plan. I use prioritized tasks, draft messages with thread locators, a waiting-on-others table and a running “things to know” section. Update the plan throughout the day as work completes, new information arrives and priorities change. Keep planned actions distinct from completed ones, and record the actual result, time and evidence for completed work. The plan then becomes a usable history of what happened as well as a guide to what comes next.

Prepare communications from the reconciled state. A reply should account for a resolution already present in the thread. A technical update should reflect the implementation and checks that support it. Whether the assistant may send that message is an authorization question, separate from whether the draft is ready.

An illustrative deployment decision makes the boundary concrete:

RecordWhat it establishes
Build and staging checks passed, with retained resultsEvidence about the tested candidate
Prepared deployment instructions identify that candidateA specific action is ready for review
No production authorization has been grantedThe assistant must leave production unchanged

An agent once completed deployment prerequisites and then deployed without asking me, treating readiness as authorization. That experience changed the interaction I wanted: prepare the consequential action so I can judge it, and execute only within the authority actually granted. Routine record maintenance can proceed under standing authorization. Production changes, external messages and other consequential actions need their own clear boundary.

The routine also feeds a lessons archive. Capture a reusable pattern while its context, failure and correction are still available; those details become harder to reconstruct later. Test the lesson against another case and refine it when the new case differs. The synthesis thinking framework itself grew from this pipeline: patterns noticed across projects, extracted, tested against new problems and eventually encoded as methodology.

Design thinking makes the architecture usable in a practitioner's day. The routines, records and authority boundaries let the human retain judgment where it matters while AI supplies the throughput that makes many simultaneous projects manageable.

Make the framework part of the work

The five modes build on one another: establish what is true, trace its relationships, identify uncertainty, borrow a useful structure and design for the people doing the work. Match the depth to the decision. A constrained CSS fix may need only first principles and systems thinking; a change crossing product behavior, integration and deployment can need all five.

For that larger review, I ask the assistant to produce a short decision record:

  1. Requirement: the user outcome, the assumptions carried over from existing code, and a counterexample that would invalidate the proposal.
  2. Dependencies: the components and records affected, including how a future session finds the reason for the decision.
  3. Uncertainty: what analysis can settle, what needs an experiment, and which earlier behaviors must survive.
  4. Analogy: the relationship borrowed from another domain and the point where it stops matching.
  5. Human decision: the evidence to review, the choice being requested, and the action the assistant is authorized to take.

Use the record to expose unresolved assumptions, make the decision and carry its reasons into the next stage of work. Another engineer should be able to understand both the chosen approach and the evidence that would cause you to change it.

Using the framework as a skill

September 2026 update: The skill-selection guidance in this section reflects current documentation.

The synthesis thinking skill is available as an Agent Skill; its published skill metadata declares CC0. The Agent Skills specification describes a format for instructions and resources, with metadata available for discovery and full instructions loaded when a skill is activated.

The framework is designed as reasoning infrastructure for non-trivial work. Configure your agent's standing instructions to call for it at the decisions where you need that discipline, and calibrate the depth to the problem. Current OpenAI skill documentation and Claude Code documentation describe explicit invocation and task-based selection, with controls over implicit use. Installing a skill makes its instructions available; the client's loading rules and your workflow determine when they are brought into the task.

Check selection and work quality separately. Use an explicit invocation on a known engineering case. If the product exposes evidence of the selected skill, retain it; if selection evidence is unavailable, record it as unknown. Then grade the result against the case: did it preserve all four settings combinations, trace the relevant dependency, or retain the CSV behavior? A response that names five modes without doing those things has not met the task.

For setup, see installing synthesis skills. The collection applies the methodology to code review, context management and multi-contributor integration. The framework is the foundational methodology behind synthesis engineering. The executive overview discusses the broader thinking practice, and AI-native project management describes the records that support it across sessions.