bmad-method 6.0.5-next.1 → 6.0.5-next.2

package/CHANGELOG.md

@@ -47,7 +47,7 @@
 * Add CodeBuddy platform support with installer configuration (#1483)
 * Add LLM audit prompt for file reference conventions - new audit tool using parallel subagents (#1720)
 * Migrate Codex installer from `.codex/prompts` to `.agents/skills` format to align with Codex CLI changes (#1729)
-* Convert review-pr and audit-file-refs tools to proper bmad-os skills with slash commands `/bmad-os-review-pr` and `/bmad-os-audit-file-refs` (#1732)
+* Convert review-pr and audit-file-refs tools to proper bmad-os skills with slash commands `bmad-os-review-pr` and `bmad-os-audit-file-refs` (#1732)
 
 ### 🐛 Bug Fixes
 
@@ -365,7 +365,7 @@ V6 Stable Release! The End of Beta!
 - TEA documentation restructured using Diátaxis framework (25 docs)
 - Style guide optimized for LLM readers (367 lines, down from 767)
 - Glossary rewritten using table format (123 lines, down from 373)
-- README overhaul with numbered command flows and prominent `/bmad-help` callout
+- README overhaul with numbered command flows and prominent `bmad-help` callout
 - New workflow map diagram with interactive HTML
 - New editorial review tasks for document quality
 - E2E testing methodology for Game Dev Studio

package/README.md

@@ -13,7 +13,7 @@
 
 Traditional AI tools do the thinking for you, producing average results. BMad agents and facilitated workflows act as expert collaborators who guide you through a structured process to bring out your best thinking in partnership with the AI.
 
-- **AI Intelligent Help** — Ask `/bmad-help` anytime for guidance on what's next
+- **AI Intelligent Help** — Invoke the `bmad-help` skill anytime for guidance on what's next
 - **Scale-Domain-Adaptive** — Automatically adjusts planning depth based on project complexity
 - **Structured Workflows** — Grounded in agile best practices across analysis, planning, architecture, and implementation
 - **Specialized Agents** — 12+ domain experts (PM, Architect, Developer, UX, Scrum Master, and more)
@@ -40,7 +40,7 @@ Traditional AI tools do the thinking for you, producing average results. BMad ag
 npx bmad-method install
 ```
 
-> If you are getting a stale beta version, use: `npx bmad-method@6.0.1 install`
+> Want the newest prerelease build? Use `npx bmad-method@next install`. Expect higher churn than the default install.
 
 Follow the installer prompts, then open your AI IDE (Claude Code, Cursor, etc.) in your project folder.
 
@@ -52,7 +52,7 @@ npx bmad-method install --directory /path/to/project --modules bmm --tools claud
 
 [See all installation options](https://docs.bmad-method.org/how-to/non-interactive-installation/)
 
-> **Not sure what to do?** Run `/bmad-help` — it tells you exactly what's next and what's optional. You can also ask questions like `/bmad-help I just finished the architecture, what do I do next?`
+> **Not sure what to do?** Ask `bmad-help` — it tells you exactly what's next and what's optional. You can also ask questions like `bmad-help I just finished the architecture, what do I do next?`
 
 ## Modules
 

package/README_CN.md

@@ -13,7 +13,7 @@
 
 传统 AI 工具替你思考，产生平庸的结果。BMad 智能体和辅助工作流充当专家协作者，引导你通过结构化流程，与 AI 的合作发挥最佳思维，产出最有效优秀的结果。
 
-- **AI 智能帮助** — 随时使用 `/bmad-help` 获取下一步指导
+- **AI 智能帮助** — 随时使用 `bmad-help` 获取下一步指导
 - **规模-领域自适应** — 根据项目复杂度自动调整规划深度
 - **结构化工作流** — 基于分析、规划、架构和实施的敏捷最佳实践
 - **专业智能体** — 12+ 领域专家（PM、架构师、开发者、UX、Scrum Master 等）
@@ -52,7 +52,7 @@ npx bmad-method install --directory /path/to/project --modules bmm --tools claud
 
 [查看所有安装选项](http://docs.bmad-method.org/how-to/non-interactive-installation/)
 
-> **不确定该做什么？** 运行 `/bmad-help` — 它会准确告诉你下一步做什么以及什么是可选的。你也可以问诸如 `/bmad-help 我刚刚完成了架构设计，接下来该做什么？` 之类的问题。
+> **不确定该做什么？** 运行 `bmad-help` — 它会准确告诉你下一步做什么以及什么是可选的。你也可以问诸如 `bmad-help 我刚刚完成了架构设计，接下来该做什么？` 之类的问题。
 
 ## 模块
 

package/docs/explanation/quick-dev-new-preview.md

@@ -0,0 +1,73 @@
+---
+title: "Quick Dev New Preview"
+description: Reduce human-in-the-loop friction without giving up the checkpoints that protect output quality
+sidebar:
+  order: 2
+---
+
+`bmad-quick-dev-new-preview` is an experimental attempt to radically improve Quick Flow: intent in, code changes out, with lower ceremony and fewer human-in-the-loop turns without sacrificing quality.
+
+It lets the model run longer between checkpoints, then brings the human back only when the task cannot safely continue without human judgment or when it is time to review the end result.
+
+![Quick Dev New Preview workflow diagram](/diagrams/quick-dev-diagram.png)
+
+## Why This Exists
+
+Human-in-the-loop turns are necessary and expensive.
+
+Current LLMs still fail in predictable ways: they misread intent, fill gaps with confident guesses, drift into unrelated work, and generate noisy review output. At the same time, constant human intervention limits development velocity. Human attention is the bottleneck.
+
+This experimental version of Quick Flow is an attempt to rebalance that tradeoff. It trusts the model to run unsupervised for longer stretches, but only after the workflow has created a strong enough boundary to make that safe.
+
+## The Core Design
+
+### 1. Compress intent first
+
+The workflow starts by having the human and the model compress the request into one coherent goal. The input can begin as a rough expression of intent, but before the workflow runs autonomously it has to become small enough, clear enough, and contradiction-free enough to execute.
+
+Intent can come in many forms: a couple of phrases, a bug tracker link, output from plan mode, text copied from a chat session, or even a story number from BMAD's own `epics.md`. In that last case, the workflow will not understand BMAD story-tracking semantics, but it can still take the story itself and run with it.
+
+This workflow does not eliminate human control. It relocates it to a small number of high-value moments:
+
+- **Intent clarification** - turning a messy request into one coherent goal without hidden contradictions
+- **Spec approval** - confirming that the frozen understanding is the right thing to build
+- **Review of the final product** - the primary checkpoint, where the human decides whether the result is acceptable at the end
+
+### 2. Route to the smallest safe path
+
+Once the goal is clear, the workflow decides whether this is a true one-shot change or whether it needs the fuller path. Small, zero-blast-radius changes can go straight to implementation. Everything else goes through planning so the model has a stronger boundary before it runs longer on its own.
+
+### 3. Run longer with less supervision
+
+After that routing decision, the model can carry more of the work on its own. On the fuller path, the approved spec becomes the boundary the model executes against with less supervision, which is the whole point of the experiment.
+
+### 4. Diagnose failure at the right layer
+
+If the implementation is wrong because the intent was wrong, patching the code is the wrong fix. If the code is wrong because the spec was weak, patching the diff is also the wrong fix. The workflow is designed to diagnose where the failure entered the system, go back to that layer, and regenerate from there.
+
+Review findings are used to decide whether the problem came from intent, spec generation, or local implementation. Only truly local problems get patched locally.
+
+### 5. Bring the human back only when needed
+
+The intent interview is human-in-the-loop, but it is not the same kind of interruption as a recurring checkpoint. The workflow tries to keep those recurring checkpoints to a minimum. After the initial shaping of intent, the human mainly comes back when the workflow cannot safely continue without judgment and at the end, when it is time to review the result.
+
+- **Intent-gap resolution** - stepping back in when review proves the workflow could not safely infer what was meant
+
+Everything else is a candidate for longer autonomous execution. That tradeoff is deliberate. Older patterns spend more human attention on continuous supervision. Quick Dev New Preview spends more trust on the model, but saves human attention for the moments where human reasoning has the highest leverage.
+
+## Why the Review System Matters
+
+The review phase is not just there to find bugs. It is there to route correction without destroying momentum.
+
+This workflow works best on a platform that can spawn subagents, or at least invoke another LLM through the command line and wait for a result. If your platform does not support that natively, you can add a skill to do it. Context-free subagents are a cornerstone of the review design.
+
+Agentic reviews often go wrong in two ways:
+
+- They generate too many findings, forcing the human to sift through noise.
+- They derail the current change by surfacing unrelated issues and turning every run into an ad hoc cleanup project.
+
+Quick Dev New Preview addresses both by treating review as triage.
+
+Some findings belong to the current change. Some do not. If a finding is incidental rather than causally tied to the current work, the workflow can defer it instead of forcing the human to handle it immediately. That keeps the run focused and prevents random tangents from consuming the budget of attention.
+
+That triage will sometimes be imperfect. That is acceptable. It is usually better to misjudge some findings than to flood the human with thousands of low-value review comments. The system is optimizing for signal quality, not exhaustive recall.

package/docs/explanation/quick-flow.md

@@ -7,6 +7,10 @@ sidebar:
 
 Skip the ceremony. Quick Flow takes you from idea to working code in two skills - no Product Brief, no PRD, no Architecture doc.
 
+:::tip[Want a Unified Variant?]
+If you want one workflow to clarify, plan, implement, review, and present in a single run, see [Quick Dev New Preview](./quick-dev-new-preview.md).
+:::
+
 ## When to Use It
 
 - Bug fixes and patches

package/docs/how-to/get-answers-about-bmad.md

@@ -7,7 +7,7 @@ sidebar:
 
 ## Start Here: BMad-Help
 
-**The fastest way to get answers about BMad is `/bmad-help`.** This intelligent guide will answer upwards of 80% of all questions and is available to you directly in your IDE as you work.
+**The fastest way to get answers about BMad is the `bmad-help` skill.** This intelligent guide will answer upwards of 80% of all questions and is available to you directly in your IDE as you work.
 
 BMad-Help is more than a lookup tool — it:
 - **Inspects your project** to see what's already been completed
@@ -18,19 +18,23 @@ BMad-Help is more than a lookup tool — it:
 
 ### How to Use BMad-Help
 
-Run it with just the skill name:
+Call it by name in your AI session:
 
 ```
-/bmad-help
+bmad-help
 ```
 
-Or combine it with a natural language query:
+:::tip
+You can also use `/bmad-help` or `$bmad-help` depending on your platform, but just `bmad-help` should work everywhere.
+:::
+
+Combine it with a natural language query:
 
 ```
-/bmad-help I have a SaaS idea and know all the features. Where do I start?
-/bmad-help What are my options for UX design?
-/bmad-help I'm stuck on the PRD workflow
-/bmad-help Show me what's been done so far
+bmad-help I have a SaaS idea and know all the features. Where do I start?
+bmad-help What are my options for UX design?
+bmad-help I'm stuck on the PRD workflow
+bmad-help Show me what's been done so far
 ```
 
 BMad-Help responds with:

package/docs/how-to/install-bmad.md

@@ -29,6 +29,15 @@ If you want to use a non interactive installer and provide all install options o
 npx bmad-method install
 ```
 
+:::tip[Want the newest prerelease build?]
+Use the `next` dist-tag:
+```bash
+npx bmad-method@next install
+```
+
+This gets you newer changes earlier, with a higher chance of churn than the default install.
+:::
+
 :::tip[Bleeding edge]
 To install the latest from the main branch (may be unstable):
 ```bash

package/docs/tutorials/getting-started.md

@@ -22,7 +22,7 @@ Build software faster using AI-powered workflows with specialized agents that gu
 
 :::tip[The Easiest Path]
 **Install** → `npx bmad-method install`
-**Ask** → `/bmad-help what should I do first?`
+**Ask** → `bmad-help what should I do first?`
 **Build** → Let BMad-Help guide you workflow by workflow
 :::
 
@@ -59,7 +59,7 @@ BMad-Help will respond with:
 BMad-Help doesn't just answer questions — **it automatically runs at the end of every workflow** to tell you exactly what to do next. No guessing, no searching docs — just clear guidance on the next required workflow.
 
 :::tip[Start Here]
-After installing BMad, run `/bmad-help` immediately. It will detect what modules you have installed and guide you to the right starting point for your project.
+After installing BMad, invoke the `bmad-help` skill immediately. It will detect what modules you have installed and guide you to the right starting point for your project.
 :::
 
 ## Understanding BMad
@@ -95,6 +95,8 @@ Open a terminal in your project directory and run:
 npx bmad-method install
 ```
 
+If you want the newest prerelease build instead of the default release channel, use `npx bmad-method@next install`.
+
 When prompted to select modules, choose **BMad Method**.
 
 The installer creates two folders:
@@ -105,14 +107,14 @@ The installer creates two folders:
 Open your AI IDE in the project folder and run:
 
 ```
-/bmad-help
+bmad-help
 ```
 
 BMad-Help will detect what you've completed and recommend exactly what to do next. You can also ask it questions like "What are my options?" or "I have a SaaS idea, where should I start?"
 :::
 
 :::note[How to Load Agents and Run Workflows]
-Each workflow has a **skill** you invoke in your IDE (e.g., `/bmad-create-prd`). Running a workflow skill automatically loads the appropriate agent — you don't need to load agents separately. You can also invoke an agent directly for general conversation (e.g., `/bmad-pm` for the PM agent).
+Each workflow has a **skill** you invoke by name in your IDE (e.g., `bmad-create-prd`). Your AI tool will recognize the `bmad-*` name and run it — you don't need to load agents separately. You can also invoke an agent skill directly for general conversation (e.g., `bmad-pm` for the PM agent).
 :::
 
 :::caution[Fresh Chats]
@@ -126,35 +128,35 @@ Work through phases 1-3. **Use fresh chats for each workflow.**
 :::tip[Project Context (Optional)]
 Before starting, consider creating `project-context.md` to document your technical preferences and implementation rules. This ensures all AI agents follow your conventions throughout the project.
 
-Create it manually at `_bmad-output/project-context.md` or generate it after architecture using `/bmad-generate-project-context`. [Learn more](../explanation/project-context.md).
+Create it manually at `_bmad-output/project-context.md` or generate it after architecture using `bmad-generate-project-context`. [Learn more](../explanation/project-context.md).
 :::
 
 ### Phase 1: Analysis (Optional)
 
 All workflows in this phase are optional:
-- **brainstorming** (`/bmad-brainstorming`) — Guided ideation
-- **research** (`/bmad-research`) — Market and technical research
-- **create-product-brief** (`/bmad-create-product-brief`) — Recommended foundation document
+- **brainstorming** (`bmad-brainstorming`) — Guided ideation
+- **research** (`bmad-research`) — Market and technical research
+- **create-product-brief** (`bmad-create-product-brief`) — Recommended foundation document
 
 ### Phase 2: Planning (Required)
 
 **For BMad Method and Enterprise tracks:**
-1. Invoke the **PM agent** (`/bmad-pm`) in a new chat
-2. Run the `bmad-create-prd` workflow (`/bmad-create-prd`)
+1. Invoke the **PM agent** (`bmad-pm`) in a new chat
+2. Run the `bmad-create-prd` workflow (`bmad-create-prd`)
 3. Output: `PRD.md`
 
 **For Quick Flow track:**
-- Use the `bmad-quick-spec` workflow (`/bmad-quick-spec`) instead of PRD, then skip to implementation
+- Use the `bmad-quick-spec` workflow (`bmad-quick-spec`) instead of PRD, then skip to implementation
 
 :::note[UX Design (Optional)]
-If your project has a user interface, invoke the **UX-Designer agent** (`/bmad-ux-designer`) and run the UX design workflow (`/bmad-create-ux-design`) after creating your PRD.
+If your project has a user interface, invoke the **UX-Designer agent** (`bmad-ux-designer`) and run the UX design workflow (`bmad-create-ux-design`) after creating your PRD.
 :::
 
 ### Phase 3: Solutioning (BMad Method/Enterprise)
 
 **Create Architecture**
-1. Invoke the **Architect agent** (`/bmad-architect`) in a new chat
-2. Run `bmad-create-architecture` (`/bmad-create-architecture`)
+1. Invoke the **Architect agent** (`bmad-architect`) in a new chat
+2. Run `bmad-create-architecture` (`bmad-create-architecture`)
 3. Output: Architecture document with technical decisions
 
 **Create Epics and Stories**
@@ -163,13 +165,13 @@ If your project has a user interface, invoke the **UX-Designer agent** (`/bmad-u
 Epics and stories are now created *after* architecture. This produces better quality stories because architecture decisions (database, API patterns, tech stack) directly affect how work should be broken down.
 :::
 
-1. Invoke the **PM agent** (`/bmad-pm`) in a new chat
-2. Run `bmad-create-epics-and-stories` (`/bmad-create-epics-and-stories`)
+1. Invoke the **PM agent** (`bmad-pm`) in a new chat
+2. Run `bmad-create-epics-and-stories` (`bmad-create-epics-and-stories`)
 3. The workflow uses both PRD and Architecture to create technically-informed stories
 
 **Implementation Readiness Check** *(Highly Recommended)*
-1. Invoke the **Architect agent** (`/bmad-architect`) in a new chat
-2. Run `bmad-check-implementation-readiness` (`/bmad-check-implementation-readiness`)
+1. Invoke the **Architect agent** (`bmad-architect`) in a new chat
+2. Run `bmad-check-implementation-readiness` (`bmad-check-implementation-readiness`)
 3. Validates cohesion across all planning documents
 
 ## Step 2: Build Your Project
@@ -178,7 +180,7 @@ Once planning is complete, move to implementation. **Each workflow should run in
 
 ### Initialize Sprint Planning
 
-Invoke the **SM agent** (`/bmad-sm`) and run `bmad-sprint-planning` (`/bmad-sprint-planning`). This creates `sprint-status.yaml` to track all epics and stories.
+Invoke the **SM agent** (`bmad-sm`) and run `bmad-sprint-planning` (`bmad-sprint-planning`). This creates `sprint-status.yaml` to track all epics and stories.
 
 ### The Build Cycle
 
@@ -186,11 +188,11 @@ For each story, repeat this cycle with fresh chats:
 
 | Step | Agent | Workflow       | Command                    | Purpose                            |
 | ---- | ----- | -------------- | -------------------------- | ---------------------------------- |
-| 1    | SM    | `bmad-create-story` | `/bmad-create-story`  | Create story file from epic        |
-| 2    | DEV   | `bmad-dev-story`    | `/bmad-dev-story`     | Implement the story                |
-| 3    | DEV   | `bmad-code-review`  | `/bmad-code-review`   | Quality validation *(recommended)* |
+| 1    | SM    | `bmad-create-story` | `bmad-create-story`  | Create story file from epic        |
+| 2    | DEV   | `bmad-dev-story`    | `bmad-dev-story`     | Implement the story                |
+| 3    | DEV   | `bmad-code-review`  | `bmad-code-review`   | Quality validation *(recommended)* |
 
-After completing all stories in an epic, invoke the **SM agent** (`/bmad-sm`) and run `bmad-retrospective` (`/bmad-retrospective`).
+After completing all stories in an epic, invoke the **SM agent** (`bmad-sm`) and run `bmad-retrospective` (`bmad-retrospective`).
 
 ## What You've Accomplished
 
@@ -221,16 +223,16 @@ your-project/
 
 | Workflow                              | Command                                    | Agent     | Purpose                                         |
 | ------------------------------------- | ------------------------------------------ | --------- | ----------------------------------------------- |
-| **`bmad-help`** ⭐                    | `/bmad-help`                               | Any       | **Your intelligent guide — ask anything!**      |
-| `bmad-create-prd`                | `/bmad-create-prd`                     | PM        | Create Product Requirements Document            |
-| `bmad-create-architecture`            | `/bmad-create-architecture`            | Architect | Create architecture document                     |
-| `bmad-generate-project-context`       | `/bmad-generate-project-context`           | Analyst   | Create project context file                     |
-| `bmad-create-epics-and-stories`       | `/bmad-create-epics-and-stories`       | PM        | Break down PRD into epics            |
-| `bmad-check-implementation-readiness` | `/bmad-check-implementation-readiness` | Architect | Validate planning cohesion           |
-| `bmad-sprint-planning`                | `/bmad-sprint-planning`                | SM        | Initialize sprint tracking           |
-| `bmad-create-story`                   | `/bmad-create-story`                   | SM        | Create a story file                  |
-| `bmad-dev-story`                      | `/bmad-dev-story`                      | DEV       | Implement a story                    |
-| `bmad-code-review`                    | `/bmad-code-review`                    | DEV       | Review implemented code              |
+| **`bmad-help`** ⭐                    | `bmad-help`                               | Any       | **Your intelligent guide — ask anything!**      |
+| `bmad-create-prd`                | `bmad-create-prd`                     | PM        | Create Product Requirements Document            |
+| `bmad-create-architecture`            | `bmad-create-architecture`            | Architect | Create architecture document                     |
+| `bmad-generate-project-context`       | `bmad-generate-project-context`           | Analyst   | Create project context file                     |
+| `bmad-create-epics-and-stories`       | `bmad-create-epics-and-stories`       | PM        | Break down PRD into epics            |
+| `bmad-check-implementation-readiness` | `bmad-check-implementation-readiness` | Architect | Validate planning cohesion           |
+| `bmad-sprint-planning`                | `bmad-sprint-planning`                | SM        | Initialize sprint tracking           |
+| `bmad-create-story`                   | `bmad-create-story`                   | SM        | Create a story file                  |
+| `bmad-dev-story`                      | `bmad-dev-story`                      | DEV       | Implement a story                    |
+| `bmad-code-review`                    | `bmad-code-review`                    | DEV       | Review implemented code              |
 
 ## Common Questions
 
@@ -238,10 +240,10 @@ your-project/
 Only for BMad Method and Enterprise tracks. Quick Flow skips from tech-spec to implementation.
 
 **Can I change my plan later?**
-Yes. The SM agent has a `bmad-correct-course` workflow (`/bmad-correct-course`) for handling scope changes.
+Yes. The SM agent has a `bmad-correct-course` workflow (`bmad-correct-course`) for handling scope changes.
 
 **What if I want to brainstorm first?**
-Invoke the Analyst agent (`/bmad-analyst`) and run `bmad-brainstorming` (`/bmad-brainstorming`) before starting your PRD.
+Invoke the Analyst agent (`bmad-analyst`) and run `bmad-brainstorming` (`bmad-brainstorming`) before starting your PRD.
 
 **Do I need to follow a strict order?**
 Not strictly. Once you learn the flow, you can run workflows directly using the Quick Reference above.
@@ -249,7 +251,7 @@ Not strictly. Once you learn the flow, you can run workflows directly using the
 ## Getting Help
 
 :::tip[First Stop: BMad-Help]
-**Run `/bmad-help` anytime** — it's the fastest way to get unstuck. Ask it anything:
+**Invoke `bmad-help` anytime** — it's the fastest way to get unstuck. Ask it anything:
 - "What should I do after installing?"
 - "I'm stuck on workflow X"
 - "What are my options for Y?"
@@ -264,10 +266,10 @@ BMad-Help inspects your project, detects what you've completed, and tells you ex
 ## Key Takeaways
 
 :::tip[Remember These]
-- **Start with `/bmad-help`** — Your intelligent guide that knows your project and options
+- **Start with `bmad-help`** — Your intelligent guide that knows your project and options
 - **Always use fresh chats** — Start a new chat for each workflow
 - **Track matters** — Quick Flow uses quick-spec; Method/Enterprise need PRD and architecture
 - **BMad-Help runs automatically** — Every workflow ends with guidance on what's next
 :::
 
-Ready to start? Install BMad, run `/bmad-help`, and let your intelligent guide lead the way.
+Ready to start? Install BMad, invoke `bmad-help`, and let your intelligent guide lead the way.

package/docs/zh-cn/how-to/established-projects.md

@@ -61,7 +61,7 @@ sidebar:
 
 ### BMad-Help：你的起点
 
-**随时运行 `/bmad-help`，当你不确定下一步该做什么时。** 这个智能指南：
+**随时运行 `bmad-help`，当你不确定下一步该做什么时。** 这个智能指南：
 
 - 检查你的项目以查看已经完成了什么
 - 根据你安装的模块显示选项

package/docs/zh-cn/how-to/get-answers-about-bmad.md

@@ -7,7 +7,7 @@ sidebar:
 
 ## 从这里开始：BMad-Help
 
-**获取关于 BMad 答案的最快方式是 `/bmad-help`。** 这个智能指南可以回答超过 80% 的问题，并且直接在您的 IDE 中可用，方便您工作时使用。
+**获取关于 BMad 答案的最快方式是 `bmad-help`。** 这个智能指南可以回答超过 80% 的问题，并且直接在您的 IDE 中可用，方便您工作时使用。
 
 BMad-Help 不仅仅是一个查询工具——它：
 - **检查您的项目**以查看已完成的内容

package/docs/zh-cn/how-to/install-bmad.md

@@ -77,7 +77,7 @@ your-project/
 
 ## 验证安装
 
-运行 `/bmad-help` 来验证一切正常并查看下一步操作。
+运行 `bmad-help` 来验证一切正常并查看下一步操作。
 
 **BMad-Help 是你的智能向导**，它会：
 - 确认你的安装正常工作

package/docs/zh-cn/index.md

@@ -19,7 +19,7 @@ BMad 方法（**B**reakthrough **M**ethod of **A**gile AI **D**riven Development
 - **[工作流地图](./reference/workflow-map.md)** — BMM 阶段、工作流和上下文管理的可视化概览
 
 :::tip[只想直接上手？]
-安装 BMad 并运行 `/bmad-help` — 它会根据您的项目和已安装的模块引导您完成所有操作。
+安装 BMad 并运行 `bmad-help` — 它会根据您的项目和已安装的模块引导您完成所有操作。
 :::
 
 ## 如何使用本文档

package/docs/zh-cn/reference/commands.md

@@ -13,7 +13,7 @@ BMad 提供两种开始工作的方式，它们服务于不同的目的。
 
 | 机制 | 调用方式 | 发生什么 |
 | --- | --- | --- |
-| **斜杠命令** | 在 IDE 中输入 `/bmad-...` | 直接加载智能体、运行工作流或执行任务 |
+| **斜杠命令** | 在 IDE 中输入 `bmad-...` | 直接加载智能体、运行工作流或执行任务 |
 | **智能体菜单触发器** | 先加载智能体，然后输入简短代码（例如 `DS`） | 智能体解释代码并启动匹配的工作流，同时保持角色设定 |
 
 智能体菜单触发器需要活动的智能体会话。当您知道要使用哪个工作流时，使用斜杠命令。当您已经与智能体一起工作并希望在不离开对话的情况下切换任务时，使用触发器。
@@ -58,13 +58,13 @@ BMad 提供两种开始工作的方式，它们服务于不同的目的。
 └── ...
 ```
 
-文件名决定了 IDE 中的斜杠命令名称。例如，文件 `bmad-agent-bmm-dev.md` 注册命令 `/bmad-agent-bmm-dev`。
+文件名决定了 IDE 中的技能名称。例如，文件 `bmad-agent-bmm-dev.md` 注册技能 `bmad-agent-bmm-dev`。
 
 ## 如何发现您的命令
 
 在 IDE 中输入 `/bmad` 并使用自动完成功能浏览可用命令。
 
-运行 `/bmad-help` 获取关于下一步的上下文感知指导。
+运行 `bmad-help` 获取关于下一步的上下文感知指导。
 
 :::tip[快速发现]
 项目中生成的命令文件夹是权威列表。在文件资源管理器中打开它们以查看每个命令及其描述。
@@ -78,10 +78,10 @@ BMad 提供两种开始工作的方式，它们服务于不同的目的。
 
 | 示例命令 | 智能体 | 角色 |
 | --- | --- | --- |
-| `/bmad-agent-bmm-dev` | Amelia（开发者） | 严格按照规范实现故事 |
-| `/bmad-agent-bmm-pm` | John（产品经理） | 创建和验证 PRD |
-| `/bmad-agent-bmm-architect` | Winston（架构师） | 设计系统架构 |
-| `/bmad-agent-bmm-sm` | Bob（Scrum Master） | 管理冲刺和故事 |
+| `bmad-agent-bmm-dev` | Amelia（开发者） | 严格按照规范实现故事 |
+| `bmad-agent-bmm-pm` | John（产品经理） | 创建和验证 PRD |
+| `bmad-agent-bmm-architect` | Winston（架构师） | 设计系统架构 |
+| `bmad-agent-bmm-sm` | Bob（Scrum Master） | 管理冲刺和故事 |
 
 参见[智能体](./agents.md)获取默认智能体及其触发器的完整列表。
 
@@ -91,11 +91,11 @@ BMad 提供两种开始工作的方式，它们服务于不同的目的。
 
 | 示例命令 | 目的 |
 | --- | --- |
-| `/bmad-bmm-create-prd` | 创建产品需求文档 |
-| `/bmad-bmm-create-architecture` | 设计系统架构 |
-| `/bmad-bmm-dev-story` | 实现故事 |
-| `/bmad-bmm-code-review` | 运行代码审查 |
-| `/bmad-bmm-quick-spec` | 定义临时更改（快速流程） |
+| `bmad-bmm-create-prd` | 创建产品需求文档 |
+| `bmad-bmm-create-architecture` | 设计系统架构 |
+| `bmad-bmm-dev-story` | 实现故事 |
+| `bmad-bmm-code-review` | 运行代码审查 |
+| `bmad-bmm-quick-spec` | 定义临时更改（快速流程） |
 
 参见[工作流地图](./workflow-map.md)获取按阶段组织的完整工作流参考。
 
@@ -105,7 +105,7 @@ BMad 提供两种开始工作的方式，它们服务于不同的目的。
 
 #### BMad-Help：您的智能向导
 
-**`/bmad-help`** 是您发现下一步操作的主要界面。它不仅仅是一个查找工具——它是一个智能助手，可以：
+**`bmad-help`** 是您发现下一步操作的主要界面。它不仅仅是一个查找工具——它是一个智能助手，可以：
 
 - **检查您的项目**以查看已经完成的工作
 - **理解自然语言查询**——用简单的英语提问
@@ -116,19 +116,19 @@ BMad 提供两种开始工作的方式，它们服务于不同的目的。
 **示例：**
 
 ```
-/bmad-help
-/bmad-help 我有一个 SaaS 想法并且知道所有功能。我应该从哪里开始？
-/bmad-help 我在 UX 设计方面有哪些选择？
-/bmad-help 我在 PRD 工作流上卡住了
+bmad-help
+bmad-help 我有一个 SaaS 想法并且知道所有功能。我应该从哪里开始？
+bmad-help 我在 UX 设计方面有哪些选择？
+bmad-help 我在 PRD 工作流上卡住了
 ```
 
 #### 其他任务和工具
 
 | 示例命令 | 目的 |
 | --- | --- |
-| `/bmad-shard-doc` | 将大型 Markdown 文件拆分为较小的部分 |
-| `/bmad-index-docs` | 索引项目文档 |
-| `/bmad-editorial-review-prose` | 审查文档散文质量 |
+| `bmad-shard-doc` | 将大型 Markdown 文件拆分为较小的部分 |
+| `bmad-index-docs` | 索引项目文档 |
+| `bmad-editorial-review-prose` | 审查文档散文质量 |
 
 ## 命名约定
 

package/docs/zh-cn/reference/workflow-map.md

@@ -9,7 +9,7 @@ BMad Method（BMM）是 BMad 生态系统中的一个模块，旨在遵循上下
 
 其基本原理和概念来自敏捷方法论，这些方法论在整个行业中被广泛用作思维框架，并取得了巨大成功。
 
-如果您在任何时候不确定该做什么，`/bmad-help` 命令将帮助您保持正轨或了解下一步该做什么。您也可以随时参考此文档以获取参考信息——但如果您已经安装了 BMad Method，`/bmad-help` 是完全交互式的，速度要快得多。此外，如果您正在使用扩展了 BMad Method 或添加了其他互补非扩展模块的不同模块——`/bmad-help` 会不断演进以了解所有可用内容，从而为您提供最佳即时建议。
+如果您在任何时候不确定该做什么，`bmad-help` 命令将帮助您保持正轨或了解下一步该做什么。您也可以随时参考此文档以获取参考信息——但如果您已经安装了 BMad Method，`bmad-help` 是完全交互式的，速度要快得多。此外，如果您正在使用扩展了 BMad Method 或添加了其他互补非扩展模块的不同模块——`bmad-help` 会不断演进以了解所有可用内容，从而为您提供最佳即时建议。
 
 最后的重要说明：以下每个工作流程都可以通过斜杠命令直接使用您选择的工具运行，或者先加载智能体，然后使用智能体菜单中的条目来运行。
 
@@ -84,7 +84,7 @@ BMad Method（BMM）是 BMad 生态系统中的一个模块，旨在遵循上下
 **如何创建它：**
 
 - **手动** — 使用您的技术栈和实施规则创建 `_bmad-output/project-context.md`
-- **生成它** — 运行 `/bmad-bmm-generate-project-context` 以从您的架构或代码库自动生成
+- **生成它** — 运行 `bmad-bmm-generate-project-context` 以从您的架构或代码库自动生成
 
 [**了解更多关于 project-context.md**](../explanation/project-context.md)