| name | bokata-feature-slicer |
| description | Slices a Feature into a Walking Skeleton and Increments Backlog — a ready-to-implement delivery plan. Internal phases (Steps and Incremental Options) are used as reasoning but not surfaced by default. Use this skill whenever you need to break down a Feature into implementable work — after generating a Features Backbone, when planning a sprint, or when a user asks to slice, decompose, or plan implementation of a feature. |
Bokata Feature Slicer
Unified skill for slicing a Feature into deployable increments. Takes a Feature from the Features Backbone and produces a Walking Skeleton + Increments Backlog ready to implement.
Default output: Walking Skeleton + Increments Backlog (Phase 3 only)
Optional: pass --show-steps, --show-increments, or --show-all in arguments to surface intermediate phases.
Quick Start
Standalone use: Can be invoked directly with a feature description + technical context. No prior pipeline required.
- Understand the Feature to slice from the provided input — any form works (plain text, backbone section, feature-context.md, or conversation context)
- Select target Feature to slice
- (Optional) Enrich with a slicer research summary and discovery context if not already present
- Phase 1 (internal): Decompose User Tasks into Steps → Instructions
- Phase 2 (internal): Generate Incremental Options per Step → Instructions
- Phase 3 (output): Synthesize Walking Skeleton + Increments Backlog → Instructions
Phases 1 and 2 are internal reasoning steps — do them thoroughly but only surface their output if the user explicitly requests it.
Prerequisites
A Feature to slice — described in any form:
- Plain text or conversation context
- Features Backbone with Features and User Tasks defined
feature-context.md content (contains backbone + criteria research already consolidated)
Optionally, Acceptance Criteria enrich the decomposition.
Optionally enriched by any context containing:
- Codebase patterns, libraries, and architecture constraints (e.g.
## Slicer Research Summary: [Feature]) — recommended
- Domain vocabulary and actors (e.g.
## Feature Research Summary) — for consistent naming across increments
- Business rules (e.g.
## Criteria Research Summary) — rules that affect which increment options are acceptable
- Technical clarifications (e.g.
## Discovery Context — Slicer: [Feature]) — layer and scope decisions from Phase 0
Note: All enrichment is recommended but not blocking — proceed without it if absent.
Phase 0 — Discovery
Skip this phase entirely if a ## Discovery Context — Slicer: [Feature] section (or an orchestrator's equivalent consolidated discovery context) is already present in the input — proceed directly to ## YOUR TASK using that context.
Think (as an expert tech lead in discovery):
Before decomposing, scan the Feature and its User Tasks for gaps that would produce wrong steps or increment options:
- Technical clarity: Are the User Tasks specific enough to decompose into layers? Any vague actions?
- Layer ambiguity: Are any steps unclear about which layer they belong to (UI vs Logic vs Data)?
- Increment scope: Are any User Tasks too large to slice meaningfully without clarification?
- Dependencies: Are there unspecified technical dependencies between User Tasks?
- Constraints: Are there architectural or performance constraints that affect which increment options are viable?
Only ask about gaps where the answer would change a Step or an Increment option. If the input is clear, don't ask.
Execute:
- List ambiguities internally
- Filter to only high-value questions (answer changes a Step or an Increment option)
- Group questions by theme (Technical Clarity, Layer Ambiguity, Increment Scope, Dependencies, Constraints)
- Present questions to the user using the format below
CRITICAL: Do not skip. Stop here and wait for user answers before producing any output.
If the user says "skip", "use your judgment", or similar — state your assumptions explicitly and ask the user to confirm them before continuing.
- State assumptions you are making for gaps you are NOT questioning
Format for questions:
## Clarification Questions — [Feature Name]
**Technical Clarity**
- [Question about a vague User Task or unclear action]
**Layer Ambiguity**
- [Question about which layer a step belongs to]
**Increment Scope**
- [Question about whether a User Task needs to be split further]
**Dependencies & Constraints**
- [Question about technical dependencies or architectural constraints]
**Assumptions I'm making (not asking):**
- [Assumption 1 — reason it's safe to assume given the context]
- [Assumption 2]
After receiving user answers, produce a ## Discovery Context — Slicer: [Feature Name] section with:
- Technical clarifications: Resolved ambiguities about User Task scope and layer assignment
- Layer decisions: Which layer each ambiguous step belongs to, as clarified
- Increment boundaries: Confirmed scope for User Tasks that needed clarification
- Dependencies confirmed: Technical dependencies between tasks or external systems
- Constraints noted: Architectural or performance constraints that affect slicing
- Assumptions: Any remaining assumptions made where questions were not raised
YOUR TASK
Read the provided input and:
-
Prerequisite Check:
- Verify you understand what Feature and User Tasks to slice — extract from input in any form; if no feature information is present at all, ask the user
- Optionally check for Acceptance Criteria — if missing, proceed without them
-
Phase 1 — Steps (internal):
Follow instructions in Phase 1: Step Analysis
- Decompose each User Task into functional Steps (UI → Logic → Data → Integration)
- Do this work internally — don't output Phase 1 results unless
--show-steps or --show-all was requested
-
Phase 2 — Increments (internal):
Follow instructions in Phase 2: Incremental Options
- Generate 3+ Incremental Options per Step using breakdown strategies
- Do this work internally — don't output Phase 2 results unless
--show-increments or --show-all was requested
-
Phase 3 — Walking Skeleton + Increments Backlog (output):
Follow instructions in Phase 3: Vertical Slices
- Identify Walking Skeleton (simplest end-to-end options, buildable in 1-3 days)
- Organize remaining increments into a backlog
- This is always the output — produce it regardless of args
Execution Flow
Input: Feature description (any form)
│
▼
┌─────────────────────┐
│ Phase 1: Steps │ ← internal reasoning
│ (Decompose Tasks) │
└────────┬────────────┘
│
▼
┌─────────────────────┐
│ Phase 2: Increments │ ← internal reasoning
│ (Generate Options) │
└────────┬────────────┘
│
▼
┌─────────────────────┐
│ Phase 3: Output │ ← surfaced to user
│ Walking Skeleton │
│ + Backlog │
└─────────────────────┘
Resources
Output Checklist
Phase 3 — Walking Skeleton + Backlog (always verify before outputting):
Internal verification (before Phase 3 synthesis):
Upstream Inputs (verify before starting):
NEXT STEPS
After completing the slicing:
- Save output — The user decides where to save
- Validate — Check output against the Output Checklist above
- Implement — Start with Walking Skeleton items, then pick increments from the backlog
