Bokata Slicer CC


Intelligent vertical slicing and feature decomposition for Claude Code using the Hamburger Method and radical vertical slicing techniques.

🚀 Quick Start

$3

Option 1: NPM (Node.js projects)
``bash
npm install -D bokata-slicer-cc
npx bokata-slicer-cc install
`

Option 2: Claude Code Plugin (any project)
`
/plugin marketplace add abrahamvallez/bokata-slicer-cc
/plugin install bokata-slicer-cc
`

Option 3: Global
`bash
npm install -g bokata-slicer-cc
cd your-project
bokata-slicer-cc install
`

$3

Bokata v0.3.0 provides three complementary commands for different analysis needs:

1. Project Analysis (multiple features):
`
/bokata Project: E-commerce platform with catalog, cart, checkout, and orders
/bokata ./docs/project-requirements.md # Can also read from file
`

2. Single Feature Analysis:
`
/bokata-feature Feature: Coach Records Audio
/bokata-feature ./docs/feature-spec.md # Can also read from file
`

3. Implementation Strategies (optional, after running /bokata or /bokata-feature):
`
/bokata-iterations-paths # Generates 3-5 implementation path options
`

4. Selection Matrix (optional, after running /bokata or /bokata-feature):
`
/bokata-matrix # Generates complete increment matrix with dependencies
`

Output: Markdown documents in ./docs/slicing-analysis/

$3

1. Start with project or feature analysis:
- Use /bokata for projects with multiple features
- Use /bokata-feature for a single feature

2. Optionally generate implementation strategies:
- Run /bokata-iterations-paths to see 3-5 different implementation approaches

3. Optionally generate selection matrix:
- Run /bokata-matrix for complete dependency reference and custom path building

---

📖 What is Bokata Slicer CC?

Bokata Slicer CC automatically analyzes features or projects and generates:

Core Analysis (/bokata or /bokata-feature):
- ✅ Executive Summary - Quick stats and metrics
- ✅ Feature Breakdown - Complete steps and increments with dependencies
- ✅ Walking Skeleton - The absolute minimum implementation
- ✅ Dependency Analysis - What each increment requires and provides

Optional Analysis (separate commands):
- ✅ Implementation Paths (/bokata-iterations-paths) - 3-5 strategic options
- ✅ Selection Matrix (/bokata-matrix) - Complete increment catalog with dependencies

$3

Important: Core analysis documents (from /bokata and /bokata-feature) contain NO effort/value/risk scores. This is intentional:

- Core documents focus on dependencies and compatibility - What each increment needs and provides
- Use /bokata-iterations-paths for estimated timelines and implementation strategies
- Use /bokata-matrix for complete dependency reference and custom path building

This separation ensures core analysis remains clean and focused on deliverables, while strategic planning happens in dedicated commands.

$3

All features must follow the Actor + Action format for clarity and consistency:

Format: [Actor] [Action]

Valid Actors: User, Player, Coach, Admin, System, Customer, Manager, etc.

Examples:
- ✅ Good: "Coach Records Audio"
- ✅ Good: "User Resets Password"
- ✅ Good: "Admin Manages Users"
- ❌ Bad: "Audio Recording" (missing actor)
- ❌ Bad: "Password Reset Feature" (not actor-focused)
- ❌ Bad: "System for User Authentication" (too verbose)

This convention is enforced by all commands to maintain clarity throughout the analysis.

$3

As Kent Beck explains in "Augmented Coding: Beyond the Vibes", this approach:

- Prioritizes code quality over simple system behavior
- Maintains human control while leveraging AI speed
- Reduces "yak shaving" (tedious setup work)
- Enables more strategic programming decisions per hour
- Transforms programmers into strategic architects

---

🎯 How It Works

$3

Bokata v0.3.0 provides specialized commands for different analysis needs:

1. /bokata - Project Analysis
- Analyzes projects with multiple features
- Generates cross-feature Walking Skeleton
- Provides feature breakdown and dependencies
- No effort/value/risk scoring (dependencies only)

2. /bokata-feature - Single Feature Analysis
- Focused analysis of a single feature
- Generates feature-specific Walking Skeleton
- Detailed step and increment breakdown
- No effort/value/risk scoring (dependencies only)

3. /bokata-iterations-paths - Implementation Strategies
- Generates 3-5 implementation path options
- Includes estimated timelines
- Strategic recommendations based on priorities
- Run after /bokata or /bokata-feature

4. /bokata-matrix - Selection Matrix
- Complete increment catalog with dependencies
- Enables custom path building
- Detailed dependency reference
- Run after /bokata or /bokata-feature

$3

Step 1: Core Analysis (/bokata or /bokata-feature)
1. Feature Breakdown - Identifies all features in user journey
2. Steps Analysis - Decomposes into UI → Logic → Data steps
3. Increments Generation - Creates 5-10 deployable increments per step
4. Walking Skeleton - Suggests absolute minimum implementation
5. Dependency Analysis - What each increment requires and provides

Step 2: Optional Strategies (/bokata-iterations-paths)
6. Implementation Paths - 3-5 options based on priorities
7. Decision Framework - How to choose the right path
8. Timeline Estimates - Realistic delivery expectations

Step 3: Optional Matrix (/bokata-matrix)
9. Selection Matrix - Complete increment catalog
10. Dependency Reference - Detailed compatibility information
11. Custom Path Building - Mix and match increments

$3

Core Analysis Output (/bokata or /bokata-feature):
`markdown


