Agent skill

Bmad

A skill your agent uses to run BMad (Breakthrough Method of Agile AI-Driven Development) as a harness-agnostic control-plane protocol that turns human intent into bounded, inspectable, resumable…

MITAuto-check passedDevelopment

Install Bmad

skills CLI

$ npx skills add magnus919/agent-skills --skill bmad -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI

$ gh skill install magnus919/agent-skills bmad --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy

$ git clone --depth 1 https://github.com/magnus919/agent-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/bmad .claude/skills/bmad && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Paste into Claude Code

Install the "bmad" agent skill from https://github.com/magnus919/agent-skills/tree/main/bmad into .claude/skills/bmad/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "bmad", then confirm the skill loads.

Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

$skill-installer

$skill-installer install https://github.com/magnus919/agent-skills/tree/main/bmad

Type this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.

skills CLI

$ npx skills add magnus919/agent-skills --skill bmad -a codex

Project install goes to .agents/skills/; add -g for ~/.codex/skills/.

GitHub CLI

$ gh skill install magnus919/agent-skills bmad --agent codex

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/magnus919/agent-skills.git skills-src && mkdir -p .agents/skills && cp -r skills-src/bmad .agents/skills/bmad && rm -rf skills-src

Use ~/.agents/skills/ instead of .agents/skills for a personal install.

Codex skills documentation · loads skills from .agents/skills/

Paste into Codex

Install the "bmad" agent skill from https://github.com/magnus919/agent-skills/tree/main/bmad into .agents/skills/bmad/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "bmad", then confirm the skill loads.

Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add magnus919/agent-skills --skill bmad -a cursor

Project install goes to .agents/skills/; add -g for ~/.cursor/skills/.

GitHub CLI

$ gh skill install magnus919/agent-skills bmad --agent cursor

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/magnus919/agent-skills.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/bmad .cursor/skills/bmad && rm -rf skills-src

Use ~/.cursor/skills/ instead of .cursor/skills for a personal install.

Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/

Paste into Cursor

Install the "bmad" agent skill from https://github.com/magnus919/agent-skills/tree/main/bmad into .cursor/skills/bmad/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "bmad", then confirm the skill loads.

Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

gemini skills install

$ gemini skills install https://github.com/magnus919/agent-skills.git --path bmad

--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.

skills CLI

$ npx skills add magnus919/agent-skills --skill bmad -a gemini-cli

Project install goes to .agents/skills/; add -g for ~/.gemini/skills/.

GitHub CLI

$ gh skill install magnus919/agent-skills bmad --agent gemini-cli

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/magnus919/agent-skills.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/bmad .gemini/skills/bmad && rm -rf skills-src

Use ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.

Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/

Paste into Gemini CLI

Install the "bmad" agent skill from https://github.com/magnus919/agent-skills/tree/main/bmad into .gemini/skills/bmad/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "bmad", then confirm the skill loads.

Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

GitHub CLI

$ gh skill install magnus919/agent-skills bmad

Installs for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).

skills CLI

$ npx skills add magnus919/agent-skills --skill bmad -a github-copilot

Project install goes to .agents/skills/; add -g for ~/.copilot/skills/.

Manual copy

$ git clone --depth 1 https://github.com/magnus919/agent-skills.git skills-src && mkdir -p .github/skills && cp -r skills-src/bmad .github/skills/bmad && rm -rf skills-src

Use ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.

GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/

Paste into GitHub Copilot

Install the "bmad" agent skill from https://github.com/magnus919/agent-skills/tree/main/bmad into .github/skills/bmad/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "bmad", then confirm the skill loads.

GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add magnus919/agent-skills --skill bmad -a opencode

OpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.

GitHub CLI

$ gh skill install magnus919/agent-skills bmad --agent opencode

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/magnus919/agent-skills.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/bmad .opencode/skills/bmad && rm -rf skills-src

Use ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.

OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/

Paste into OpenCode

Install the "bmad" agent skill from https://github.com/magnus919/agent-skills/tree/main/bmad into .opencode/skills/bmad/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "bmad", then confirm the skill loads.

OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

Facts

Skill name: bmad
GitHub stars: 115
Token cost: ~2.6k tokens
SKILL.md length: 1,040 words
Files: 18 (incl. scripts, references)
Skills in repo: 131
Repo updated: Oct 10, 2026
First seen: Oct 7, 2026
Licence: MIT

