micropatch

Capture fork customizations as MicroPatch specs and re-apply them to newer upstream codebases.

4|Updated Mar 5, 2026
One-click install
npx skills add https://github.com/lirrensi/agent-sommelier --skill micropatch
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: micropatch
Source: https://github.com/lirrensi/agent-sommelier/tree/main/skills/micropatch
Command: npx skills add https://github.com/lirrensi/agent-sommelier --skill micropatch

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps you reliably capture and re-apply intentional fork customizations so features survive upstream upgrades without brittle diff/merge replay.

Core Features & Use Cases

  • Semantic MicroPatch specs: documents a customization as a behavior-level contract (intent, scope, dependencies, verification).
  • Create and Apply workflows: extracts fork intent into MicroPatch folders, then re-implements the feature semantically on newer upstream code.
  • Verification-first Definition of Done: focuses success on externally observable behavior and concrete checks, not on whether old lines were restored.
  • Idempotent, non-mechanical application guidance: emphasizes adaptation to upstream reality and avoiding redundant overlap.

Quick Start

Use the micropatch skill when you need to extract a fork’s meaningful changes into a reusable MicroPatch spec and later re-apply that same feature contract to a newer upstream release.

Frequently Asked Questions about micropatch

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I preserve fork features when applying upstream upgrades?

Semantic patching captures fork customizations as behavior-level MicroPatch specifications, re-applying the intended feature contract onto newer upstream codebases instead of replaying brittle diffs.

Why does diff and merge replay break when maintaining long-lived forks?

Diff and merge replay breaks because it mechanically restores old lines without adapting to upstream reality. Semantic patching instead uses a verification-first Definition of Done focusing on preserving externally observable behavior.

How to document fork customizations so they survive upstream releases?

You document fork customizations by writing a folderized MicroPatch with a micropatch.md spec, optional advisory hints.diff, and a clear Definition of Done enabling verification of intentional differences across releases.

What is semantic patching for fork maintenance?

Semantic patching for fork maintenance is the process of extracting intentional codebase differences into reusable behavior-level contracts, ensuring features are idempotently re-implemented on newer upstream releases without mechanical overlap.

What are the limitations of using semantic patches for upstream syncing?

Semantic patches require adapting to upstream reality and avoiding redundant overlap. Hints.diff is advisory only, meaning success depends on meeting externally observable behavior checks defined in the verification criteria, not mechanical line restoration.