MCPInstall

scoping-changes

Use when deciding how big a fix should be, when scope is drifting mid-task, when a plan is being quietly trimmed to fit, or when "while you're at it" appears in any form. Encodes size-to-trigger, decompose-not-descope, and drive-to-completion. Use whenever the work is about to grow past its cause or shrink below its promise.

Installs
18.3K
Last 24h
+389
Trending rank
#786
Security
Pass

Install

Works with every agent the skills CLI supports.

npx skills add https://github.com/riekelt/principal-engineer --skill scoping-changes
  1. 01

    Install

    Run the command in your project. The CLI asks which agents to install for.

  2. 02

    Describe the task

    Ask your agent for something this skill covers. It loads scoping-changes automatically when relevant.

  3. 03

    Review the result

    The agent follows the SKILL.md steps, scripts and references bundled with the skill.

Security audits

Independent scans of the skill's instructions and bundled files.

Gen Agent Trust Hub PassSAFE ·The skill provides engineering guidelines for managing task scope and contains no executable code or security risks.
Socket PassNo alerts
Snyk PassLOW ·Risk: LOW · No issues

SKILL.md

The instructions your agent reads when the skill is triggered.

Scoping changes

REQUIRED BACKGROUND: the principal-engineering skill.

Overview

Scope fails in both directions: gold-plating grows a fix past its trigger; silent descoping shrinks an approved task below what was agreed. Both are one defect: the delivered change no longer matches its cause. Core principle: size fixes to their trigger, and when reality forces a cut, decompose visibly instead of trimming quietly.

Sizing to the trigger

  • The trigger is the defect or need itself, not the ticket's sentence about it. The same defect found on a second path is in scope (reporting "fixed" while it lives on elsewhere is a half-true report); an adjacent improvement found because the file was open is not.
  • The fix is as big as the thing that triggered it. No gold-plating, no fencing unreachable edges, no refactor riding along because the file was open.
  • Adjacent improvements you noticed are real and belong in the tracker, not in this diff.
  • Borderline addition test: would it ship on its own merits if the main fix did not exist? If not, it is decoration on someone else's diff. If it would, it ships on its own: passing the test licenses a separate change, never a rider.
  • The owner can re-scope; the owner cannot merge scopes. "Squeeze it in" from whoever owns the work legitimately adds the second task, and it still ships as its own change. These rules govern how work is shaped; the owner decides what work exists.
  • Unrequested structure is scope creep wearing a design pattern: an interface with a single implementer, a factory that only ever builds one thing, configuration for a value nobody will change. Add the structure when the second case arrives, not when it is imagined.
  • A deliberate simplification that accepts a real limit carries that limit in a comment: the ceiling and what would justify raising it ("one shared queue; shard per tenant when a single consumer can no longer keep up"). The ceiling is a current constraint: the comment describes what the system does today, not the history of the decision.
  • Exhaust the codebase, the standard library, the platform, and the dependencies already installed before writing new code; see adding-dependencies before reaching for a new package.

Decompose, never silently descope

  • The owner decomposes an approved task that turns out too big into named parts with the cut line stated, never delivering a quiet "pragmatic minimum" that looks complete.
  • The author files each deferred part as a tracked item with an owner, or explicitly "owner pending triage" when none exists yet. Tracker discipline lives in the technical-writer plugin's writing-issues where installed. Deferred work that lives only in the author's memory was descoped, not deferred.
  • The report says plainly which parts shipped and which did not. A partial delivery honestly labeled is a plan; a partial delivery labeled complete is a defect.

Driving to completion

  • An approved plan runs to completion without "want me to continue?" checkpoints; stop only for genuine blockers, destructive actions, or hard gates that need the operator.
  • Blocked on one part: finish the unblocked parts, surface the blocker with what it needs, never let one stuck task silently stall the rest.
  • Settled decisions stay settled mid-execution. New information that genuinely reopens one becomes an explicit re-decision, not a quiet swerve; record it via recording-decisions where the technical-writer plugin is installed.

Scope in review

  • Reviewing: an unrelated defect noticed in passing is not your finding; note it once for the tracker and stay on the diff.
  • Being reviewed: findings against the diff get fixed or explicitly answered; findings outside the diff get tracked, not absorbed into the change.

