// Write the minimum implementation to pass the failing tracer test for a slice. Fires when a failing tracer test exists for the slice. Reads the slice (including out_of_scope) and the failing test before writing anything. Refuses to add features listed in out_of_scope. Refuses to modify the test.
Given a single out-of-scope or P3 finding id from docs/findings.json, file a GitHub issue for future resolution, dedup against existing open issues, append to docs/issues-filed.json, and label with deferred-from-loop. Refuses P1 findings. Operates on exactly one finding per invocation.
Optional post-green cleanup of a slice's implementation. Fires when the slice's test suite is green after slice-impl completes. Reads the slice definition and test files; modifies only implementation files. Tests must be green before starting and must remain green throughout. Aborts and reverts if any refactor step breaks a test. Skipped when the green implementation already reads cleanly.
Write exactly ONE failing test targeting a slice's first acceptance criterion. Fires when a slice is ready and no passing test yet covers the first criterion. Never writes implementation. Refuses to run if a passing test already covers the criterion.
Given a single finding id from docs/findings.json, apply a triage-approved fix to the relevant slice, re-run the slice's tests, and record the resolution result. Refuses to act on findings where in_scope is false. Aborts and reports if tests fail after the fix. Operates on exactly one finding per invocation.
On workflow exit, read the workflow trace and substrate indexes lazily, identify real signal (recurring deferral, novel ADR, new anti-pattern, reusable solution, new vocabulary term), and write 0–4 substrate entries via substrate-write. Refuses to write when nothing meaningful surfaced. On a failed-gate workflow, writes the rejection reason as an anti-pattern or ADR. Invoke when a workflow is about to exit.
Run weekly substrate maintenance: promote recurring anti-patterns to reviewer entries, merge overlapping ADRs with supersession, mark stale solutions and superseded ADRs, and retag scope globs for moved files. All writes go through substrate-write (append-only). Invoke on cadence (weekly) or when substrate signal degrades.
| name | slice-impl |
| description | Write the minimum implementation to pass the failing tracer test for a slice. Fires when a failing tracer test exists for the slice. Reads the slice (including out_of_scope) and the failing test before writing anything. Refuses to add features listed in out_of_scope. Refuses to modify the test. |
| inputs | {"slice":"A slice entry from docs/plans/<workflow_id>.md — id, title, acceptance_criteria, touched_paths, out_of_scope","failing_test":"The failing tracer test file produced by tracer-test for this slice"} |
| outputs | {"implementation":"The minimal source file(s) under touched_paths that make the failing test pass"} |
| substrate_access | {"pattern":"eager","reads":[".substrate/anti-pattern/INDEX.md"],"on_demand":"Anti-pattern bodies fetched via substrate-read when scope glob matches the slice's touched_paths"} |
Triggered when a failing tracer test exists for the slice. Eagerly loads anti-pattern entries scoped to the slice's touched_paths before writing anything. Reads the slice definition (including out_of_scope) and the failing test in full. Writes the minimum implementation that makes the failing test pass and keeps all existing tests green. Refuses to add any feature listed in out_of_scope. Refuses to modify the test. Stops if no failing test exists or if the failing test does not belong to this slice.
Before reading any artifact, confirm that:
<slice_id> is produced by tracer-test — confirm the file is present.Cannot start slice-impl: no failing test found for slice <slice_id>.
The test at <test_path> is already passing (or no test file exists).
Run tracer-test for this slice first, then run slice-impl.
Cannot start slice-impl: the failing test at <test_path> is for slice <other_slice_id>,
not slice <slice_id>. Provide the correct test file for this slice.
Do not proceed until all three conditions are confirmed.
Before reading the slice or the test, load the anti-pattern index:
.substrate/anti-pattern/INDEX.mdFor each anti-pattern index entry, check whether its scope overlaps the slice's touched_paths globs. Fetch the body of every matching anti-pattern entry via substrate-read before proceeding.
Record each loaded anti-pattern as a constraint that the implementation must not violate.
If the anti-pattern index does not exist or is empty, continue — absence of anti-patterns is not a blocker.
Read the slice entry in full from docs/plans/<workflow_id>.md. Extract and record:
id — the stable slice identifiertitle — the slice descriptionacceptance_criteria — the list of observable behaviors the slice must satisfytouched_paths — the globs that bound the implementation's blast radiusout_of_scope — the explicit YAGNI guards; this list is a hard constraintInternalize out_of_scope as a set of prohibited features. Any item listed there must not appear in the implementation, regardless of how natural or helpful it might seem.
Read the failing test file in full. Understand:
Do not write any implementation yet.
Before writing code, reason through the smallest change that satisfies all of the following simultaneously:
out_of_scope is not violated. None of the items in the slice's out_of_scope list appear in the implementation.touched_paths. Only files matching the slice's touched_paths globs are created or modified.If satisfying the failing test requires changes to files outside touched_paths, stop and report:
slice-impl blocked: the failing test requires changes outside the slice's touched_paths.
Test requires: <path>
Slice touched_paths: <globs>
Escalate to the plan author to update the slice definition before proceeding.
If satisfying the failing test would require adding a feature listed in out_of_scope, stop and report:
slice-impl refused: the failing test requires implementing "<out_of_scope_item>",
which is explicitly listed in this slice's out_of_scope.
out_of_scope entry: <item>
The test or the slice definition needs to be reviewed before proceeding.
Do not write any code if either blocker applies.
Write the minimum code required. Apply these rules:
out_of_scope. Cross-check each code element added against the out_of_scope list before committing it. If an element is borderline, err on the side of exclusion.After writing the implementation, run the test suite:
If the failing test still fails after writing the implementation, diagnose and correct the implementation. Do not modify the test.
If existing tests regress, diagnose and correct the implementation to eliminate the regression. Do not modify existing tests.
Repeat Steps 5–7 as needed until both conditions hold.
Confirm the result to the user:
slice-impl complete.
Slice: <slice_id> — <title>
Test: <test_path> — now passing
Files written or modified:
<path> — <one-line description of what was added>
...
out_of_scope enforced (not added):
- <item>
- <item>
Anti-patterns applied: <count> (<list of anti-pattern ids loaded>)
Existing tests: <N> passing, 0 regressions
If no out_of_scope items were at risk of inclusion, omit that section. If no anti-patterns were loaded, omit that section.
out_of_scope is a hard constraint. Items listed there are prohibited features, not suggestions. Any implementation element that corresponds to an out_of_scope item must be removed.touched_paths scope filter must be applied at the index layer; only matching entries are fetched in full.touched_paths. Implementation changes must not create or modify files outside the slice's declared globs. Violations require escalation, not workarounds.slice-refactor, not this skill.