Synthesis coding: a professional practice for AI-assisted development

I’ve had the same conversation with CTOs at least two dozen times over the past year. It usually starts with someone asking about our AI-assisted development practices, and within minutes we’re describing nearly identical approaches — systematic frameworks for integrating AI capabilities into professional software engineering. Different terminology, same patterns.

Last month, during a technical architecture review, I watched a senior engineer demonstrate what I’d been observing across organizations. They used AI to generate an initial implementation, performed systematic security analysis, refactored the architecture based on scaling requirements, generated comprehensive tests, and deployed with full monitoring instrumentation. When I asked what they called this approach, they shrugged: “Just how we work with AI now.”

I'm calling the discipline synthesis engineering: the systematic integration of human expertise with AI capabilities to build production-grade software systems. The hands-on craft of writing code within this discipline I call synthesis coding.

Terminology update prepared October 1, 2026: Synthesis work is now the umbrella for these practices. Synthesis engineering covers engineering work; synthesis coding names the software-development craft.

The practical question for an engineering leader is what must accompany generated code before other people can depend on it. A working demonstration leaves questions about security, operations, change, and ownership unanswered. Those questions determine the development process.

Direct the work and verify the result

My starting principle is that people remain accountable for the system they build. AI can propose architecture, investigate alternatives, implement code, detect errors, and review changes. The engineering team decides which commitments to make and what evidence will justify accepting the result.

Think of leading a team of superpowered beings. You draw on their different strengths, learn from what they know, delegate, and course-correct while remaining accountable.

WorkHuman responsibilityUseful AI contribution
Strategy and architectureDefine goals, constraints, and accepted tradeoffsResearch options, propose designs, challenge assumptions
ImplementationSpecify the behavior and boundariesWrite and revise code within those boundaries
VerificationSet acceptance criteria and judge the evidenceGenerate cases, run checks, inspect discrepancies
Error detectionDecide the consequences and required responseFind suspicious behavior and propose explanations
CorrectionApprove the remedy and its consequencesImplement the remedy and repeat the relevant checks

The same person need not perform every check manually. A test suite can enforce an invariant; a second agent can inspect an implementation; a reviewer can challenge both. Delegating work still requires deciding what would count as successful work.

Questions that improve the collaboration

Expose assumptions: “What assumptions are you making here?” “What could go wrong with this approach?” “Explain why you chose this pattern.”

Compare alternatives: “What are three different approaches to this problem?” “What’s the unconventional solution you’d hesitate to suggest?” “Show the tradeoffs in maintainability, speed, and simplicity.” “Which constraint rules out an option?”

Research related work: “How have others solved this problem?” “Are there patterns from adjacent domains that apply here?” Ask for sources and inspect them before relying on the answer.

Improve the context: “What information would change your recommendation?” “What am I not asking that I should be asking?”

These questions are useful when the answers affect a decision. Asking for alternatives after the requirements already determine the choice adds work without improving that choice.

A case study: building an agentic workflow system

I built a workflow automation platform with separate AI agents for research synthesis, quality validation, output formatting, and domain-specific processing. Humans supplied the domain judgment and remained the decision-makers. The agents performed defined parts of the work through a stateful workflow engine built on LangGraph.

A research synthesis agent processed source material; a quality validation agent checked the result against criteria; formatting agents prepared output for different distribution channels. The orchestration layer managed their dependencies. Independent tasks could run in parallel, while a task that needed another agent's output waited for it.

What made this system defensible was the orchestration logic, the quality standards, and the accumulated knowledge of which specialist patterns worked for which problem types. A competitor trying to reproduce it would need those capabilities as well as access to the models.

This became my laboratory for synthesis engineering principles. The architectural decisions I made, especially the ones I refused to delegate to AI, determined whether this system would work at all.

Where vibe coding is useful

When Andrej Karpathy described “fully giving in to the vibes” and forgetting the code exists, he articulated something real. For many use cases, this approach is optimal.

In his April 2025 MenuGen account, Andrej Karpathy described having Cursor and Claude write an app's code while he worked through API integrations, authentication, payments, and deployment.

I use vibe coding here for developing primarily by describing a desired result and trying the generated software, with little inspection of its internals. I use that approach regularly when testing an API integration or exploring a new library. A short experiment can answer whether an idea is worth pursuing before I invest in its architecture.

  • Rapid prototypes that help decide what to build.
  • Personal tools whose failures the sole user understands and can tolerate.
  • Learning through examples of an unfamiliar framework.
  • Non-technical builders exploring a problem through working software.
  • Disposable experiments where the intended result is knowledge rather than maintained code.

