Skip to main content
skill CX Codex

052-design-hamburger-method — Claude Code skill: setup and use

052-design-hamburger-method splits oversized user stories and specs into thin vertical slices using the Hamburger Method. Delivers end-to-end observable value instead of isolated technical tasks.

Apache-2.0 172 installs ★ 465 updated 2026-10-21

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add jabrena/plinth --skill 052-design-hamburger-method -a claude-code
Open on GitHub

What 052-design-hamburger-method does

This interactive skill walks engineers through the Hamburger Method to break down bloated features. It maps three to six workflow layers needed for a capability, then lists four or five implementation options per layer, sorted from the plainest acceptable choice to richer variants. By testing the scope against the question of what could ship tomorrow, it trims costly or irreversible choices to form a tiny end-to-end slice.

Horizontal technical assignments are barred from becoming standalone stories. Slices must cut through the full stack and deliver visible user progress. Skipping references/052-design-hamburger-method.md prevents the workflow from running.

Once slices are verified for testability and tracking, the skill routes them directly into companion Plinth skills: 043-planning-github-issues for GitHub, 044-planning-jira for Jira, and 042-planning-openspec for formal specifications.

What it helps with

  • Split an oversized feature into thin end-to-end vertical slices
  • Define the smallest useful release candidate for tomorrow
  • Eliminate redundant or costly architecture options early
  • Format decomposed work items for Jira, GitHub issues, or Azure DevOps

Example prompts for the agent

  • Apply the Hamburger Method to split this oversized story
  • Find the smallest useful slice for this user profile feature
  • Turn this broad spec into tracked vertical slices instead of horizontal tasks

How to install 052-design-hamburger-method

1Skills CLI (Vercel)

npx skills add jabrena/plinth --skill 052-design-hamburger-method -a claude-code

2Manually: put the files in place

~/.claude/skills/052-design-hamburger-method/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/052-design-hamburger-method/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about 052-design-hamburger-method

How to install 052-design-hamburger-method in Claude Code?

Run npx skills add jabrena/plinth --skill 052-design-hamburger-method -a claude-code in your terminal. The file is placed into ~/.claude/skills/052-design-hamburger-method/SKILL.md.

What does this skill prevent during decomposition?

It strictly forbids outputting single-tier technical chores, such as isolated database migrations or frontend-only stubs, as shippable stories.

Which planning tools does this skill connect with?

It routes parsed work items into other Plinth skills: 041-planning-plan-mode, 042-planning-openspec, 043-planning-github-issues, 044-planning-jira, and 045-planning-azure-devops.

Source text

SKILL.md · Apache-2.0
---
name: 052-design-hamburger-method
description: Use 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
license: Apache-2.0
metadata:
  author: Juan Antonio Breña Moral
  version: 0.19.0
---
# Hamburger Method Design

Guide Java teams through the Hamburger Method for splitting oversized work into small, valuable, end-to-end vertical slices. **This is an interactive SKILL**.

**What is covered in this Skill?**

- Recognizing oversized feature, story, plan, or spec work
- Identifying 3-6 functional or workflow layers that participate in delivering value
- Generating 4-5 implementation or quality options per layer
- Challenging scope with the smallest useful version question
- Filtering options that are too costly, redundant, irreversible, or unnecessary for early learning
- Composing one first vertical slice and follow-up slices
- Self-checking value, size, testability, deliverability, and issue-tracking suitability
- Routing plan, OpenSpec, GitHub issue, and Jira follow-up through the existing planning skills

## Constraints

Split oversized work into vertical slices that deliver observable value, not isolated horizontal technical tasks.

- **MUST** read `references/052-design-hamburger-method.md` before applying the method
- **MUST** identify 3-6 functional or workflow layers before selecting a slice
- **MUST** generate 4-5 options per layer, ordered from simplest acceptable option to richer options
- **MUST** challenge scope with the smallest-useful-version question before recommending a first slice
- **MUST** filter costly, redundant, irreversible, or unnecessary options before composing the first slice
- **MUST** keep recommended work as vertical slices that deliver observable value
- **MUST NOT** present isolated technical layers as independently shippable stories

## When to use this skill

- Apply the Hamburger Method
- Split this oversized story
- Find the smallest useful slice
- Break this feature into vertical slices
- Turn this broad plan into tracked slices
- This feature is too large

## Workflow

1. **Recognize Oversized Work**

Read `references/052-design-hamburger-method.md`, then restate the large feature, story, plan, or spec idea and why ordinary implementation task decomposition would be too broad, risky, or horizontal.

2. **Map Layers and Options**

Identify 3-6 functional or workflow layers needed for observable value. For each layer, generate 4-5 implementation or quality options ordered from the simplest acceptable choice to richer choices.

3. **Challenge Scope**

Ask: "If this had to ship tomorrow, what would be the smallest useful version?" Use the answer to remove options that are too costly, redundant, irreversible, or unnecessary for early learning.

4. **Compose the First Slice**

Select one option from each relevant layer to create the smallest useful end-to-end vertical slice. Explain the user-visible value, validation signal, and why rejected layer options wait for later slices.

5. **Plan Follow-Up Slices**

Propose follow-up vertical slices that incrementally improve quality, automation, robustness, reach, observability, operational behavior, or supported workflows without turning them into isolated technical layers.

6. **Self-Check and Route Follow-Up**

Check every slice for value, size, testability, deliverability, and issue-tracking suitability. Route implementation planning through `041-planning-plan-mode`, spec-level changes through `042-planning-openspec`, GitHub issue work through `043-planning-github-issues`, Jira work through `044-planning-jira`, and Azure DevOps work through `045-planning-azure-devops`.

## Reference

For detailed guidance, examples, and constraints, see [references/052-design-hamburger-method.md](references/052-design-hamburger-method.md).

© Juan Antonio Breña Moral · Apache-2.0 · jabrena/plinth

Similar skills

All skills for Notes, tasks and projects →

From the same set123

The whole set →
054-design-tdd 054-design-tdd — a skill that walks Java developers through red-green-refactor cycles with test-driven development. Write a failing test first, implement just enough code to pass, then refactor while tests stay green. CX Codex +1 177installs 707-technologies-hexagonal-architecture 707-technologies-hexagonal-architecture is a Claude Code skill that reviews and improves Hexagonal architecture boundaries in Java projects without coupling to Spring Boot, Quarkus, or Micronaut. CX Codex +1 174installs 056-design-avoid-breaking-changes 056-design-avoid-breaking-changes reviews plans, OpenSpec changes, and APIs for breaking changes and migration risks before release. CX Codex +1 172installs 055-design-parallel-change The 055-design-parallel-change skill guides you through designing safe database schema changes when old and new application versions must run simultaneously. It breaks complex migrations into three separately deployable phases. CX Codex +1 172installs 053-design-simple-rules 053-design-simple-rules is a Claude skill that checks Java design and refactoring decisions against Kent Beck's four rules, in order. CX Codex +1 172installs 057-design-feature-toggles 057-design-feature-toggles — an interactive skill for designing and reviewing feature toggles in Java services, including kill switches, staged rollouts, experiments, and cleanup. CX Codex +1 171installs 051-design-two-steps-methods The 051-design-two-steps-methods skill splits complex or risky code changes into two steps: first refactor to improve design while preserving behavior, then apply the intended behavior change. CX Codex +1 170installs 045-planning-azure-devops 045-planning-azure-devops manages Azure Boards work items via the Azure DevOps CLI. It verifies tool availability first and restricts query outputs strictly to IDs and counts. CX Codex +1 168installs

Project sponsors

Companies that keep this analytics open