Bmad Handoff logo

Bmad Handoff

Community
aj-geddes
bmad-handoff

Emits a dev-tool-agnostic handoff manifest from ready-for-dev stories so an external dev plugin or runner can pick up and execute the work. Use when the user says "generate a handoff", "create handoff manifest", "export stories for dev", "hand off to dev tool", "produce handoff manifest", "ready to hand off", "prepare handoff for external tool", "export ready-for-dev stories", or "create the handoff package". Also trigger when the user asks "what stories are ready for dev?" and wants an exportable artifact rather than a status report. Produces: handoff-manifest.json listing all ready-for-dev stories with id, story file path, status, owned file/module scope, wave/parallel_set, dependencies, acceptance-criteria summary, locked-sections note, and a schemaVersion field. See REFERENCE.md (bundled) for the full manifest schema and adapter notes for git-worktree parallel development and autonomous dependency-graph orchestrators.

Overview

Publisheraj-geddes
Repositoryclaude-code-bmad-skills
Skill namebmad-handoff
Stars
492
Forks
77
Bundled files
3
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 3 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by aj-geddes on GitHub. Read the source before you install it.

Installation

Install the Bmad Handoff AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/aj-geddes/claude-code-bmad-skills/tree/main/bmad-planning-orchestrator/skills/bmad-handoff
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/aj-geddes/claude-code-bmad-skills.git /tmp/claude-code-bmad-skills
mkdir -p .claude/skills
cp -r /tmp/claude-code-bmad-skills/bmad-planning-orchestrator/skills/bmad-handoff .claude/skills/bmad-handoff
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Bmad Handoff in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Bmad Handoff on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Bmad Handoff is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

BMAD Handoff

Purpose: Scan the planning output folder for all stories at status ready-for-dev, compile them into a single handoff-manifest.json, and leave it where any downstream dev tool can read it — without coupling to any specific runner.

This is the last artifact the planning plugin produces. What happens next is owned by the external dev tool, not by this skill.

When to Run

Run this skill after the story-writing phase is complete and you (or the user) have confirmed that at least one story carries status ready-for-dev. The manifest is a point-in-time snapshot; re-run the skill to refresh it.

Workflow

Use TodoWrite to track progress through these steps.

1. Locate the output folder

Look for bmad-output/project-context.md (the default output folder) or ask the user for the output folder. Default: bmad-output/.

2. Discover story files

