scoped-sequential-prs

Splits large changes into ordered, single-purpose PRs with a mechanical contamination gate.

Updated Jul 9, 2026
One-click install
npx skills add https://github.com/t-step/bindle-archive --skill scoped-sequential-prs-t-step
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: scoped-sequential-prs
Source: https://github.com/t-step/bindle-archive/tree/main/skills/scoped-sequential-prs
Command: npx skills add https://github.com/t-step/bindle-archive --skill scoped-sequential-prs-t-step

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Large or tangled changes are hard to review as one PR, and splitting them by hand often leaks later-stage code or documentation into early PRs. This Skill enforces strict scope isolation so each PR in an ordered series contains only what its stage owns. ## Core Features & Use Cases - Ordered PR series planning: Define each stage's name, owned files, and acceptance checklist, then build PRs sequentially in separate git worktrees. - Three-step contamination gate: A file-scope diff check, a content scan for forward references to later-stage symbols, and a scope-declaration integrity check that forces explicit Scope override: statements instead of silently widened allow-patterns. - Scope isolation rules: No forward-looking code or prose, each PR builds and tests standalone, and shared prerequisites are pulled into the earliest stage that needs them. - Use Case: You have an uncommitted prototype with a lexer, parser, and evaluator. Use this Skill to land it as PR1 (lexer only), PR2 (parser), PR3 (evaluator), verifying with the gate that no parser or evaluator code or docs leak into PR1. ## Quick Start Split my uncommitted prototype into an ordered series of clean single-purpose PRs and prepare the first PR, keeping later-stage code and docs out of it.

Frequently Asked Questions about scoped-sequential-prs

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

FAQPage Schema
How do I split a large change into multiple PRs in git?▼

Plan an ordered list of stages where each PR owns specific files, build each stage in its own git worktree, and base each new PR on the merged tip of the previous one. Run a contamination check on the diff before opening each PR to confirm only in-scope files landed.

How do I keep later-stage code out of an early PR?▼

Run a two-part gate: check git diff --name-only against an allow-pattern of files the stage owns, then grep the added diff lines for symbols owned by later stages. Any match is contamination to strip or move to the PR that owns it.

Why does my scoped PR pass a file check but still break the build?▼

A name-only diff check cannot see forward references inside an in-scope file, such as an import of a module the PR excludes. Add a content scan of the diff's added lines for later-stage symbols to catch imports or calls that leave the PR non-building.

When should I not split a change into a PR series?▼

Do not split a genuinely atomic change or a small change that is already one reviewable PR. Sharding those artificially adds overhead without improving reviewability.

What is a scope override in a staged PR workflow?▼

A scope override is deliberately including a later-stage file or symbol, for example due to an explicit user instruction. It must be stated as a Scope override line in the PR description and gate report, never hidden by widening the allow-pattern and reporting clean.