Feature Name - Vertical Slicing Analysis

1. Executive Summary

[Quick stats and metrics - NO ESTIMATES]

2. Feature Breakdown

[Complete steps and increments with dependencies]

3. Walking Skeleton

[Minimum implementation with dependency rationale]

4. Dependency Analysis

[What each increment REQUIRES and PROVIDES]
`

Implementation Paths Output (/bokata-iterations-paths):
`markdown


Feature Name - Implementation Paths

1. Speed to Market (2-4 days)

[Fast path with timeline]

2. Balanced Approach (5-8 days)

[Balanced path with timeline]

3. Quality First (10-15 days)

[Quality path with timeline]

4. Decision Guide

[How to choose based on priorities]
`

Selection Matrix Output (/bokata-matrix):
`markdown


Feature Name - Selection Matrix

Complete Increment Catalog

[All increments with dependency details]

Compatibility Maps

[Which increments work together]

Custom Path Building Guide

[How to build your own path]
`

---

🔗 Dependency and Compatibility System (NEW in v0.2.0)

Every increment now explicitly specifies its dependencies and compatibility:

$3

Each increment defines:
`
REQUIRES: What external dependencies it needs (or "None" for zero-dependency paths)
PROVIDES: Capabilities it offers to other steps
COMPATIBLE WITH: Which increments from other steps it works with
`

$3

✅ Guaranteed Deployable Paths - Walking Skeleton is always a valid, complete E2E flow
✅ Coordinated Increments - All selected increments work together seamlessly
✅ Multiple Valid Options - Several implementation paths automatically identified
✅ Transparent Dependencies - Clear visibility of what each increment needs
✅ Automatic Validation - Incompatible combinations are detected and flagged

$3

`markdown
Step 1: UI Form
| Increment | Requires | Provides | Compatible With |
|-----------|----------|----------|-----------------|
| 1.1 Form (client) | None | User input | 2.1, 3.1 |
| 1.2 Form (API) | POST /api/save | HTTP request | 2.2, 2.3 |

Step 2: Backend
| Increment | Requires | Provides | Compatible With |
|-----------|----------|----------|-----------------|
| 2.1 None | None | Nothing | 1.1, 3.1 |
| 2.2 API endpoint | Database | POST /api/save | 1.2, 3.2 |

Step 3: Storage
| Increment | Requires | Provides | Compatible With |
|-----------|----------|----------|-----------------|
| 3.1 localStorage | None | Persistence | 1.1, 2.1 |
| 3.2 Supabase | Backend ready | Database | 1.2, 2.2 |

