메뉴
Load ONCE at planning (coordinator + specifier) to turn a PRD into right-sized vertical slices tagged produces/consumes/touches, derive the dependency DAG, and tag the spine. Load before any slice is dispatched.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
SOC 직업 분류 기준
Verify an implementer's diff with an INDEPENDENT, different-vendor sub-agent (diff plus contract only); turn blocking issues into fix-tasks and loop until clean.
Run independent subtasks in parallel — one git worktree and one implementation sub-agent per task, each opening its own PR — then cross-review every PR. maestro never merges; the human does.
Have the Claude and GPT partners critique each other's answers across a configurable number of rounds (default 1) before converging on a synthesis. Use when the user wants the two perspectives stress-tested against each other, not just shown side by side.
Load per slice — the COORDINATOR's 3-role dispatch sequence (specifier → coder → refactorer, SEPARATE sessions, a handback to the coordinator between each) that drives ONE vertical slice from a failing acceptance test to refactored green in a single worktree. Load for every slice the wavefront dispatches.
Load ONCE as the coordinator's orchestration loop after the DAG is built. Land the spine, then drive dependency-ordered waves of parallel independent slices until the DAG drains, and finish with the architect verification.
Load ONCE at the end — the final whole-feature join by a fresh architect at the integration HEAD. Run gates, mutation, and cross-slice DRY over the assembled feature and SIGN-OFF or BOUNCE, attributing each failure to its owning slice.
| name | slice-decompose-to-dag |
| description | Load ONCE at planning (coordinator + specifier) to turn a PRD into right-sized vertical slices tagged produces/consumes/touches, derive the dependency DAG, and tag the spine. Load before any slice is dispatched. |
Planning runs once, before any slice is dispatched. It produces the structure the whole build is driven from: a set of right-sized vertical slices, the edges between them, and the spine. The specifier is the coordinator's pair here; the coordinator owns the final DAG.
Inspect the target root (read-only) and record the stack + the EXACT gate commands the whole run will use, so workers never re-detect:
A slice is ONE externally-visible behavior, end to end. Tag each slice with:
produces — the contracts/interfaces/data this slice creates that others can
build on (a function signature, an endpoint, a schema, a module boundary).consumes — the contracts it needs to already exist.touches — the files it is expected to modify.A slice must fit comfortably in ONE worker session: a handful of files plus its behavior spec plus its acceptance test, implementable AND testable to green in a single context window. If a slice won't fit, SPLIT it into more slices. Never sub-delegate a slice to fan-out — splitting, not sub-delegating, is how the work is bounded.
A -> B exists IFF B.consumes ∩ A.produces is non-empty (B needs a
contract A produces).touches ∩ touches) is NOT an edge. It is a MERGE COST, resolved
at integration — never a reason to serialize two otherwise-independent slices.Mark a slice as spine when it either:
Do not guess contracts. Use the investigate skill to read the target repo so
produces/consumes reflect the actual interfaces a slice will create or call.
A DAG built on guessed edges either over-serializes (false dependencies) or
breaks at integration (missed ones).