A personal script that handles sensitive information or performs irreversible actions needs appropriate safeguards even if nobody else uses it. A prototype that becomes a service inherits obligations to the people who depend on it.

Architectural authority remains human

Across engineering organizations I work with and in conversations with CTO peers, I’ve seen teams develop consistent practices for production software with AI. During one code review, an engineer had used AI extensively and produced exceptionally well-structured code. The engineer described planning the architecture first, having AI implement within those constraints, and then reviewing everything for security and performance. The team maintained its quality standards while dramatically accelerating implementation. Over the next few months, I heard variations of that account repeatedly.

One CTO described their approach: “We use AI to amplify implementation velocity within architectural guardrails we establish. The moment AI starts making architectural decisions, we’ve lost control of our system’s evolution.”

I take the responsibility point seriously. AI can contribute to an architectural decision, including proposing the design. The team still owns the choice, its rationale, and the consequences when requirements change. Human architectural authority makes those responsibilities explicit.

I saw the consequences of leaving that ownership unclear in a microservices project. Within two weeks, the team had five authentication patterns, three approaches to error handling, and no consistent logging strategy. The code worked, but nobody could maintain it. They spent the next month refactoring for consistency.

Writing down the authentication model, error conventions, and database access patterns gives engineers and agents a common reference. Reviews and executable checks then test whether the services follow those patterns, so multiple engineers can work coherently across the system.

The database decision

Early in the workflow project, someone suggested starting with SQLite and migrating to PostgreSQL for production. I pushed back. Hard. PostgreSQL was our intended production database, and I wanted development to exercise that choice from the beginning.

SQLite could have handled the initial work. It supports many simultaneous readers but one writer at a time per database file; that can be entirely appropriate for an application. SQLite's own guidance explains when embedded storage works well and when many concurrent writers favor a client/server database.

A change of database can affect locking behavior, retry handling, migrations, and the code used to obtain connections. Generating more implementation around an interim choice creates more code to inspect when that choice changes. The relevant question was whether the initial convenience justified that second round of integration work.

We used Docker Compose, PostgreSQL, and asyncpg, with a pool size of 20 and an overflow allowance of 10. Those settings permit up to 30 connections to be checked out from that pool; actual throughput depends on the workload. Multiple process-local pools add to the application’s total connection demand. SQLAlchemy’s asynchronous adapted pool uses the same size and overflow semantics. SQLAlchemy documents these settings.

The setup cost an extra afternoon. My estimate was that the refactoring we avoided would have consumed a week. It let us exercise the chosen database throughout development. When AI accelerates implementation, an early architectural decision spreads through the code faster. Getting that decision right saves work throughout the project.

Preserve project knowledge beyond a conversation

In early versions of the workflow system, I started a fresh conversation for each feature. I repeatedly explained the architecture, existing code structure, and conventions. Then I tried continuing a conversation through v0.4, v0.5, v0.6, and v0.7. By v0.8, the conversation contained our database models, API conventions, testing approach, and error-handling strategy. Implementation velocity increased dramatically. The richer context gave AI more of the project’s conventions to work from.

A long conversation is one way to retain context during work. Durable project records also make that context available to a new session and to another engineer. Architecture decision records explain what was chosen and why. Maintained examples show the expected implementation. Tests preserve requirements in an executable form.

Documentation update prepared October 1, 2026: Current tools can carry information across sessions. Claude Code supports project instructions and automatic memory files. These supply context to the model; executable hooks can enforce action constraints. Teams need to know which records are loaded and keep them accurate. Claude Code memory documentation.

For a new feature, useful context includes the relevant decision, the affected interface, a representative implementation, and the tests that define acceptable behavior. Accumulating every old conversation can bury those facts. Keeping them current is engineering work.

Make quality a repeatable practice

The workflow system used a sequence of quality checks:

  1. Implementation: generate initial code using the architectural patterns.
  2. Security review: examine it against OWASP Top 10 categories and relevant vulnerabilities.
  3. Performance analysis: identify likely bottlenecks and questions that require measurement.
  4. Test generation: cover expected behavior, edge cases, and error conditions.
  5. Human code review: examine architecture, logic, and cases the preceding checks might have missed.

AI assisted with these steps, giving us repeated opportunities to find problems before production. Each stage needs to test a different aspect of the implementation. An AI-generated test can repeat the code’s mistaken assumption; a security review can miss an asset or trust boundary that nobody supplied.

The engineering team therefore needs explicit acceptance criteria: what behavior is required, which failures must be handled, what performance is adequate, and who will inspect the evidence. The quality standards article develops that process.

