Last week I was integrating twelve PRs from six engineers in a single day. The synthesis merging process worked — cherry-picks, regression verification, quality gates — but every step depended on methodology I had documented in runbooks scattered across private repositories. If another engineer needed to run the same process, they would have had to read my CLAUDE.md files, find the right runbook, copy it into their own setup, and hope the references still pointed somewhere valid.
That is not how methodology should travel.
Today I am releasing Synthesis Skills — 20 open-source Agent Skills that encode the methodology behind synthesis coding and synthesis engineering into a format any AI coding assistant can use. One command installs all of them:
npx skills add rajivpant/synthesis-skills --global --all --copyThis works with Claude Code, Cursor, Codex CLI, GitHub Copilot, and 40+ other agents that support the Agent Skills open standard.
What Agent Skills actually are
The Agent Skills standard, released by Anthropic in December 2025, defines a portable format for teaching AI assistants how to do things. Each skill is a SKILL.md file — YAML frontmatter describing what the skill does and when to use it, followed by markdown instructions.
The format uses progressive disclosure to manage token costs:
- Tier 1 — name and description (~50 tokens per skill) load at session startup. Your assistant knows what skills are available without reading the full instructions.
- Tier 2 — the SKILL.md body (under 500 lines) loads when your task matches the skill description. You ask for a code review; the code review methodology appears.
- Tier 3 — reference materials, detailed checklists, and supporting documents load on demand when the skill body references them.
This means 20 installed skills cost about 1,000 tokens of always-on overhead — roughly 0.1% of a 1M context window. The full methodology loads only when relevant.
What is in the collection
The skills span four disciplines that synthesis engineering practitioners encounter daily.
Engineering methodology. Codebase review provides an enterprise-scale audit framework with a tiered review system — Essential items that every codebase needs, through Mission-Critical items for production systems handling money or sensitive data. PR review encodes the delta review methodology I developed for synthesis-coded projects, including security scanning patterns that catch the kind of secret-logging bugs that slip through when AI assistants introduce debug statements during development. Code integration is the adopt-and-adapt pattern for multi-contributor work — the full cherry-pick safety protocol, including the regression verification process that caught a silent feature revert in a real production system.
Content creation and quality. A 27-point content quality framework for detecting and fixing the patterns that make AI-assisted writing sound like AI-assisted writing. A systematic fact-checking process with a multi-source confidence framework designed for articles synthesized from multiple AI research outputs — where errors tend to be subtle (wrong framing of correct numbers, conflated findings) rather than obvious fabrications.
Project management. The context lifecycle skill implements the three-tier architecture I wrote about in Context Loss and How to Prevent It — CONTEXT.md for working memory, REFERENCE.md for stable facts, sessions/ for archived logs. It solves the problem of AI assistants starting every session with zero context by giving them a structured system for maintaining continuity across weeks of work.
Reasoning techniques. Tree-of-thought prompting, structured code planning (evaluate multiple approaches before writing), and LLM project setup across Claude, ChatGPT, and Gemini.
The full catalog is on GitHub.
Why methodology, not capabilities
Most Agent Skills in the ecosystem focus on capabilities — API integrations, code generation patterns, platform-specific tooling. Synthesis Skills focus on methodology: how to think about a code review, how to structure an article for accuracy, how to manage context across a long-running project.
The distinction matters because capabilities change with every model release. A code generation skill written for GPT-4 may be obsolete when GPT-5 ships. But the methodology of reviewing a codebase tier by tier — starting with security and architecture before touching style — does not expire. The adopt-and-adapt integration pattern works regardless of which model your contributors used to write their code.
Methodology skills compound over time. When I discovered that cherry-picks can silently revert prior synthesis merge work, that lesson went directly into the code integration skill. When a PR review caught secret-logging that an AI assistant introduced during a development session, the detection pattern went into the PR review skill. Each incident makes the skills better. Capabilities are replaced; methodology is refined.
Lessons from converting 13,000 lines of runbooks
Synthesis Skills did not start as skills. They started as markdown runbooks in private repositories — 67 files totaling over 13,000 lines, accumulated over months of synthesis coding practice. Converting them taught me three things worth sharing.
Identity and methodology must be separated. My runbooks mixed instructions about how to do things (methodology) with instructions about how I want Claude to talk to me (identity). When I tried to share a code review runbook with a colleague, it came with my personal voice preferences, my forbidden-words list, and my confidentiality rules embedded throughout. The separation I arrived at: methodology goes in skills (portable, shareable), identity stays in CLAUDE.md (personal, always-loaded). Public skills include sensible defaults and defer to your CLAUDE.md preferences when present.
Safety guardrails cannot be on-demand. Skills load based on task matching — ask for a code review, the review skill loads. But confidentiality rules, deployment gates, and never-delete policies must be active at all times, not just when a matching skill happens to trigger. The architecture: CLAUDE.md keeps the rules (always loaded, 136 lines on my machine). Skills provide the detailed procedures. Your assistant always knows it needs deployment permission. The full deployment checklist loads only when you are actually deploying.
Namespace collisions are a real problem in a flat ecosystem. I released v1.0.0 with generic names like pr-review and fact-checking. Within hours, I recognized the collision risk — other skill authors would inevitably use the same names, and the last install silently overwrites the first. v2.0.0, released the same day, prefixes every skill with synthesis- for global uniqueness. The cost is a few extra characters. The benefit is that installing Synthesis Skills will never break someone else’s setup, and vice versa.
How to install
For users with Node.js:
npx skills add rajivpant/synthesis-skills --global --all --copyWithout Node.js:
curl -fsSL https://raw.githubusercontent.com/rajivpant/synthesis-skills/main/install.sh | shBoth install all 20 skills to ~/.claude/skills/, ~/.agents/skills/, and any other agent directories detected on your machine. Update with npx skills update or ./install.sh update.
To install specific skills only:
npx skills add rajivpant/synthesis-skills --global --copy --skill synthesis-pr-review,synthesis-codebase-reviewWhat comes next
The skills are CC0 (public domain) for methodology and Apache 2.0 for executable scripts. Use them however you want. Contribute improvements if you find gaps.
I will continue refining these skills as I encounter new patterns in real projects — the same way the code review runbook became an upgrade playbook and the multi-contributor workflow evolved through twelve PRs in a single day. The skills are the living documentation of what works.
If you are practicing synthesis coding, these skills encode the methodology so your AI assistant does not start from zero every session. If you are new to the approach, the skills are a practical way to try it — install them and see how structured methodology changes the quality of your AI-assisted work.
The repository: github.com/rajivpant/synthesis-skills
The standard: agentskills.io
This is part of a series on synthesis coding — the practice of building software through human-AI collaboration where the human provides direction, judgment, and domain expertise while the AI provides execution speed and breadth. Synthesis Skills are one component of the synthesis engineering methodology.
Rajiv Pant is a technology executive and AI practitioner. He created the synthesis coding methodology and leads engineering teams building AI-powered products.