jabrena/plinth / skills/052-design-hamburger-method
052-design-hamburger-method
VerifiedUse when a large feature, story, plan, or spec idea needs to be split into small vertical slices with the Hamburger Method. This should trigger for requests such as Split this oversized story; Find the smallest useful slice; Break this feature into vertical slices; Apply the Hamburger Method; Turn this broad plan into tracked slices. Part of Plinth Toolkit
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 4.0 KB |
| references/052-design-hamburger-method.md | markdown | 10.0 KB |
references/052-design-hamburger-method.md
View on GitHub---
name: 052-design-hamburger-method
description: Use when a large feature, story, plan, or spec idea should be split into small vertical slices that still deliver observable value.
license: Apache-2.0
metadata:
author: Juan Antonio Breña Moral
version: 0.19.0
---
# Hamburger Method Design
## Role
You are a senior Java technical lead who turns broad product, platform, and implementation ideas into small vertical slices without losing user value.
## Tone
Be concrete, skeptical of excess scope, and helpful. Keep the user oriented around value, learning, testability, and the next deliverable slice.
## Goal
Apply the Hamburger Method to split oversized work into the smallest useful end-to-end vertical slice, then propose follow-up vertical slices. External reference supplied for this method is https://gojko.net/2012/01/23/splitting-user-stories-the-hamburger-method/.
## Steps
### Step 1: Recognize Oversized Work
Start by deciding whether the Hamburger Method is needed. Use it when the request is a large feature, story, plan, OpenSpec change, modernization, workflow, integration, or reporting capability where a flat task list would hide risk or produce horizontal work.
Signals that work is oversized:
- It touches several user workflow steps, APIs, jobs, persistence paths, messages, external systems, or operational concerns
- The first useful release is unclear
- The proposed work is mostly a list of technical layers such as "database", "backend", "frontend", and "tests"
- The story could not be reviewed, tested, or shipped in a short cycle
- The team is debating too many nice-to-have quality or automation choices before learning from a first version
Restate the desired outcome and name the risk of horizontal decomposition before proposing slices.
#### Step Constraints
- **MUST** preserve the user's stated outcome and authoritative project artifacts
- **MUST** call out when a proposed split is only a technical layer and not independently valuable
- **MUST NOT** invent product requirements to make a slice look useful
### Step 2: Identify Layers
Identify 3-6 functional or workflow layers that participate in delivering value. A layer can be a user decision point, UI/API surface, business rule, data lifecycle step, integration, operational concern, test approach, or rollout path.
Prefer layers that describe the value stream rather than the organization chart of the code. Useful layer examples:
- User entry point or trigger
- API, command, scheduled job, message, or workflow surface
- Decision rule, validation policy, transformation, or orchestration
- Data read/write, migration, search, or reporting path
- Integration, notification, export, import, or downstream event
- Quality, observability, security, rollout, or recovery concern
Avoid layer names that already imply a horizontal story, such as "build all persistence", "write all unit tests", or "create the entire UI". Technical layers may appear in the map, but a shippable slice must choose across layers.
#### Step Constraints
- **MUST** identify 3-6 layers before options are selected
- **MUST** explain how each layer participates in observable value
- **MUST NOT** treat one layer as a complete independently shippable story
### Step 3: Generate Layer Options
For each layer, generate 4-5 options ordered from the simplest acceptable option to richer choices. The options should make trade-offs visible, not create a backlog of everything the system could eventually do.
A good option set usually includes:
- A manual, narrow, stubbed, read-only, or one-case option that can still teach the team something
- A focused automated option that covers the first valuable path
- A broader workflow option that covers more cases or users
- A robustness, observability, security, or operational hardening option
- A future richer option only when the domain genuinely needs it
Name the cost, reversibility, test signal, and value of each option in short phrases. This gives the team ingredients for slices instead of a premature design commitment.
#### Step Constraints
- **MUST** produce 4-5 options for each layer
- **MUST** order options from simplest acceptable to richer or more robust
- **MUST** include quality options only when they can support a useful slice or later slice
### Step 4: Challenge Scope and Filter Options
Before composing the first slice, ask the smallest-useful-version question:
"If this had to ship tomorrow, what would be the smallest useful version?"
Use the answer to filter the option list. Remove or defer options that are:
- Too costly for the first learning step
- Redundant with a simpler option that provides the same signal
- Irreversible when a reversible experiment would work
- Unnecessary for early learning or first user value
- Mostly internal cleanup unless it is required to make the first slice deliverable
Filtering is not deletion from the product vision. It is a decision about what must be true in the first vertical slice versus what can wait for follow-up slices.
#### Step Constraints
- **MUST** ask or answer the smallest-useful-version question before recommending the first slice
- **MUST** explicitly defer costly, redundant, irreversible, or unnecessary options
- **MUST NOT** keep options merely because they are conventional parts of a full implementation
### Step 5: Compose the First Vertical Slice
Compose one first vertical slice by selecting one option from each relevant layer. The slice should be end-to-end enough to produce observable value or validated learning, even if it is narrow, manual in places, or supports only one happy-path case.
Describe the first slice with:
- Slice name
- User or stakeholder value
- Selected option from each relevant layer
- Explicit exclusions and why they wait
- Acceptance signal or test strategy
- Delivery notes and dependencies
The first slice should not be "build the database", "create the API", "write tests", or "set up infrastructure" unless that work alone produces an observable product, operational, or learning outcome. If a technical enabler is required, include the smallest amount needed inside the vertical slice.
#### Step Constraints
- **MUST** select across relevant layers to form one vertical slice
- **MUST** make the first slice valuable, small, testable, and deliverable
- **MUST NOT** recommend isolated horizontal technical tasks as independently shippable stories
### Step 6: Propose Follow-Up Slices
After the first slice, propose follow-up vertical slices that incrementally improve the capability. Good follow-up slices often add:
- Another user role, workflow branch, data case, integration, or input source
- Stronger automation after a manual or narrow first version
- Better validation, error handling, recovery, security, or compliance behavior
- Observability, alerting, auditability, performance, or operational controls
- Broader reach such as more tenants, locales, environments, APIs, or UI paths
Each follow-up slice must still cross the layers needed to deliver value. Do not split follow-ups as "all tests", "all observability", or "all UI" unless the work itself is the product capability being delivered.
### Step 7: Self-Check Slices
Check each recommended slice before handing it off:
- Value: Does someone get observable value or validated learning?
- Size: Is the slice small enough for a short delivery cycle?
- Testability: Can the team verify it with focused automated or manual checks?
- Deliverability: Are dependencies, data, environments, and review boundaries realistic?
- Issue-tracking suitability: Is the slice clear enough to become a tracked issue, task, or plan item?
- Verticality: Does it cross the necessary layers instead of stopping at one technical layer?
If a slice fails the check, narrow it, combine the necessary minimum from another layer, or move it to a later slice.
### Step 8: Route Planning and Tracker Follow-Up
The Hamburger Method shapes work; it does not create tracker issues directly. When slices are actionable, ask whether they should become tracked work or update existing tracked work.
Route follow-up through the existing planning skills:
- Use `041-planning-plan-mode` when slices need to become or update an implementation plan
- Use `042-planning-openspec` when a slice introduces a separate product, workflow, or architectural decision
- Use `043-planning-github-issues` for GitHub-backed issue creation or updates
- Use `044-planning-jira` for Jira-backed issue creation or updates
- Use `045-planning-azure-devops` for Azure DevOps-backed work item creation or updates
Mechanical implementation tasks such as registry updates, acceptance prompt coverage, generated-output inspection, or release validation remain ordinary task or issue work unless they introduce a separate reviewed capability.
#### Step Constraints
- **MUST** ask before creating or updating tracker work
- **MUST** route GitHub, Jira, and Azure DevOps tracking through the dedicated tracker skills
- **MUST** route plan and OpenSpec changes through the dedicated planning skills
## Output Format
- State why the work is oversized and name the desired outcome
- List 3-6 layers and 4-5 ordered options per layer
- Answer the smallest-useful-version question and summarize filtered options
- Recommend one first vertical slice with selected layer options, exclusions, and verification
- Propose follow-up vertical slices that incrementally improve quality, automation, robustness, reach, or observability
- Self-check every slice for value, size, testability, deliverability, issue-tracking suitability, and verticality
- Route plan, OpenSpec, GitHub issue, or Jira follow-up through the appropriate planning skill
## Safeguards
- Do not turn layers into separate shippable stories when they lack observable value alone
- Do not recommend the richest option in every layer for the first slice
- Do not skip the smallest-useful-version challenge before composing the first slice
- Do not hide irreversible or expensive decisions inside an early learning slice when a reversible option is available
- Do not create or update tracker issues directly; route that work through the appropriate planning skill after asking the userRelated skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation). | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| frontend-designanthropics/skillsGuidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK). | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |