synthesis-code-integration
The adopt-and-adapt integration pattern for multi-contributor synthesis-coded projects. Covers the lead synthesist role, quality gates, cherry-pick safety, and graduated integration intensity. Use when asked to: synthesis coding, multi-contributor, integration, cherry-pick, adopt and adapt, lead synthesist, integrate contributions, merge contributor work.
Rajiv Pant · 已有静态检查记录
安装与使用
运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。
npx skills add synthesisengineering/synthesis-skills --skill synthesis-code-integration技能说明
name: synthesis-code-integration description: "The adopt-and-adapt integration pattern for multi-contributor synthesis-coded projects. Covers the lead synthesist role, quality gates, cherry-pick safety, and graduated integration intensity. Use when asked to: synthesis coding, multi-contributor, integration, cherry-pick, adopt and adapt, lead synthesist, integrate contributions, merge contributor work." license: "CC0-1.0" depends_on: [] metadata: author: "Rajiv Pant" version: "1.3.1" source_repo: "github.com/synthesisengineering/synthesis-skills" source_type: "public"
Code Integration
When multiple people contribute to a project built through synthesis coding, integration is fundamentally different from a standard open source merge workflow. This skill defines how it works.
The Core Problem
In synthesis coding, the lead developer (the "lead synthesist") builds and evolves the system through continuous, context-rich collaboration with AI. The result is a codebase with:
- Deep architectural consistency — decisions compound across sessions
- Implicit conventions — not all standards are documented yet because one person held them all in their head
- Rapid evolution — the codebase may change substantially between the time an external contributor branches off and the time they submit a PR
When an external contributor forks or branches, they get a snapshot. They build against that snapshot. Meanwhile, the lead may have evolved the architecture, introduced new patterns, improved output quality, or refactored entire subsystems. The contributor's code reflects the old state.
A blind merge risks:
- Regression — undoing improvements the lead made after the contributor branched
- Inconsistency — introducing patterns that conflict with the codebase's evolved conventions
- Security gaps — missing safeguards the lead added (audit logging, rate limiting, input validation)
- Quality drift — code that works but does not meet the project's current bar
Adopt-and-Adapt: The Integration Pattern
The lead synthesist does not merge external contributions directly. Instead:
- Adopt the intent, the design, and the valuable implementation work
- Adapt the code to meet current standards, architecture, and quality bar
This is neither a merge nor a rewrite. It is selective integration with improvement. The contributor's work is the foundation; the lead brings it up to production standard.
Why This Works
- Respects the contributor's work. Their design thinking, feature concept, and implementation effort are preserved.
- Maintains quality. The lead synthesist is the quality gate. Nothing ships that does not meet the bar.
- Avoids regression. By starting from current
mainand selectively pulling in changes, the lead never risks overwriting recent improvements. - Educates through feedback. The review process teaches contributors the project's standards, making future contributions smoother.
Why Direct Merge Does Not Work
- The contributor did not have the latest context. Their code is correct for a codebase that no longer exists in that exact form.
- Standards evolve faster than documentation. The lead synthesist holds conventions that are not yet written down.
- AI-accelerated development means the codebase moves fast. A branch that is a week old may be dozens of commits behind.
Roles
Lead Synthesist
The person who holds the architectural vision, maintains the quality bar, and has the deepest context on the system.
Responsibilities:
- Define and evolve project standards
- Review all external contributions
- Perform adopt-and-adapt integration
- Maintain the canonical repository
- Control production deployments
- Document standards as they emerge through the integration process
Key principle: The lead synthesist's standards ARE the project's standards. Integration is the forcing function that makes those standards explicit and documented.
Contributors
Developers who build features on branches or forks. They may or may not use synthesis coding themselves.
Responsibilities:
- Understand existing standards before building (read the contributor guide)
- Submit complete features (both frontend and backend, with tests)
- Maintain clean branch hygiene (one feature per branch, meaningful commits)
- Respond to review feedback and iterate
Contribution Workflow
Before Building
- Read the project's contributor guide. Every synthesis-coded project with external contributors should maintain one.
- Sync to latest main. Do not build on stale code.
- Discuss the approach for significant features. Especially anything touching auth, security, the data model, or user-facing architecture.
While Building
- One feature per branch. Never bundle unrelated work.
- Complete features only. Backend + frontend + tests = complete.
- Follow existing patterns. Before creating a new component, search the codebase for similar ones.
- Meaningful commits. Use conventional commit format (
feat:,fix:,docs:,test:,chore:).
Submitting
- Rebase onto latest main. Minimize divergence.
- Clean diff. No debugging artifacts, no commented-out experiments, no unrelated changes.
- Share early if uncertain. A draft PR with a question is better than a finished PR that needs fundamental rework.
The Integration Process
Step 1: Assess
- Fetch the branch and review the diff
- Identify what the contribution does, what it changes, and what assumptions it makes
- Check: how far has
mainmoved since the contributor branched off? - Check: does the contribution touch sensitive areas (auth, security, data model, user-facing text)?
Step 2: Review
Evaluate against the project's quality gates. Produce written feedback covering:
- What's strong — acknowledge good work
- What must change — security issues, broken functionality, standard