breaking-driven
/breaking-driven
Use when bloated code needs clean re-derivation, or the user says "this module is bloated" or "break it and rebuild". Not for untracked data or changes without VCS rollback.
- Author
- gosuda ↗
- Repository
- dalcom-skills ↗
- Licence
- Apache-2.0
- Last repository change
- 10.11.2026
Assessment and security
- Files in this package
- 2
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 10.11.2026, without references to retired models or APIs.
Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.
What it does and when to use it
Use when bloated code needs clean re-derivation, or the user says "this module is bloated" or "break it and rebuild". Not for untracked data or changes without VCS rollback.
Triggers from the description
Original author description
Use when bloated code needs clean re-derivation, or the user says "this module is bloated" or "break it and rebuild". Not for untracked data or changes without VCS rollback.
How it works
- Name the target
- Separate interior from boundary
- Write the contract, then look away
- Walk every old behavior
- Ask before touching the boundary
- Demolish, test, commit
- When it goes wrong
- What you hand back
SKILL.md preview
--- name: breaking-driven description: 'Use when bloated code needs clean re-derivation, or the user says "this module is bloated" or "break it and rebuild". Not for untracked data or changes without VCS rollback.' --- # Breaking-driven development Some modules are past patching: layers of accretion, duplicated branches, indirection that no longer serves any caller. This skill rebuilds such a module from its consumer contract instead of refactoring its structure, so the accretion cannot reproduce itself under fresh names. It runs on one target at a time, deletes everything the contract does not require, and commits each target atomically with its essential behaviors tested. It works only where version control can undo it: every mutation touches VCS-tracked targets, the exact set is shown before anything is deleted, and nothing is pushed anywhere. There is no remote mutation in this skill. Before the first deletion, the target paths must have no uncommitted changes; if they do, stop and report those paths, because reverting to the last green commit would also discard them. ## Name the target A named path goes straight to work. A blank invocation or explicit repo-wide wording is the only license to survey: rank candidates by bloat signal, size, duplication, indirection depth, and branch density, then work the list in order, one target committed before the next begins. Anything identifiable scopes to itself. Each invocation is one run with no standing cadence; a recurring sweep needs a cadence request in that invocation. Escalating a named grievance into a whole-tree campaign is this skill's worst failure, and trigger phrasing alone never distinguishes a single target from a sweep. ## Separate interior from boundary Inventory the target's consumers and mark each surface as one of: * Interior: every caller is in-tree, nothing persisted or shipped. * Boundary: public API, wire or on-disk format, config running in someone else's deployment, plugin point, anything a version was promised against. Interior is a conclusion, not a default: every consumer channel static analysis cannot resolve (reflection, string dispatch, generated code, external integrations, operator runbooks) carries boundary class until evidence or an explicit yes moves it. An empty grep over dynamic dispatch is not evidence; unresolved means boundary. Nothing below proceeds on an unclassified surface. ## Write the contract, then look away State what the target owes its callers, sourced from call-site usage, existing tests, and the public signature (never from the target's own internals), and build the replacement from that statement alone. Reaching into the old structure for the contract is how the accretion reproduces itself; state the contract, then look away. ## Walk every old behavior Go through the old implementation function by function, branch by branch within a single function, and for each behavior name where it lives in the replacement or classify it. Read for behavior rather than structure: branches, guards, early returns, side effects, ordering guarantees, error and failure semantics, state transitions. This audit is the only backstop in the method (nothing executable proves the replacement equivalent), so a behavior never read is a feature deleted by accident, and the walk is exhaustive, not impressionistic. Classify each behavior with a one-line reason as one of: * Essential: fold it into the replacement. * Residue: cut it. Performance characteristics are out of scope; benchmark separately when the target is hot. Nothing is cut or kept without its classification. ## Ask before touching the boundary Present every boundary surface and get an explicit answer before touching it. Interior surfaces need no ask; demolish them. Each boundary surface carries a recorded answer: * Yes: cut it. * No: keep it permanently. It is contract, not residue. Cut none on silence or after a no. A general instruction such as no defer or do all of it is never a recorded answer for a boundary surface. Each boundary surface needs its own yes or no after it has been presented with its class. This is the one place the skill stops, and stopping is the design, not hedging. ## Demolish, test, commit Delete the old implementation and every surface reachable only from it. Do not write an adapter from the new shape back to the old: that resurrects the demolished structure under a new name. Run the repo's existing test suite, and cover every behavior classified essential that had no test. Commit this target atomically before starting the next. A search for every symbol classified residue must return nothing (no unused imports, deps, types, or files survive), while surfaces kept essential or refused at the boundary gate keep their identifiers: they are the contract, not leftovers. Half-demolished is the forbidden state: finish a target or revert it via version control to the last green commit, never ship the middle. ## When it goes wrong - Residue remains (exit 1): symbols, imports, config keys, or doc references classified residue still resolve. Delete them; do not ship until the search is empty. - Verifier red (exit 2): the repo's own tests or build fail against the replacement. Fix the replacement or revert the target; never ship red. - Campaign stalled mid-target (exit 3): a target is half old, half new. Finish it or revert it to the last green commit; never ship the middle. - Divergence unclassified (exit 4): old behavior neither folded in as essential nor cut as residue. Complete the walk before proceeding. - Boundary cut without an answer (exit 5): a published surface was destroyed on silence or after a no. Restore it from version control and settle the question. - Scope exceeded (exit 6): a repo-wide sweep ran off a named target. Revert the untargeted work. - A half-demolished target is never left in the tree. Revert to the last green commit rather than widen scope or invent evidence, and never swallow a verifier failure or pretend the work is done when it is not. ## What you hand back Each target produces a clean demolition: consumer contract restated, replacement derived from it, every old behavior classified essential or residue, residue deleted, essential behaviors tested, target committed atomically with the verifier green. A repo-wide campaign produces one such commit per target in ranked order.
Files in this package (2)
- SKILL.md 6 KB
- agents/openai.yaml 1 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · gosuda/dalcom-skills | 90 | Apache-2.0 |
| OutlineDriven/outline-driven-development | 100 | Apache-2.0 |
Database snapshot: 13.11.2026 · package version 816592260bf5 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100deprecate-and-migrate
Use when asked to remove old code, migrate consumers, or decide whether to maintain or sunset a system. Not for untracked data or changes without VCS rollback. - 100rebuild
Use when asked to rewrite or clean up a bloated ticket or epic that hard-codes implementation, restates a spec, or cites counts and line numbers. - 90migrasutra-breaking-change
Use when migration work needs the breaking-change and api impact specialist: identify code and configuration likely affected by target-version breaking changes and produce proof-linked findings. - 90clean-clean-cut
Use when asked to run /clean-clean-cut to cut accumulated records and residue. Not for untracked or non-VCS changes, or branch/worktree cleanup: use git-cleanup. - 100anti-slop-stack
Ruthless multi-layer purifier for AI coding agents. Eliminates bloated boilerplate, hallucinated abstractions, narrative comments, generic AI template UIs, and robotic prose. Use when asked to "remove AI slop", "clean up code", "audit for bloat", "simplify project", or "purify codebase". - 90change-write
Write a changelog entry or release notes for an API version — breaking changes, new features, fixes. Use when asked to "write release notes", "add a changelog entry", or "document breaking changes".