When Someone Else Contributes to Your Synthesis-Coded Project

I built a production system through months of synthesis coding: sustained, context-rich collaboration with Claude Code. The codebase had deep architectural consistency because one person held all the context. Then a colleague started contributing features on branches.

Their code was good. The features were real. But when I looked at the PRs, I realized I couldn't just merge them. The codebase had moved. Patterns had evolved. Security safeguards had been added. Conventions existed that weren't written down anywhere because I'd been the only one writing code. An unchecked merge would have regressed things I'd spent weeks getting right.

This is the multi-contributor problem in synthesis coding, and I've written a runbook (now available as the synthesis-code-integration Agent Skill) for how to solve it.

What a contribution must catch up with

In synthesis coding, the lead developer, or “lead synthesist,” builds and evolves the system through continuous AI collaboration. Three properties of that work matter when someone else contributes:

Deep architectural consistency. Decisions compound across sessions. The lead carries the reasons for the design into the AI collaboration, and that context shapes the next change. Over time, components follow a coherent approach.

Implicit conventions. Naming patterns, error handling, security practices and the way components compose may have emerged through the work before anyone wrote them into a guide. A new contributor needs access to those standards.

Rapid evolution. A branch that's a week old may be dozens of commits behind. While the contributor builds a feature, the lead may introduce patterns, add security layers, refactor subsystems or raise the quality bar. The contribution reflects the snapshot from which it started.

A blind merge can undo improvements, introduce conflicting patterns or omit safeguards added after the contributor branched. A pull request and its review can address those risks. The review must compare the contribution with the current system, including conventions that the tests may not yet capture.

Adopt-and-adapt: the integration pattern

Adopt-and-adapt separates two responsibilities:

  1. Adopt the intent, the design, and the valuable implementation work.
  2. Adapt the code to meet current standards, architecture, and quality bar.

The contributor's work is the foundation. Preserve their design thinking, feature concept and useful implementation while bringing the result up to the project's production standard. The amount of adaptation depends on what the review finds.

For a contribution that needs substantial adaptation, create a fresh branch off current main. Selectively bring in changes file by file, function by function. Fix the identified issues during integration. Test the integrated result, then merge it into canonical main.

This is the intensive form of the method I used for the first contributions. It gives the lead a way to reconcile valuable work with an architecture that has moved since the contributor branched.

Roles matter

Lead synthesist

The lead holds the architectural vision, maintains the quality bar and has the deepest context on the system. In the project I describe, this was the person who built it through sustained AI collaboration.

The lead defines and evolves project standards, reviews all external contributions, chooses the required adaptation and controls production deployments. That authority includes the duty to document standards as they emerge through integration.

The lead synthesist's standards are the project's standards. Making them explicit lets contributors apply them without having to infer every decision from the lead's code.

Contributors

Contributors build features on branches or forks. They may or may not use synthesis coding themselves.

Their goal is to make integration easy. Read the contributor guide before building, sync to the latest main, and submit complete features with both frontend and backend work and tests. Keep one feature per branch. The closer the contribution is to the project's standards, the less adaptation it needs.

The full integration process

When the lead receives a contribution:

Assess. Fetch the branch and review the diff. Identify what the contribution does, what it changes and what assumptions it makes. Check how far main has moved and whether the change touches sensitive areas such as authentication, security, the data model or user-facing text. Choose the integration intensity from those findings.

Review. Evaluate the contribution against the quality gates. Begin written feedback with what is strong; earned recognition helps contributors see what to keep doing. Identify what must change, including security issues, broken functionality and standards violations. Separately explain what should improve, such as code quality or architectural choices, so the contributor knows the difference between requirements and suggestions.

Integrate. For substantial adaptation, use a fresh branch off current main and selectively bring in changes. Fix the issues and test the integrated result before accepting it into main. A contribution that already meets the standards needs less intervention. Sync mirrors and forks after the merge so contributors have the latest code.

Communicate. Share the review with the contributor. Explain what changed and why, and update the contributor guide with lessons that should prevent recurrence. Each integration should transfer more of the lead's context to the team.

Quality gates

Every contribution must pass four gates before acceptance into main. An integration branch provides a place to make and test the required changes.

Completeness. The feature is fully implemented across frontend and backend. There is no dead code, no reference to a method that does not exist, and no dependency on unreleased work. New backend logic has tests.

Security. Privileged operations produce audit log entries. Authentication tokens are handled correctly, sensitive endpoints have rate limiting, credentials are not hardcoded, and inputs are validated at system boundaries.

Architecture. The contribution contains one feature, follows the codebase's patterns and uses framework features properly. It must preserve existing functionality.

Project-specific standards. Brand compliance, UI terminology, deployment safety, database migration approach and performance expectations belong in the contributor guide. When an undocumented standard causes a mismatch, the lead is responsible for making it explicit. Contributors cannot be expected to guess it.

Lessons from the first integration

A blind merge puts the current system at risk. Even passing CI can miss conflicting patterns, security requirements or quality regressions. Every external contribution needs review against the current standards; the amount of adaptation follows from that review.

Bundled features create unnecessary pain. Multiple unrelated features in one branch make review harder, create conflicts and can prevent accepting feature A without also accepting unfinished feature B. Enforce one feature per branch as a contribution requirement.

Orphaned half-features confuse the next developer. Frontend code that calls nonexistent backend endpoints suggests a capability the system does not have. Require both sides of the feature, tested together.

Integration is when standards get documented. Reviewing another person's work exposes decisions the lead has been carrying implicitly. Each integration review should make the contributor guide more useful. The guide grows with the team's experience, and the precedent set in review shapes its culture.

Production deployment needs its own approval gate. Automatically deploying every push to main removes the lead's decision about when the work reaches users. Production deploys always require explicit human approval.

The runbook

I've published the full methodology as an open-source runbook, now an Agent Skill: Multi-contributor Synthesis Coding

It covers everything in this article plus the detailed contribution workflow before building, while building and when submitting; communication principles for productive review; and guidance for new projects. It is licensed under CC0 1.0 and is part of the synthesis-skills open-source project.

If you're synthesis coding solo and expect to involve contributors, read it before the first PR arrives. The precedent you set with the first contribution defines the culture.

March 2026 update: After twelve PRs from six engineers and multiple integration rounds, I wrote Synthesis merging: what happens after the first PR. It describes how the process evolved from full rework through lighter integration to zero-adjustment merges as contributors learned the standards. It also covers dependency-aware ordering, contributor attribution on GitHub and the staging branch when two streams of work converge. The goal is a team whose shared understanding makes good contributions easier to accept, with integration intensity increasing again when a change warrants closer attention.


This article is part of the synthesis coding series.