At a glance

A skill your agent uses to run BMad (Breakthrough Method of Agile AI-Driven Development) as a harness-agnostic control-plane protocol that turns human intent into bounded, inspectable, resumable…

Works in 5 steps: Why — the outcome and why it matters. → Capabilities — what the system must be… → Constraints — technical, operational,… → …
Resumable agent work
SKILL.md covers When to use this skill, Work classification (smallest…, The intent contract (five… and The canonical loop, plus 9 more sections
Runs Python scripts from its folder

What it does

Bmad is an agent skill from magnus919/agent-skills. Use this skill to run BMad (Breakthrough Method of Agile AI-Driven Development) as a harness-agnostic control-plane protocol that turns human intent into bounded, inspectable, resumable agent work. Compress intent into a five-field contract (Why, Capabilities, Constraints, Non-goals, Success signal); classify work as direct/bounded/initiative and route to the smallest safe path; carry decisions in durable artifacts; review as triage; route failure to the layer where ambiguity entered; and gate autonomy on…

Its SKILL.md is about 2.6k tokens, which your agent loads only when the skill is triggered. The skill folder holds 21 other files, including scripts and reference files (for example `README.md`, `evals/evals.json` and `references/adoption.md`).

It sits in Development, covering Spec-driven development. The repository describes itself as: Curated collection of AI agent skills for Hermes and other agent frameworks. The licence is MIT.

When your agent uses it

Resumable agent work
A change request
Delegated build
Multi-agent epic needs intent capture

Example prompts

“/bmad”

Requirements

Python 3

Workflow steps

5 steps, taken from the first numbered list in SKILL.md.

Why — the outcome and why it matters.
Capabilities — what the system must be able to do.
Constraints — technical, operational, legal, security, privacy, time, cost, organizational boundaries.
Non-goals — what is explicitly out of scope.
Success signal — how we will know the result works and is acceptable.

What it can do on your machine

Read from SKILL.md and the folder at commit 22b4723. It shows what the files ask for, not the result of running them.

Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
Ships 2 files in scripts/ (Python, from the files we listed), which the agent can run.
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Bmad loads about 2.6k tokens when it runs, and up to ~12k if it reads all its reference files. Until then it costs about 253 tokens; SKILL.md has 1,040 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it: ~253
When it runs · the whole SKILL.md, loaded when a task matches: ~2.6k
With references · SKILL.md plus every file in references/, read only if the agent opens them: ~12k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from magnus919/agent-skills at commit 22b4723, republished under its MIT licence (© magnus919). 1,040 words, ~2,604 tokens.

Download SKILL.mdSave it as .claude/skills/bmad/SKILL.md (or your agent's skills folder). This skill also uses 17 other files; get the full folder from GitHub.

name: bmad
description: Use this skill to run BMad (Breakthrough Method of Agile AI-Driven Development) as a harness-agnostic control-plane protocol that turns human intent into bounded, inspectable, resumable agent work. Compress intent into a five-field contract (Why, Capabilities, Constraints, Non-goals, Success signal); classify work as direct/bounded/initiative and route to the smallest safe path; carry decisions in durable artifacts; review as triage; route failure to the layer where ambiguity entered; and gate autonomy on observable acceptance with machine-readable status (draft/ready-for-dev/in-progress/in-review/done/blocked). Use when a change request, feature, delegated build, or multi-agent epic needs intent capture, bounded implementation, review, and resumability in any agent harness. Do not use for validating whether a problem is real (product-discovery), shaping bets before planning (product-shaping), formal spec/gate pipelines (spec-driven-development), or the issue-to-PR delivery flow (neckbeard).
license: MIT
metadata.source: https://github.com/magnus919/agent-skills/tree/main/bmad
metadata.tags: bmad, bmad-method, agentic-engineering, intent-contract, spec, work-classification, review-triage, autonomy, dark-factory, control-plane, bounded-work…

BMad: Intent-to-Delivery Control-Plane Protocol

BMad is a software-delivery method built on one idea: human intent should be progressively clarified, recorded, reviewed, and handed to agents as durable context rather than improvised in chat. This skill turns that method into a protocol any agent harness can follow — no official BMad installer required.

The loop: classify the request → compress intent into a contract → route to the smallest safe path → implement one bounded unit → review as triage → route failure to the layer where ambiguity entered → gate autonomy on observable acceptance → learn from completed work.

When to use this skill

Load when a change request, feature, bug report, delegated build, or multi-agent epic needs:

intent capture before implementation — a contract, not a vibe;
a decision about how much ceremony the work deserves;
durable artifacts so work is resumable across sessions or agents;
review that triages findings instead of enumerating noise;
autonomy that stops safely when the boundary is unsafe.

Work classification (smallest safe path)

Class	Shape	Process
Direct	clear goal, local change, established patterns, small blast radius	implement immediately after minimal clarification
Bounded	coherent change needing a short contract and plan	intent contract → plan → implement → review
Initiative	cross-component, multi-story, high-risk, or strategically uncertain	analysis → planning → solutioning → implementation → learning

Load references/classification.md for the decision table, the one-question rule, and stop conditions.

The intent contract (five fields)

For bounded or initiative work, establish a contract before implementation:

Why — the outcome and why it matters.
Capabilities — what the system must be able to do.
Constraints — technical, operational, legal, security, privacy, time, cost, organizational boundaries.
Non-goals — what is explicitly out of scope.
Success signal — how we will know the result works and is acceptable.

If a field is materially ambiguous, ask one high-leverage question, propose a recommended answer, and wait for the decision. For trivial changes the contract can be five bullets in conversation; for larger work it becomes a versioned spec file.

Load references/spec.md for SPEC authoring and the status vocabulary. Templates: templates/SPEC.md and templates/INTENT.md.

The canonical loop

Inspect the repository and available context before asking anything.
Classify the work; state the proposed route.
Establish or resume the intent contract; ask at most one material question.
Present a plan for non-trivial work; wait at the approval checkpoint.
Implement the smallest coherent change; run focused tests first, then broader checks.
Review for correctness, scope, security, regressions, maintainability.
Repair findings that belong to this change; defer unrelated findings explicitly.
Report intent, behavior, files, risk, verification, findings disposition, and an accept / rework / investigate choice.

Spec status vocabulary

Machine-readable status for resumable work:

Status	Meaning
`draft`	Spec exists but is not ready
`ready-for-dev`	Passed readiness; ready to implement
`in-progress`	Implementation underway
`in-review`	Review or triage underway
`done`	Workflow completed successfully
`blocked`	Cannot safely continue unattended

blocked is a routing signal, not failure: a higher-level orchestrator, another workflow, or a human takes over. Validate a spec deterministically with scripts/check-spec.py.

Failure routing

When something is wrong, diagnose the layer where the failure entered:

Failure	Route
Wrong outcome or wrong problem	intent / analysis
Missing or contradictory requirement	contract / planning
Conflicting technical approach	architecture
Incorrect local code	implementation
Insufficient test or evaluation	verification
Unrelated pre-existing issue	defer explicitly
Unsafe ambiguity	block and ask

Do not keep patching code when the specification is the real problem.

Autonomy gate

Autonomous execution is allowed only when all of these hold: intent contract coherent, acceptance observable, boundary explicit, repository safe to modify, tests or evaluations runnable, durable status writable, escalation defined. During autonomous work: one coherent change at a time; never expand scope on unrelated improvements; never merge, deploy, or change external systems without authorization; stop on intent gaps, missing capability, destructive ambiguity, failed verification, or non-convergent repair.

Show full SKILL.md (418 more words)Show less

Reference files

Reference	Load when
references/protocol.md	You need the full paste-ready operating protocol for an agent
references/classification.md	Classifying a request or choosing ceremony depth
references/spec.md	Writing or resuming a SPEC / intent contract
references/lifecycle.md	Running an initiative through all four phases
references/project-context.md	Setting up or auditing repository rules (AGENTS.md)
references/review-and-failure-routing.md	Running a review or diagnosing a failure
references/autonomy.md	Configuring or running autonomous (Build Auto) work
references/party-mode.md	Deliberation, trade-offs, design debates, post-mortems
references/adoption.md	Adopting the protocol incrementally or mapping to a dark factory

Templates

Template	Purpose
templates/SPEC.md	Versioned machine contract for bounded/initiative work
templates/INTENT.md	Lightweight five-field contract for bounded work
templates/STORY.md	One bounded, dispatchable work unit
templates/REVIEW.md	Final human checkpoint: intent → behavior → risk → verification

Scripts

Script	When to run
scripts/check-spec.py	After writing or editing a spec: validate five fields + status vocabulary (stdlib only, `--json` output)

Routing to adjacent skills

Upstream (before BMad): product-discovery validates whether a problem is real; product-shaping sets an appetite and produces a pitch; product-strategy and product-roadmapping-and-portfolio frame strategic context.
Downstream (during BMad): spec-driven-development for formal spec/gate pipelines; implementation-planning for a dependency-aware delivery plan; adr-authoring for architecture decisions; software-architecture-analysis for reverse-engineering an existing codebase.
Execution and gates: neckbeard for the issue-to-PR delivery flow; verification-methodology for acceptance evidence; qa-methodology for test strategy; agent-evals-and-observability for independent evaluators; agent-council for Party-Mode-style multi-agent deliberation; release-engineering for deployment gates; kanban-guru for backlog and dispatch policy.

When not to use

The problem itself is unvalidated → product-discovery. BMad compresses intent; it does not establish whether the problem is real.
No decision yet on how much the work is worth → product-shaping first (appetite, pitch, bet). BMad starts from a placed intent.
You need a formal spec format plus phase gates as the factory pipeline → spec-driven-development owns SPEC format and gate mechanics; BMad provides the control-plane protocol around them.
You are executing an issue-to-PR delivery flow with its own gates → neckbeard. BMad complements it; do not run two competing delivery lifecycles.
You need independent review → role-play is not independence. Use agent-council, separate evaluators, or agent-evals-and-observability; never claim persona separation as independent review.
Operating the official BMad installer/tooling → this skill emulates the method; it does not install or operate bmad-method npm packages.

Version drift and attribution

BMad is actively evolving (official repository: bmadcode/bmad-method; BMAD™ and BMAD-METHOD™ are trademarks of BMad Code, LLC). Older articles differ on name expansion, agents, file names, and commands. When installing the official tooling, treat the official docs and installed source as authoritative. This skill is an original distillation of the method as a harness-agnostic protocol; it does not reproduce official installer content.

Files

SKILL.md and 17 other files (scripts, references) in bmad of magnus919/agent-skills.

SKILL.md
README.md
evals/evals.json
references/adoption.md
references/autonomy.md
references/classification.md
references/lifecycle.md
references/party-mode.md
references/project-context.md
references/protocol.md
references/review-and-failure-routing.md
references/spec.md
scripts/check-spec.py
scripts/test_check_spec.py
templates/INTENT.md
templates/REVIEW.md
templates/SPEC.md
… and 1 more

Open the folder on GitHubat commit 22b4723

Compare with similar skills

Bmad next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Bmad compared with similar skills
Skill	Stars	Used in	Tokens	Auto-check	Licence	Repo updated
Bmad this skillmagnus919/agent-skills	115	—	~2.6k	Automated safety check: Pass	MIT	today
Ss SpecSerial-Studio/Serial-Studio	7.2k	—	~766	Automated safety check: Pass	Custom licence	yesterday
PRP PlanWirasm/prp	2.3k	—	~4k	Automated safety check: Pass	MIT	8 days ago
Spec Driven Workflowalirezarezvani/claude-skills	28k	—	~3.9k	Automated safety check: Pass	MIT	1 mo ago
CCPM Project Managementautomazeio/ccpm	8.4k	—	~1.1k	Automated safety check: Pass	MIT	6 mo ago
SPARC Development Methodologyruvnet/ruflo	74k	2 repos	~829	Automated safety check: Pass	MIT	today

Similar skills

Ss Spec
Serial-Studio/Serial-Studio
Phase 1 of Serial Studio's spec-driven workflow: capture WHAT a feature must do and WHY, with no implementation detail.
7.2k GitHub stars~766 tokensUpdated yesterday
DevelopmentAuto-check passed
PRP Plan
Wirasm/prp
Writes an implementation-ready plan for a feature, bug fix, refactor or chore from a PRD, issue or description, grounded in codebase evidence, and can post it back to the source issue.
2.3k GitHub stars~4k tokensUpdated 8 days ago
DevelopmentAuto-check passed
Spec Driven Workflow
alirezarezvani/claude-skills
A skill your agent uses when the user asks to write specs before code, define acceptance criteria, plan features before implementation, generate tests from specifications, or follow spec-first…
28k GitHub stars~3.9k tokensUpdated 1 mo ago
DevelopmentAuto-check passed
CCPM Project Management
automazeio/ccpm
Runs a spec-driven workflow from PRD to epic to GitHub issues to parallel agents, with status, standup and blocked-work reports from bundled scripts.
8.4k GitHub stars~1.1k tokensUpdated 6 mo ago
Product & Project ManagementAuto-check passed
SPARC Development Methodology
ruvnet/ruflo
Applies the SPARC method (specification, pseudocode, architecture, refinement, completion) with 17 specialized modes and multi-agent orchestration, from research to deployment.
74k GitHub starsUsed in 2 repos~829 tokens
DevelopmentAuto-check passed
BiSheng SDD Document Review
dataelement/bisheng
Reviews BiSheng spec, design and tasks documents with checklists for PRD gaps, handover readiness and acceptance traceability, producing a report or an LGTM.
12k GitHub stars~717 tokensUpdated today
DevelopmentAuto-check passed

Questions about Bmad

What does Bmad do?

A skill your agent uses to run BMad (Breakthrough Method of Agile AI-Driven Development) as a harness-agnostic control-plane protocol that turns human intent into bounded, inspectable, resumable…. Bmad is an agent skill from magnus919/agent-skills. Use this skill to run BMad (Breakthrough Method of Agile AI-Driven Development) as a harness-agnostic control-plane protocol that turns human intent into bounded, inspectable, resumable agent work.

When should I use Bmad?

Bmad fits situations like: resumable agent work; A change request; delegated build; multi-agent epic needs intent capture.

How do I install Bmad in Claude Code?

Run `npx skills add magnus919/agent-skills --skill bmad -a claude-code`. Or copy the skill folder (bmad in magnus919/agent-skills) into .claude/skills/bmad in your project. Claude Code loads it when a task matches its description.

How do I install Bmad in Codex?

Run `npx skills add magnus919/agent-skills --skill bmad -a codex`. Or copy the skill folder (bmad in magnus919/agent-skills) into .agents/skills/bmad in your project. Codex loads it when a task matches its description.

Can I use Bmad in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add magnus919/agent-skills --skill bmad -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/bmad, .gemini/skills/bmad, .github/skills/bmad and .opencode/skills/bmad in your project.

What does Bmad need to run?

Going by SKILL.md and its folder, Bmad needs Python for the scripts in its folder. Our summary lists: Python 3.

Does Bmad access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Bmad safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Bmad use?

Bmad is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Bmad use?

About 2.6k tokens (SKILL.md is roughly 10k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 9.4k tokens, read only when the agent opens those files.

What are the alternatives to Bmad?

Skills that share tags, products or a category with Bmad: Ss Spec (Serial-Studio/Serial-Studio, 7.2k stars), PRP Plan (Wirasm/prp, 2.3k stars), Spec Driven Workflow (alirezarezvani/claude-skills, 28k stars) and CCPM Project Management (automazeio/ccpm, 8.4k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Bmad?

magnus919 (a GitHub user) maintains it in magnus919/agent-skills, which has 115 GitHub stars. The repository holds 131 skills in this directory. The repository was last updated on October 10, 2026.

Source: magnus919/agent-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.

Install Bmad

Facts

At a glance

What it does

When your agent uses it

Example prompts

Requirements

Workflow steps

What it can do on your machine

Tool permissions

Runs code

Network

Credentials

Context cost

Safety

SKILL.md

BMad: Intent-to-Delivery Control-Plane Protocol

When to use this skill

Work classification (smallest safe path)

The intent contract (five fields)

The canonical loop

Spec status vocabulary

Failure routing

Autonomy gate

Reference files

Templates

Scripts

Routing to adjacent skills

When not to use

Version drift and attribution

Files

Compare with similar skills

Similar skills

More from magnus919/agent-skills

Related

Questions about Bmad