✅ Valid Paths:
- 1.1 + 2.1 + 3.1 (all client-side, zero dependencies)
- 1.2 + 2.2 + 3.2 (API + database, coordinated)
`

---

💡 Key Features

$3


- /bokata for multi-feature projects
- /bokata-feature for single feature analysis
- /bokata-iterations-paths for strategic planning
- /bokata-matrix for custom path building
- Each command focused on specific analysis type

$3

- Selects simplest increments across all steps
- Guarantees compatibility - all selected increments work together
- Validates that Walking Skeleton is deployable with zero external dependencies
- Answers: "What would we ship if deadline was tomorrow?"

$3

- Automatic detection of incompatible increment combinations
- Clear mapping of what each increment requires and provides
- Multiple valid paths automatically identified and coordinated
- Transparent dependency analysis in generated documents
- Central to core analysis - no effort/value/risk distractions

$3

- Speed: Fastest to next deployment
- Balanced: Speed + quality mix
- Quality: Polished experience
- Feature-by-Feature: Complete one feature at a time (projects)
- Cross-Feature: Improve one aspect across all features (projects)
- All paths use compatible increments across features
- Generated by /bokata-iterations-paths command

$3

- Priority-based recommendations
- Pros/cons for each path
- Real-world scenarios
- Red flags and anti-patterns
- Generated by /bokata-iterations-paths command

$3

- Selection matrix with all increments
- Dependency information for each increment
- Compatibility constraints clearly shown
- Sprint planning guidance
- Generated by /bokata-matrix command

$3

- Markdown format with dependency tables
- Includes dependency analysis section
- Shareable with team
- Ready for implementation
- Version controlled
- Clean separation between core analysis and strategic planning

---

📚 Documentation

- INSTALL.md - Complete installation guide
- CLAUDE.md - Full usage guide and command reference
- CONTRIBUTING.md - Development and contribution guide
- Agents Documentation - Technical details

---

🏗️ Architecture

$3

- /bokata - Project analysis (multiple features)
- /bokata-feature - Single feature analysis
- /bokata-iterations-paths - Implementation strategies
- /bokata-matrix - Selection matrix and dependencies

$3

- project-analyzer - Multi-feature projects
- feature-analyzer - Single feature analysis
- iteration-planner - Implementation paths
- matrix-generator - Selection matrix

$3

- feature-backbone-specialist - Feature identification
- step-analyzer-specialist - Steps decomposition
- increment-generator-specialist - Increments generation
- path-composer-specialist - Walking Skeleton composition
- doc-generator - Documentation generation

---

🎓 Methodology

$3

Every slice must:
- ✅ Answer: "What would we ship if the deadline was tomorrow?"
- ✅ Cut through all technical layers (UI → Logic → Data)
- ✅ Deliver real, observable value to the user
- ✅ Build the smallest that works, not the "best" version first
- ✅ Can be deployed independently
- ✅ Enable early feedback

$3

20+ strategies including:
- Start with outputs - Begin with visible results
- Zero/One/Many progression - Hardcode → single → multiple
- Dummy to dynamic - Static → configurable → dynamic
- Workflow simplification - Skip optional steps
- User segment narrowing - Target specific user type
- Capacity-based splitting - Limit initial capacity
- Extract basic utility - Core functionality only
- Defer edge cases - Handle happy path first
- Manual before automated - Automation comes later
- And more...

Note: These strategies are applied during increment generation in core analysis. Timeline estimates are only provided in the /bokata-iterations-paths output.

---

📊 Example Usage

$3

Input:
`
/bokata-feature Feature: User Exports Data to CSV
`

Core Analysis Output:
- 3 steps identified
- 18 increments generated
- Walking Skeleton: 3 increments (dependencies specified)
- Output: user-exports-data-2025-10-28.md
- No timeline estimates (dependencies only)

Optional Follow-up:
`
/bokata-iterations-paths # Get 3 implementation paths with timelines
/bokata-matrix # Get complete selection matrix
`

$3

Input:
`
/bokata-feature Feature: Coach Records Audio

Context: Mobile app, first time using audio APIs
Priorities: Speed to market, need validation
`

Core Analysis Output:
- 6 steps identified
- 42 increments generated
- Walking Skeleton: 6 increments (all compatible, zero external dependencies)
- Output: coach-records-audio-2025-10-28.md
- Dependency analysis included

Optional Follow-up:
`
/bokata-iterations-paths # Get 3 paths: Speed, Balanced, Quality (with timelines)
/bokata-matrix # Get full increment catalog with dependencies
`

$3

Input:
`
/bokata Project: Task management app for remote teams

Features:
- User Creates Projects
- User Adds Tasks
- User Tracks Progress
- Team Collaborates

Tech: React + Node.js
`

Core Analysis Output:
- 4 features identified (using Actor+Action format)
- 16 steps across features
- 96 total increments
- Walking Skeleton: 4 increments (cross-feature compatible)
- Output: task-management-app-2025-10-28.md
- Complete dependency analysis

Optional Follow-up:
`
/bokata-iterations-paths # Get 5 paths including Feature-by-Feature and Cross-Feature
/bokata-matrix # Get complete project matrix
`

$3

Input:
`
/bokata ./docs/project-requirements.md
/bokata-feature ./docs/feature-spec.md
`

Benefits:
- Parse existing PRDs and specifications
- Maintain documentation in version control
- Consistent analysis from documented requirements

---

🤝 Contributing

We welcome contributions! This project is licensed under GPL-3.0, which means:

- ✅ You can use, modify and distribute freely
- ✅ You must maintain the same license in derivative works
- ✅ You must include the original copyright notice
- ✅ Any improvements benefit the entire community

To contribute:

1. Fork the repository
2. Create a branch for your feature
3. Follow existing structure and documentation
4. Submit a Pull Request with detailed description

See CONTRIBUTING.md for development setup and guidelines.

License

This project is licensed under the GNU General Public License v3.0.

`
Copyright (C) 2025 Abraham Vallez

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
``

---

📚 Additional Resources

- Augmented Coding: Beyond the Vibes - Kent Beck
- INSTALL.md - Installation guide
- CLAUDE.md - Full command reference
- Agents documentation - Technical details

---

💬 Support

- Issues: Report bugs or request features
- Discussions: Ask questions or share ideas

---

🌟 Show Your Support

If Bokata Slicer CC helps your team, consider:
- ⭐ Starring this repository
- 🐛 Reporting issues
- 🤝 Contributing improvements
- 📢 Sharing with your network

---

Built with ❤️ using Augmented Coding principles

Happy slicing! 🍔⚡