Build a workflow that improves with use

The workflow used LangGraph to coordinate stateful tasks. Several capabilities were useful:

  • Cycles: a validator could return an output to its producer with feedback.
  • Conditional branches: intermediate results could determine which specialist ran next.
  • Shared state: stages could receive information produced earlier in the workflow.
  • Recorded execution: inputs, decisions, outputs, and check results could be retained for investigation.

The workflow recorded which inputs tended to fail validation and which combinations of agents passed on the first attempt. That performance information informed routing changes and architectural refinement.

In LangGraph’s evaluator-optimizer pattern, feedback becomes context for another generation step. That can improve an output within a run. Improving the underlying model or the workflow itself requires a separate training or design process. The refinement loop makes this a cyclic graph.

For a self-managed graph, LangGraph checkpoints retain thread state, while stores hold information shared across threads. Configure persistent storage for information that must survive a restart; the in-memory implementations keep it only for the life of the process.

To improve the workflow over time, collect failures, identify a change and evaluate it. Engineers can revise a prompt, validation rule or routing decision from that evidence. An automated controller can also make bounded changes using decision rules and verification we design.

How improvement becomes an advantage

Learn from accumulated cases. More use produces cases to learn from, including failures that become regression tests. Compare a changed workflow with its predecessor on difficult cases, keeping some separate from development. This is how a team builds an advantage over competitors who can copy its current features but lack its accumulated learning.

Apply domain expertise. Record what a good result means in the relevant domain: required evidence, prohibited inferences, acceptable formats, and costly failure modes. Incorporate the expert judgment your team has developed over years.

Test transfer to adjacent tasks. Test whether patterns identified in one task transfer to adjacent tasks before investing in additional training. Evaluate the second task against its own quality threshold and baseline. In the 2024 ExpeL study, researchers transferred lessons from question answering to fact verification. With target-task examples used to adapt those lessons, the agent achieved a mean success rate of 70%, compared with 63% for the ReAct baseline: a 7-percentage-point gain. Both used GPT-3.5-Turbo for task execution; GPT-4 adapted the instructions without updating model weights. That result supports testing transfer in your own workflow, with the task and comparison clearly defined.

Measure cost per accepted result. As quality improved in our workflow system, average tokens per high-quality output decreased 23%. For an inspectable comparison, define the quality threshold, count rejected attempts and retries, record model and prompt versions, and divide total usage by the number of outputs that meet the threshold. Also track latency and human review effort; token savings alone can conceal a more expensive process.

An organization’s domain knowledge becomes more useful when it is captured in working evaluations, routing decisions, and reusable patterns. A team that keeps improving these practices is building an advantage that access to the same model cannot supply. I want organizations to build that capability, with engineers directing improvement and AI carrying out the work at scale.

Make the work maintainable by a team

One engineering manager told me: "With pure vibe coding, only the engineer who generated the code could maintain it. With synthesis coding, the whole team understands the architecture because we made those decisions collectively."

The broader lesson I draw is to make understanding transferable. Another engineer should be able to trace a request through the system, explain the relevant design decision, reproduce the tests, and investigate a failure. Written reasoning and working verification make that shared understanding useful to the next engineer.

Security review processes, testing standards, and performance requirements can then survive changes of personnel or AI tool. Systematic practices enable faster innovation: engineers who understand the architecture and can rely on their quality processes can make changes confidently.

I’m seeing organizations experiment with AI-assisted architectural analysis during design reviews, AI-generated test suites that exceed human-written coverage, security audits integrated into deployment pipelines, performance optimization within human-defined constraints, and documentation that stays current as code evolves.

To apply this practice, choose one consequential change. Record the decision the team owns, supply the agent with the relevant context, define the evidence needed to accept the implementation, and ask another engineer to explain the result. That exercise will reveal more about the development process than the volume of code generated.

This practice needs shared frameworks, methods for different contexts, organizational implementation patterns, ways to educate teams, and tools designed for systematic human-AI collaboration. I want practitioners to develop those together.

On terminology and usage

I offer my contributions to the synthesis engineering and synthesis coding terminology, and the accompanying visual identity, under CC0 1.0 Universal. Use, adapt, and build upon those contributions without asking permission or providing attribution. This dedication does not grant rights in material owned by others.

Use the vocabulary if it helps you hire, train, or organize your engineering teams. Bring back the patterns that work and the problems the framework still needs to solve.


This article is part of the synthesis engineering series, exploring rigorous human-AI collaboration through professional software development.

Originally published at rajiv.com.