Since publishing my series on synthesis engineering, I've received a recurring question: "How does synthesis coding differ from vibe coding?" I use both, sometimes with the same AI tool on the same day.
By vibe coding, I mean exploring through conversation: describe a result, run what the AI produces, and adjust it. By synthesis coding, I mean the hands-on practice of directing AI development through deliberate design, implementation, understanding and verification. Synthesis engineering is the broader discipline, including how teams organize that work.
The distinction becomes useful when a promising experiment starts doing something people depend on. A working screen can show that an idea is worth pursuing. Before it takes payments or changes a shared database, someone needs to understand and verify those operations.
What exploration gives you
When Andrej Karpathy described “fully giving in to the vibes” and forgetting the code exists, he articulated something that resonated with developers worldwide.
Andrej Karpathy's April 2025 account of building MenuGen captures the appeal. Cursor and Claude wrote the code for an app that turned a photographed menu into pictures of dishes. He also described the integration work around authentication, payments, deployment and changing APIs. The quick local prototype and the work of making it available to others belonged to the same project.
Conversational experimentation lets me try an idea before I know whether it deserves a larger investment. When I want to explore a new API, I'll describe the integration I'm imagining and see what emerges. When I'm learning a framework, AI-generated examples help me connect the documentation to code I can run and change. The questions become more specific once I have something in front of me.
In November 2025, I needed a script to reorganize files on my desktop. I described the goal, ran the result and adjusted it through conversation. It took minutes. I was interested in getting the organization I wanted; I didn't expect to maintain the script as a continuing project.
An organizer can overwrite an irreplaceable file even if its author is its only user. The amount of architectural planning a task needs and the care its actions require are separate decisions.
- Rapid prototyping lets you compare possible products or interactions before committing to an implementation.
- Tools for your own use can fit a need too particular for packaged software.
- Learning becomes more concrete when you can vary an example and see why its behavior changes.
- Experiments let you test a concept you may discard tomorrow, especially with synthetic data and replaceable resources.
- Nontechnical builders can make functional software for problems they understand well.
There is pleasure in describing an idea and being able to try it. A prototype can expose a better interaction, reveal a mistaken assumption or make a previously awkward task practical. Those are useful outcomes even when none of its code goes into a maintained system.
What maintained software asks of you
Synthesis coding grew from my experience with software that needs to be secured, extended by a team and operated for months or years. Architectural decisions have to survive multiple conversations. Another engineer has to understand why a module exists and how to change it. Someone must be able to investigate a failure, including a failure the original author never anticipated.
Framework changes: April–May 2026.
The framework now describes five principles. Its original 2025 form had four; transferable knowledge became the fifth in April 2026, and the fourth expanded from iterative context building to a self-improving system in May 2026.
Human architectural authority means I remain responsible for the technology choices, system boundaries, security model and integration decisions. AI can research options, compare tradeoffs and challenge a design. I decide which constraints the implementation must satisfy and which decisions need further review.
Systematic quality standards apply to the resulting software regardless of who typed it. Code review, tests, security analysis and performance checks need to address the behavior the system promises. AI can help create and run those checks; a passing test still needs to be a meaningful test.
Active system understanding means engineers can explain the code they accept and investigate it when it fails. If I can't trace a request through a module or explain how it handles an error, I need to resolve that gap before taking responsibility for the change.
A self-improving system retains useful context, skills, instructions and practices. Architectural decisions, established conventions and effective workflows give a later session something to work from. Improvement requires maintaining those records, loading the relevant material and checking the resulting work. Accumulating files alone does not do that.
Transferable knowledge makes the work understandable to people who weren't present when it was created. Documented decisions, shared conventions and readable code help another engineer continue the project, with or without the original AI tool.
When I modernized my 17-year-old WordPress plugin with Claude Code in November 2025, these responsibilities were concrete. Blogroll Links reads stored links, renders them on public pages and provides administrator settings. Queries, output escaping and permission checks all needed attention.
By late 2025, I was maintaining a plugin serving thousands of sites. Its public output and administrator settings carried responsibilities that my short-lived desktop experiment did not have.
The modernization targeted PHP 8 and followed WordPress conventions. Compatibility needed systematic verification across the versions the plugin supports. WordPress's plugin directory guidelines also require secure code and compatible licensing.
Choose by what the code can affect
The same context can support exploration or require a maintained implementation. Look at the data, available actions, downstream dependencies and recovery options before choosing how to work.
| Context | Useful starting approach | Consequence to inspect | Review before relying on it |
|---|---|---|---|
| Weekend experiment | Conversational exploration with replaceable resources | Does it use real credentials, publish anything or change valuable data? | Check those actions before enabling them; keep discarded experiments disconnected from ongoing work. |
| Production API | Synthesis coding | Which callers depend on its responses, permissions and failure behavior? | Verify contracts, authorization, error handling, operating limits and ownership. |
| Learning a new framework | Conversational examples you can run and vary | Is an example teaching a current pattern, and is it isolated from real services? | Compare it with the framework's documentation and test your explanation of its behavior. |
| Legacy system modernization | Synthesis coding | Which interfaces, stored data and integrations must the change account for? | Make the intended behavior explicit and test the affected paths and supported environments. |
| Automation for your own use | Exploration on disposable inputs; deliberate verification for consequential actions | Can it overwrite files, expose credentials or send data elsewhere? | Inspect planned changes and test collisions, failures and recovery before using valuable inputs. |
| Multi-repository platform | Synthesis coding | Does a producer's change still meet its consumers' expectations? | Review the cross-repository change and exercise the affected integration. |
| Prototype for a stakeholder demo | Conversational exploration with synthetic data | Can a demonstration trigger real messages, payments or state changes? | Separate the demonstration from live actions and identify what the prototype has not established. |
| Enterprise application | Synthesis coding | Who depends on its data, access controls and continued operation? | Verify the relevant security, operational and compliance requirements with the responsible people. |
To try this with a file organizer, put disposable copies in a test folder and ask the tool to list the moves it proposes. Include two files with the same destination name. You can inspect whether the plan matches your intent without giving the experiment access to the originals.
Before pointing an organizer at valuable files, inspect how it selects its input folder, handles an existing destination and responds to an interrupted operation. Verify a recovery procedure on the copies. If other people will use it, make its behavior and limits understandable to them.
Move along the spectrum
The two approaches describe regions on a spectrum. At the exploratory end, conversation and quick feedback guide the work, with limited design and review. At the maintained-system end, explicit architecture, technical workflows, documented decisions and systematic validation support continued use. Work across multiple repositories adds coordination between components that can change independently.
A weekend experiment may become something you want to maintain. A production project may include an exploratory branch where you compare interface ideas using synthetic data. The project label doesn't settle how to handle every task inside it.
I've seen teams make the transition from a promising prototype to maintained software through four steps:
- Keep the prototype as a reference for the original vision. Preserve the interaction or result that made it useful.
- Make explicit architectural decisions for the maintained version: its boundaries, data flow, security requirements and operating assumptions.
- Implement that version with deliberate review and verification. Retain prototype code where it meets the requirements; replace it where it doesn't.
- Validate that the resulting system still delivers the value the prototype demonstrated. A more orderly implementation that loses the useful interaction has missed the purpose of the work.
The transition deserves attention when the experiment acquires a real dependency: a user who expects it to work, a credential that permits consequential actions, an interface another system calls or data that must survive.
Keep the process proportional
An internal tool may handle payroll. A feature flag may hide an interface while a background job still writes to a database. A data-processing script that runs once may alter the only copy of a dataset. Internal audience, hidden features and short lifetime each tell you something about the work, but none establishes its consequences by itself.
There are also tasks where a lighter process is appropriate. A discarded interface mockup using fabricated records may need interaction review without a long-term operating plan. A calculation over replaceable local inputs may need a checked formula and output inspection without a service architecture. Make those choices from the actual task.
Questions that travel between approaches
- What am I trying to build?
- What does success look like?
- How do I communicate my intent to the AI effectively?
- How do I validate that what emerged matches what I need?
Exploration often answers them through conversational iteration and immediate feedback. Maintained software needs answers that another engineer can inspect: a decision, an interface contract, a test, an operating procedure. Skills in expressing intent, recognizing a weak result and refining an idea help in both settings.
If you mainly work through conversational prototypes, choose a project that people will depend on and make its requirements explicit. The framework develops the principles; the WordPress case shows why particular implementation details matter.
If your work already has extensive design and review, give yourself a place to explore. Try an unfamiliar API or compare several versions of an interaction with disposable inputs. Let a concrete result sharpen the next question before deciding whether the idea deserves a maintained implementation.
My bet is that teams fluent in both approaches will have an advantage. Conversational exploration makes an idea quick to try; engineering discipline gives a useful idea a path into software people can rely on. I want developers to become good at making that transition without losing the curiosity that started the work.
Terminology and reuse
I documented these practices because teams needed vocabulary for work they were already doing. Use synthesis engineering for the discipline and synthesis coding for the craft if that distinction helps you discuss, teach or organize the work.
I offer my terminology and the accompanying visual identity under CC0 1.0 Universal, to the extent of the rights I hold. You can use and adapt that material without asking my permission or providing attribution. Third-party material retains its own rights, and CC0 does not waive patent, trademark, privacy or publicity rights or imply endorsement.
This article is part of the synthesis engineering series, which explores rigorous human-AI collaboration in professional software development.
