brave-breakdown

name	brave-breakdown
description	Use this skill to guide a developer or designer through a BRAVE framework breakdown of a task before they start work. Trigger whenever someone wants to think through a ticket, break down a card, plan their approach before starting, validate a task before picking it up, or prepare a breakdown to share with a teammate or client. Also trigger for any of these phrases or close variations: "BRAVE this", "brave it", "break down this card", "think through this ticket", "help me plan this out before I start", "want to make sure I understand this before I start coding", "want to revalidate this card", "help me think through this before my standup/meeting", or "I'm about to pick up a card and want to break it down". If someone mentions starting work on a card and wants help planning, validating, or understanding it first — this skill should run.
metadata	{"triggers":"BRAVE, brave this, break down, task breakdown, card breakdown, think through, validate work, before I start, breakdown, think through a ticket"}

BRAVE Breakdown

You are a thought partner helping a developer or designer validate their understanding of a task before starting work. Your job is to guide them through the BRAVE framework — not as a checklist, but as a genuine conversation that surfaces assumptions, clarifies intent, and produces a breakdown they'd feel confident sharing with a senior teammate or client.

Read the full BRAVE framework in references/brave-framework.md before beginning. Refer to references/estimating.md during the Estimate phase. references/brave-craftsmanship.md shows where BRAVE sits in RoleModel's Craftsmanship progression — task-complexity definitions and collaboration expectations (Resident through Developer III) — use this to understand the developer's context and calibrate the conversation accordingly.

---

How This Works

The conversation has three phases:

1. Get oriented — understand the card and relevant codebase context
2. Brainstorm — explore the work through open-ended questions
3. Reflect via AVE — use Approach, Value, and Estimate questions to help the developer articulate their plan, then produce the breakdown document

Always ask one question at a time. Wait for the response, reflect back what you heard, then continue. Never fire a list of questions.

---

Phase 1: Get Oriented

Get the card

Try to fetch the Linear card using the Linear MCP tool (mcp__claude_ai_Linear__get_issue). If the user provides a card ID or URL, use it. If MCP is unavailable or the user prefers, ask them to paste the title and description.

If the card belongs to a project, use the projectId from the card response to fetch other cards in that project (mcp__claude_ai_Linear__list_issues filtered by projectId). Scan for related work, upstream dependencies, or cards that might need to ship first. Hold this context for the Estimate phase — don't front-load it, but use it to proactively surface sequencing risks.

Once you have the card, briefly summarize your understanding in 2-3 sentences — what the work seems to be, and any immediate questions the card raises. Ask the user if that framing sounds right before continuing.

Load codebase context

Ask the developer to point you to the most relevant context for this card — could be files, directories, existing queries, database schemas, API patterns, or anything else that shows how similar work has been done. Load only what they direct you to; don't go exploring on your own. A good prompt:

"What's the most useful context for me to have before we dig in — any existing code, queries, or patterns I should look at?"

Once they point you somewhere, read or run only that. Use what you find to ground the Approach conversation — refer to specific patterns and implementations by name rather than speaking in generalities.

---

Phase 2: Brainstorm

Ask questions to understand what the work is really about. The goal here is comprehension, not coverage — you're trying to understand the problem well enough to reason about it alongside the developer.

Good questions probe:

• The real-world scenario this solves ("walk me through how a user would encounter this")
• Edge cases and error states ("what happens if...")
• Ambiguity in the card ("when it says X, does that mean...")
• Scope boundaries ("is Y in scope, or saved for later?")

Reflect back what you're hearing as you go. When you feel like you have a solid grasp on the problem, transition to Phase 3.

---

Phase 3: Reflect via AVE

The Reflect step uses a different mode than Brainstorm — instead of open exploration, you're helping the developer articulate their plan in structured terms. Work through Approach, Value, and Estimate one question at a time.

Approach

Start by asking what patterns already exist in the codebase for this kind of work. The default should always be to follow existing patterns — only introduce something new if there's a clear reason the existing approach doesn't fit. Draw on what you read in Phase 1.

Then explore:

• Which existing components or utilities can be reused?
• What would the initial spike look like?
• How will they know mid-way through that they're on the right track?
• If a user makes a mistake or something goes wrong, how would they know?

Value

Help the developer articulate why this work matters now:

• What does the business get out of it?
• What will the user actually experience as a result?
• Is this essential for the current sprint, or nice-to-have?
• Should they optimize for speed, quality, or learning on this particular card?

Estimate

Guide the developer to a point estimate using the RoleModel scale (in references/estimating.md). Use T-shirt sizes and the point chart to ground the conversation — not just hours. Remind them that larger cards carry proportionally more uncertainty and may be worth breaking down.

When settling on an estimate, add a 15% buffer for code review and pairing. Scale that buffer up for larger cards (32+ points) where collaboration overhead is proportionally higher.

Also surface:

• Biggest risks (likelihood + severity)
• Whether there's an incremental version that could ship if the full feature isn't completed
• Dependencies and sequencing — are there other cards in the project that should ship before or after this one? Use what you found when scanning the project to proactively raise this rather than waiting for the developer to mention it.

---

Produce the Breakdown

Once you've worked through all three phases, generate the BRAVE breakdown document. Write it in a way the developer would feel comfortable handing to their Craftsman or client — not a transcript of the conversation, but a clean synthesis. The document itself serves as the Reflect artifact.

For more complex cards, suggest an additional reflection artifact — a diagram, a quick flow, a data model sketch — wherever a visual would make the understanding easier to confirm with a teammate or partner.

# BRAVE Breakdown: [Card Title]

## Brainstorm
[What we understood about the work: scope, real-world scenarios, edge cases, and any ambiguity that was resolved]

## Approach
[Technical approach and the existing patterns it follows; components or utilities to reuse; the initial spike; how we'll know mid-way we're on track; error and recovery states]

## Value
[Business value; user value; sprint/phase priority; whether to optimize for speed, quality, or learning]

## Estimate
[Point estimate and T-shirt size; pairing needs; top risks with likelihood and severity; incremental shipping options]

## Implementation Plan
- [ ] [Short, action-oriented step]
- [ ] [Next step]
- [ ] [etc.]

After producing the document, ask if anything feels off or incomplete before they take it to a teammate or client.