Synthesis Engineering: Organizing Complex Work with AI

Synthesis engineering is the professional discipline of human-AI collaboration on complex work. It combines human expertise with AI capabilities through defined principles, documented practices, lessons from real projects, and a framework for extending those practices to new domains.

The goal is to build a substantial, evolving body of work. Better prompts help with individual tasks; a discipline also determines how work is organized, how quality is judged, and what the next project learns from this one.

  • Synthesis coding applies it to building software: deciding what a change should do, implementing it, reviewing it and checking its behavior.
  • Synthesis project management applies it to organizing work: keeping decisions, responsibilities, current state and supporting evidence recoverable as people or AI sessions take over.

Documented practices and lessons make these methods useful beyond an individual conversation. A failed handoff, missed test or conflicting edit should change how the next task is organized. Those lessons, and the reasons behind them, are part of the discipline.

Design around AI capabilities

Human workflows use folder hierarchies for navigation, meetings for synchronization, periodic reviews as reminders, and linear documents for sequential reading. AI gives us other useful capabilities: full-text search, synthesis across documents, and repeated execution of documented procedures. Designing around those capabilities changes how we organize the work; human judgment, shared state and checks still have jobs to do.

In synthesis coding, the useful analogy is an engineering lead coordinating several “10x engineers,” with contributions spanning product, design, implementation, security review and documentation. The leadership work remains familiar: clear direction, quality standards, trust and verification.

For synthesis project management, the innovations are a living CONTEXT.md snapshot, semantic tags and relationships, proactive searches of lessons, and daily records that roll up into weekly and monthly insights. In my use, context recovery that took more than 15 minutes came down to seconds, and lessons surfaced when they were useful instead of staying forgotten in folders.

Human roleAI role
Sets direction and goalsExecutes with speed and consistency
Reviews and approves outputGenerates drafts and options
Makes judgment callsSurfaces trade-offs and alternatives
Encodes lessons learnedApplies lessons proactively
Designs the systemMaintains the system

The human remains responsible for the work. The chemistry analogy in synthesis is intentional: a synthesized compound has properties neither input possesses alone. Human-AI synthesis produces work that neither human expertise nor AI capability could achieve independently.

Put the discipline to work

Consider an illustrative change: a reporting application needs a cancel button for reports that are still being generated. An AI assistant can help inspect the code, propose an implementation, add tests and revise the interface. The work also needs an answer to a product question: what should happen if the report finishes just as the user cancels it?

An agent is an assistant that can take successive actions using its available tools and permissions. The method applies whether an agent does one part of this change or carries a task through several stages.

Give the assignment a result the team can check

For the reporting example, suppose the team chooses these rules: a completed report remains available; cancellation is confirmed only after the server accepts it; and an automatic retry must not restart a canceled job.

That is enough to make the assignment more precise than “add cancellation.” The interface needs to distinguish a request to cancel from a confirmed cancellation. The process generating the report needs to recognize that request. The retry mechanism needs to respect the final state. Tests need to cover cancellation while work is running and cancellation arriving near completion.

An assistant can inspect where those responsibilities currently live and recommend how to change them. It can also identify a conflict in the requirements. The person responsible for the product needs to settle a consequential choice, such as whether a finished report should remain accessible. Routine implementation decisions can be delegated within that choice and the project's constraints.

A usable task record might read:

Add cancellation for report jobs that are queued or running. Keep completed reports available. Confirm cancellation only after the server accepts it, and prevent retries from restarting canceled work. Show how the interface, server and retry behavior satisfy those rules. Identify any requirement the existing design cannot meet.

This gives the assistant room to solve the implementation while making the result reviewable.

Keep the evidence attached to the change

A completion message should point to evidence for the requested behavior. In this example, that means the relevant code changes and test results, including the cases near completion and during a retry.

The tests themselves need review. A test that changes a status label without exercising the job's cancellation behavior would leave the central requirement untested. A check that starts with an already canceled job could miss the transition from running to canceled. The reviewer needs to follow the requirement through the implementation far enough to see what was exercised.

AI can perform parts of this review, suggest missing cases and run checks. Assigning those tasks does not make the resulting evidence conclusive. Someone accepting the change still has to decide whether the checks address the requirement and whether the remaining uncertainty matters for release.

Parallel work adds a coordination requirement. If one agent edits the interface and another edits the job processor, they need the same agreement about states and responses. Assign clear work areas and an owner for integration.

Update — documentation checked October 1, 2026: OpenAI’s guidance on long-running work also calls for explicit completion criteria and separate work areas for parallel chats.

Leave a record that the next session can recover

The project record should preserve the cancellation rules, the reason for keeping completed reports, the implementation's current state and the checks that passed or remain open. Link to the actual change and test output. A summary can make that record easier to enter; it should retain a route back to the supporting material.

Then test the handoff. Give a fresh session the project's entry instructions and ask it to locate the cancellation decision and explain the unfinished work. Check its answer against the record. If it cannot find the decision, inspect how the session discovers and reads project files. If it finds the record but misstates it, inspect the wording and the assistant's interpretation.

This check is useful even when the earlier conversation still fits in a tool’s context. The 2023 Lost in the Middle study found that performance on its question-answering and retrieval tasks depended on where relevant information appeared. A large context window alone does not assure reliable recall.

The same discipline applies to a human colleague taking over the change. They need to know why the cancellation behavior was chosen, which parts work and where the evidence lives. A project-memory layout can help organize those records; the useful test is whether the next contributor can recover the decision.

For a contained edit completed in one sitting, a clear request and a reviewed diff may be sufficient. The record becomes more valuable when work crosses sessions, people or agents, or when the next change depends on why an earlier choice was made. Start with one such decision in the work already underway. Record its source, the chosen behavior and how it will be checked, then ask the next session to recover it.

A discipline that grows through practice

Prompt engineering belongs within this work, alongside organizational practices, quality frameworks and lesson capture. A spelling checker is useful AI assistance; synthesis asks AI to contribute substantively to the creative or technical work. Human responsibility for direction and acceptance remains essential even when agents work autonomously between reviews.

The body of knowledge should cover failed context recovery, security patterns, mistakes and how we catch them, and organizational practices that let teams expand this approach. Each project can improve the next one.

Developers can begin with synthesis coding. Project managers and leaders can use synthesis project management to improve how they track work and preserve knowledge. Organizations can apply the same pattern to writing, research, design and analysis.

Coding and project management are the first two documented crafts. The opportunity extends to synthesis architecture for network, security, cloud and application design; synthesis research for investigation and analysis; synthesis writing for content creation; and synthesis design for creative work. People already do this work. Documenting its principles, practices and lessons can turn individual experiments into transferable crafts.

As AI capabilities evolve, new crafts will emerge. Design for those capabilities while keeping human judgment at the center of the work.

Synthesis engineering is an open methodology. Its terminology and concepts are released to the public domain under CC0.