Glob for **/{epic}.{story}.*.story.md under the output folder. Accept alternative flat layouts (stories/*.story.md) if the glob turns up nothing.

3. Filter to ready-for-dev

Read the **Status:** header field of each story file (in the story header block, not a ## Status heading). Include only stories whose status value is exactly ready-for-dev.

If none are found, report which statuses were seen and stop — do not produce an empty manifest.

4. Extract per-story fields

For each qualifying story file, extract:

FieldSource in story file
idFilename stem or ## Story heading ID
storyFilePathRelative path from project root
status**Status:** header field value
epicFirst segment of filename, e.g. "2" in 2.1.stripe.story.md
storyNumberSecond segment, e.g. "1"
titleFirst H1 or ## Story heading text
ownedScope## Owned File/Module Scope — list every path verbatim
wave## Dependency Maps → wave/parallel_set annotation (integer or null)
parallelSetSame section — parallel set label if present (string or null)
dependencies## Dependency Maps → blocked-by story IDs (array, may be empty)
acceptanceCriteriaSummaryFirst 3 AC items from ## Acceptance Criteria, each ≤120 chars
lockedSectionsNoteStatic string — see schema
devAgentRecordStatic null — placeholder for the dev tool to populate

5. Compute wave order

If stories do not already carry explicit wave annotations:

  • Stories with empty dependencies arrays are wave 1.
  • A story whose every dependency is in wave N or lower is wave N+1.
  • Add the computed wave value; leave parallelSet null when not annotated.

6. Write the manifest

Write to {outputFolder}/handoff-manifest.json.

Use the schema from ${CLAUDE_PLUGIN_ROOT}/skills/bmad-handoff/templates/handoff-manifest.schema.json as the structural contract. Populate schemaVersion: "1.0".

Sort stories by wave ascending, then by id ascending within each wave.

7. Report to the user

Print a compact summary:

Handoff manifest written → bmad-output/handoff-manifest.json
  schemaVersion : 1.0
  stories       : <N> ready-for-dev
  waves         : <W>  (wave 1 has <X> stories, can start immediately)
  output path   : bmad-output/handoff-manifest.json

If any story was missing required sections (e.g. no ## Owned File/Module Scope), list those as warnings — do not silently omit or fabricate data.

Manifest Field Definitions (Quick Reference)

See REFERENCE.md for the full schema narrative and adapter notes.

FieldTypeRequiredNotes
schemaVersionstringyesSemver string; current = "1.0"
generatedAtstringyesISO-8601 UTC timestamp
projectNamestringyesFrom project-context.md or user input
outputFolderstringyesRelative path used to find stories
storiesarrayyesOne object per ready-for-dev story
stories[].idstringyesUnique story identifier
stories[].storyFilePathstringyesRelative path to the .story.md file
stories[].statusstringyesAlways "ready-for-dev" in this manifest
stories[].epicstringyesEpic identifier
stories[].storyNumberstringyesStory number within epic
stories[].titlestringyesHuman-readable story title
stories[].ownedScopearrayyesFile/module paths this story may modify
stories[].waveintegeryesExecution wave (1 = no dependencies)
stories[].parallelSetstring|nullnoLabel if explicitly grouped
stories[].dependenciesarrayyesStory IDs that must complete first
stories[].acceptanceCriteriaSummaryarrayyesFirst 3 AC items, ≤120 chars each
stories[].lockedSectionsNotestringyesInstruction to dev tools
stories[].devAgentRecordnullyesDev tool populates; always null at emit time

lockedSectionsNote is always the string:

"Sections Acceptance Criteria, Dev Notes, and Testing are LOCKED. External dev tools must not edit them. Populate only the Dev Agent Record section."

Subagent Strategy

For small backlogs (≤15 stories), this skill runs single-threaded — the extraction loop is fast and context fits in one session.

For large backlogs (16+ stories), fan out story extraction in parallel:

AgentTask
Agent 1…NRead story files in their assigned slice; extract fields; return JSON fragment
CoordinatorMerge fragments; compute wave order; write manifest

Each agent receives the list of file paths for its slice plus the field extraction table above. It returns a JSON array of story objects (no wave field yet). The coordinator merges, computes waves, sorts, and writes the manifest.

Key Guidelines

  1. Never fabricate field values — if a field is missing from a story file, emit null and add a warning to the summary.
  2. Do not modify story files — this skill is read-only with respect to story content.
  3. ownedScope is critical for parallel-conflict safety; never collapse or summarize it.
  4. This manifest is a STABLE versioned interface. Increment schemaVersion (as a separate schema revision, not within this run) before adding or removing fields.
  5. Do not filter out stories based on anything other than ready-for-dev status — dependency resolution is the dev tool's job.
  6. If the user asks to "re-run" or "refresh" the manifest, overwrite the existing file.


Part of the BMAD Planning & Orchestrator plugin — a Claude Code harness for the BMAD Method by the BMAD Code Organization (https://github.com/bmad-code-org/BMAD-METHOD). Implements the spirit of bmad-handoff. All methodology credit belongs to the BMAD Code Organization.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Bmad Handoff AI skill do?

Emits a dev-tool-agnostic handoff manifest from ready-for-dev stories so an external dev plugin or runner can pick up and execute the work. Use when the user says "generate a handoff", "create handoff manifest", "export stories for dev", "hand off to dev tool", "produce handoff manifest", "ready to hand off", "prepare handoff for external tool", "export ready-for-dev stories", or "create the handoff package". Also trigger when the user asks "what stories are ready for dev?" and wants an exportable artifact rather than a status report. Produces: handoff-manifest.json listing all ready-for-de...

Why use Bmad Handoff on TypingMind?

Because you install it once and use it with any model. Bmad Handoff is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Bmad Handoff in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/aj-geddes/claude-code-bmad-skills/tree/main/bmad-planning-orchestrator/skills/bmad-handoff. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Bmad Handoff?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Bmad Handoff?

As many as you like. As long as a model supports skills, you can use Bmad Handoff with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Bmad Handoff AI skill free?

It is published on GitHub by aj-geddes. Check the repository for licensing terms. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