Przejdź do treści
Biblioteka skilli
Programowanie · Budowanie i kod

breaking-driven

/breaking-driven

Oczyszcza rozdęty kod przez ponowne wyprowadzenie od zera, pod warunkiem że zmiany są w kontroli wersji.

Repozytorium
dalcom-skills ↗
Licencja
Apache-2.0
Ostatnia zmiana repozytorium
10.11.2026

Ocena i bezpieczeństwo

90/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść25 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 10.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co robi i kiedy

Oczyszcza rozdęty kod przez ponowne wyprowadzenie od zera, pod warunkiem że zmiany są w kontroli wersji.

Wyzwalacze z opisu

this module is bloatedbreak it and rebuild
Oryginalny opis (EN)

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.

Jak działa

  1. Name the target
  2. Separate interior from boundary
  3. Write the contract, then look away
  4. Walk every old behavior
  5. Ask before touching the boundary
  6. Demolish, test, commit
  7. When it goes wrong
  8. What you hand back
Sekcje z nagłówków SKILL.md, w oryginale · 59 linii, 987 słów
Podgląd SKILL.md
---
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.
Pliki w paczce (2)
  • SKILL.md 6 KB
  • agents/openai.yaml 1 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · gosuda/dalcom-skills90Apache-2.0
OutlineDriven/outline-driven-development100Apache-2.0

Migawka bazy z 13.11.2026 · wersja paczki 816592260bf5 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100deprecate-and-migrate
    Pomaga usuwać stary kod, migrować konsumentów i rozstrzygać, czy system utrzymywać, czy wygasić.
  • 100rebuild
    Przepisuje rozdęty ticket lub epic, który narzuca implementację, powtarza specyfikację albo cytuje liczby i numery linii.
  • 90migrasutra-breaking-change
    Wskazuje kod i konfigurację, na które wpłyną zmiany niezgodne z wersją docelową, i podaje ustalenia z dowodami.
  • 90clean-clean-cut
    Wycina nagromadzone rekordy i pozostałości po poleceniu /clean-clean-cut, z wyłączeniem zmian nieśledzonych i sprzątania gałęzi czy worktree.
  • 100anti-slop-stack
    Oczyszcza kod pisany przez agentów AI z przerostu szablonów, zmyślonych abstrakcji, narracyjnych komentarzy i robotycznego tekstu.
  • 90change-write
    Pisze wpis do changelogu lub notatki wydania dla wersji API: zmiany łamiące, nowe funkcje i poprawki.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.