Use when a requirement spans a full vertical capability slice across multiple hexagonal zones — domain entity, port, adapter(s), use case, render/web — plus port conformance. Defines the double-loop TDD protocol, the sanctioned WIP-acceptance-test mechanism, the layer implementation order, and the slice definition of done.
90%
Does it follow best practices?
Run evals on this skill
Adds up to 20 points to the overall score
Passed
No findings from the security scan
A slice is ONE behavioral requirement whose implementation crosses all four zones. It is not five requirements. REQ IDs name behavior the user of the system can observe; "implement the repository adapter" is not a requirement, it's a layer of one. The exception: a port guarantee that is domain- meaningful in its own right ("save then load returns an equal sale") gets its own REQ ID, because the contract suite that verifies it outlives any single slice.
Two loops, two clocks:
The reconciliation with the rest of the kit is the WIP convention below: the outer test exists, is committed, guides the work — but is excluded from the green bar in a form that is mechanically tracked and cannot be silently left behind.
#[ignore])// REQ-SALE-007
#[ignore = "WIP(REQ-SALE-007)"]
#[test]
fn customer_sees_discounted_total_on_checkout() { ... }Rules, all mechanically enforced:
WIP(REQ-<AREA>-<NNN>). check-guard permits
adding #[ignore] ONLY in this form; any other ignore is still a
weakening violation.status: in-progress.status: accepted. You cannot declare a slice done and leave the
acceptance test parked — removing the marker and seeing the test green
IS the definition of done.@wip(REQ-<AREA>-<NNN>) tag on the scenario, with the wip tag excluded
from the default cucumber run — identical rules, identical staleness
semantics; the audit greps the tag instead of the attribute.Inside-out with the outer rail in place. Each step is a normal tdd-cycle loop in its zone, with the test types testing-strategy assigns to that zone:
in-progress.composition-root —
the only crate permitted to depend on everything) connects the pieces.
Remove the WIP marker. Acceptance test green. Spec status → accepted.
hex-lint clean — any new crate created during the slice was tagged
with its hex-arch.role at creation (untagged members are a hard
error, so this cannot be deferred).
DON'T FORGET: register in the composition root and prove it from the
real binary. The test harness wires its own world — a handler can
pass every web feature while the real binary still 404s the route
because nothing registered it. Field incident: the action took the
"unknown action" error path even though the handler existed and its
tests were green. "Served by the real binary" is part of the slice's
definition of done, not an ops detail.Steps 3–7 each end in green commits with layer-scoped subjects
(pricing/domain:, pricing/port:, pricing/http:), so the history reads
as the slice assembling.
If the capability has no slices yet, do NOT pick a meaty behavior first. Pick the thinnest behavior that still touches every layer (a tracer bullet: "GET returns the stored entity's name") and drive it through steps 1–9. This forces every wiring, serialization, and composition decision while the stakes are one field, not a business rule. Slice two onward is then mostly Zone 1/4 work hanging off proven plumbing — which is also where the walking skeleton pays off for sessions: later slices fit in one session; the skeleton is the one that may not.
Vec<Commit> vs commit-plus-files)
are two methods, not one method with a kind enum. And when the real
method lands, DELETE the placeholder enum arm — no second way to do it.list method —
one port change, every consumer inherits — never copied into each
caller.select/narrow function in the use case beats a new port method.A slice isn't closed until its reusable seams are written down where the next session will find them (memory-discipline, seam-catalog genre): each new port method, shared mapper, or extracted core, by path and signature, with an imperative consumer note — "future file browsing MUST drive through this, not a new method." The next slice is built by a session that wasn't there; the seam memo is the difference between reuse and reinvention. Shared-code extraction discovered mid-slice (two handlers growing the same row logic) happens in the REFACTOR step and goes in the memo too.
When the slice replaces something rather than adding it, the grammar changes: land the new code consumer-free, swap consumers one commit at a time, delete duplicates with the last swap; or expand–migrate–contract for data-shape changes. The full sequencing patterns, legacy-bridge labeling, and fractional-slice convention are in refactoring-campaign — use that skill the moment a slice's diff is mostly deletions of an old shape.
A capability covering N distinct behaviors/endpoints is N slices. Split at pickup time, not in upfront planning — by then the seams are visible. One behavior = one child work item = full test layers. Mid-flight rescoping is normal: when a slice turns out to be two things, split again and ship the shippable half (see tracker-discipline). The parent stays open until the last child closes, and tracks which child blocks it.
A slice frequently outlives a session. The handoff (session-lifecycle) carries a layer map for the in-flight slice in the bead/HANDOFF.md:
REQ-SALE-007 [spec ✓] [acceptance WIP ✓] [domain ✓] [port+fake ✓]
[usecase ▶ next: scenario 'discount on empty cart']
[adapters –] [web –] [wire-up –]The inner loop's "never end mid-red" holds per session because the WIP test is ignored: the suite is green at every handoff even though the slice isn't done. That's the whole point of the convention.
igouss/gitweb-rs
9ef2429
If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.