Common mistakes

  • "While I'm here" as a justification. You are here for the trigger.
  • Descoping to hit a deadline and reporting done. The deadline pressure was real; the honest move was decomposing and saying which half shipped.
  • Fencing edge cases the system cannot reach, to feel thorough. Unreachable defensiveness is dead code with good intentions.
  • Re-litigating an approved design mid-implementation because a mildly better idea appeared. Write the idea down; finish the plan; propose it against the shipped reality.
  • Letting a reviewer's out-of-scope wish expand the diff. Track it, thank them, ship the trigger.

FAQ

What does the scoping-changes skill do?

Use when deciding how big a fix should be, when scope is drifting mid-task, when a plan is being quietly trimmed to fit, or when "while you're at it" appears in any form. Encodes size-to-trigger, decompose-not-descope, and drive-to-completion. Use whenever the work is about to grow past its cause or shrink below its promise.

How do I install scoping-changes?

Run npx skills add https://github.com/riekelt/principal-engineer --skill scoping-changes in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/scoping-changes/ (personal) or .claude/skills/scoping-changes/ (project).

Which AI agents can use scoping-changes?

Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.

Is scoping-changes safe to install?

Security partners have reviewed it: Gen Agent Trust Hub passed; Socket passed; Snyk passed. As with any skill, read the SKILL.md and bundled scripts before installing.

Who maintains scoping-changes?

It is published by riekelt in riekelt/principal-engineer. It has 18,317 recorded installs.

More from riekelt/principal-engineer

View all →

principal-engineering

riekelt/principal-engineer

Use when doing any non-trivial engineering work - implementing, debugging, refactoring, configuring, operating, or investigating why a system misbehaves - or any change where being wrong has a cost. Encodes the evidence-over-theory discipline, the hard safety rules, and the pre-change checkpoint. Use whenever code, data, or infrastructure is about to change or must be understood before it can, even if the task looks routine or is only "find out why". Foundation for the sibling skills.

writing-unit-tests

riekelt/principal-engineer

Use when writing or refactoring unit tests - a new test file, added cases, a flaky test, an unreadable one. Encodes behavior-first testing: one behavior per test, names that state the claim, deterministic setup, mocks only at boundaries you do not own. Use whenever a test is being written, even a quick one, and whenever a test needs a sleep, a mock of your own code, or a copy of the implementation's math.

Testing & QA18.4K installs

verifying-before-done

riekelt/principal-engineer

Use when about to say "done", "fixed", "passing", or "shipped", or when reporting the outcome of any change. Encodes verification as the definition of done: drive the change at its surface, run the verify command, report faithfully, distrust green suites, own failing gates. Use before every completion claim, even when the change was small and obviously correct, which is when this is skipped.

Docs & Writing18.4K installs

guarding-architecture

riekelt/principal-engineer

Use when a change crosses module boundaries, adds a dependency direction between modules, touches a critical path, or conflicts with a stated principle - and when writing or updating architecture principles themselves. Encodes structural invariants as named, enforced contracts: statement, rationale, guard. Use whenever "we'll just import it from there for now" appears, which is how boundaries die.

keeping-one-source-of-truth

riekelt/principal-engineer

Use when adding data, config, state, constants, an enum-like string, a cache, or anything that could exist in two places - or when two sources already disagree. Encodes the one-fact-one-source doctrine for code and data: derive rather than store, extend the owner, absorb duplicates. Use at the moment copying a value feels faster than referencing it.

18.3K installs

testing-changes

riekelt/principal-engineer

Use when deciding what tests a change needs - a feature, a bug fix, a refactor, any behavior change - or when reviewing whether a diff's tests are sufficient. Encodes tests-change-with-behavior, the bug-regression pattern, and assertion discrimination. Use whenever behavior changes and the test diff is empty, especially when the change is "too small to test".

Testing & QA18.3K installs

Popular code quality & workflow skills

View category →

grill-me

mattpocock/skills

A relentless interview to sharpen a plan or design.

Scan a codebase for deepening opportunities, present them as a visual HTML report, then grill through whichever one you pick.

handoff

mattpocock/skills

Compact the current conversation into a handoff document for another agent to pick up.

domain-modeling

mattpocock/skills

Build and sharpen a project's domain model. Use when discussing codebase terminology, writing or editing a GLOSSARY.md, or recording or editing an ADR.

codebase-design

mattpocock/skills

Shared vocabulary for designing deep modules. Use when the user wants to design or improve a module's interface, find deepening opportunities, decide where a seam goes, make code more testable or AI-navigable, or when another skill needs the deep-module vocabulary.

diagnosing-bugs

mattpocock/skills

Diagnosis loop for hard bugs and performance regressions. Use when the user says "diagnose"/"debug this", or reports something broken/throwing/failing/slow.