refactor: consolidate agents into phase-based skill directories (#2050)

* refactor: consolidate agents into phase-based skill directories

Remove separate agent/workflow/skill directories (src/bmm/agents,
src/bmm/workflows, src/core/skills, src/utility/agent-components) and
reorganize all content into phase-based structures under src/bmm-skills
(1-analysis, 2-plan-workflows, 3-solutioning, 4-implementation) and
src/core-skills. Eliminates the agent/skill distinction by treating
agents as skills within their workflow phase.

* fix: update broken file references to use new bmm-skills paths

* docs: update all references for unified bmad-quick-dev workflow

Remove all references to the old separate bmad-quick-spec and
bmad-quick-dev-new-preview workflows. The new bmad-quick-dev is a
unified workflow that handles intent clarification, planning,
implementation, review, and presentation in a single run.

Updated files across English docs, Chinese translations, source
skill manifests, website diagram, and build tooling.

Author: bmadcode

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

@@ -5,11 +5,7 @@ sidebar:
   order: 1
 ---
 
-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).
-:::
+Skip the ceremony. Quick Flow takes you from intent to working code in a single workflow — no Product Brief, no PRD, no Architecture doc.
 
 ## When to Use It
 
@@ -32,31 +28,33 @@ If you start a Quick Flow and realize the scope is bigger than expected, `bmad-q
 
 ## How It Works
 
-Quick Flow has two skills, each backed by a structured workflow. You can run them together or independently.
+Run `bmad-quick-dev` and the workflow handles everything — clarifying intent, planning, implementing, reviewing, and presenting results.
 
-### quick-spec: Plan
+### 1. Clarify intent
 
-Run `bmad-quick-spec` and Barry (the Quick Flow agent) walks you through a conversational discovery process:
+You describe what you want. The workflow compresses your request into one coherent goal — small enough, clear enough, and contradiction-free enough to execute safely. Intent can come from many sources: a few phrases, a bug tracker link, plan mode output, chat session text, or even a story number from your epics.
 
-1. **Understand** - You describe what you want to build. Barry scans the codebase to ask informed questions, then captures a problem statement, solution approach, and scope boundaries.
-2. **Investigate** - Barry reads relevant files, maps code patterns, identifies files to modify, and documents the technical context.
-3. **Generate** - Produces a complete tech-spec with ordered implementation tasks (specific file paths and actions), acceptance criteria in Given/When/Then format, testing strategy, and dependencies.
-4. **Review** - Presents the full spec for your sign-off. You can edit, ask questions, run adversarial review, or refine with advanced elicitation before finalizing.
+### 2. Route to the smallest safe path
 
-The output is a `tech-spec-{slug}.md` file saved to your project's implementation artifacts folder. It contains everything a fresh agent needs to implement the feature - no conversation history required.
+Once the goal is clear, the workflow decides whether this is a true one-shot change or needs the fuller path. Small, zero-blast-radius changes go straight to implementation. Everything else goes through planning so the model has a stronger boundary before running autonomously.
 
-### quick-dev: Build
+### 3. Plan and implement
 
-Run `bmad-quick-dev` and Barry implements the work. It operates in two modes:
+On the planning path, the workflow produces a complete tech-spec with ordered implementation tasks, acceptance criteria in Given/When/Then format, and testing strategy. After you approve the spec, it becomes the boundary the model executes against with less supervision.
 
-- **Tech-spec mode** - Point it at a spec file (`quick-dev tech-spec-auth.md`) and it executes every task in order, writes tests, and verifies acceptance criteria.
-- **Direct mode** - Give it instructions directly (`quick-dev "refactor the auth middleware"`) and it gathers context, builds a mental plan, and executes.
+### 4. Review and present
 
-After implementation, `bmad-quick-dev` runs a self-check audit against all tasks and acceptance criteria, then triggers an adversarial code review of the diff. Findings are presented for you to resolve before wrapping up.
+After implementation, the workflow runs a self-check audit and adversarial code review of the diff. Review acts as triage — findings tied to the current change are addressed, while incidental findings are deferred to keep the run focused. Results are presented for your sign-off.
 
-:::tip[Fresh Context]
-For best results, run `bmad-quick-dev` in a new conversation after finishing `bmad-quick-spec`. This gives the implementation agent clean context focused solely on building.
-:::
+### Human-in-the-loop checkpoints
+
+The workflow relocates human control to a small number of high-value moments:
+
+- **Intent clarification** — turning a messy request into one coherent goal
+- **Spec approval** — confirming the frozen understanding is the right thing to build
+- **Final review** — deciding whether the result is acceptable
+
+Between these checkpoints, the model runs longer with less supervision. This is deliberate — it trades continuous supervision for focused human attention at moments with the highest leverage.
 
 ## What Quick Flow Skips
 
@@ -69,9 +67,9 @@ The full BMad Method produces a Product Brief, PRD, Architecture doc, and Epic/S
 
 ## Escalating to Full BMad Method
 
-Quick Flow includes built-in guardrails for scope detection. When you run `bmad-quick-dev` with a direct request, it evaluates signals like multi-component mentions, system-level language, and uncertainty about approach. If it detects the work is bigger than a quick flow:
+Quick Flow includes built-in guardrails for scope detection. When you run `bmad-quick-dev`, it evaluates signals like multi-component mentions, system-level language, and uncertainty about approach. If it detects the work is bigger than a quick flow:
 
-- **Light escalation** - Recommends running `bmad-quick-spec` first to create a plan
-- **Heavy escalation** - Recommends switching to the full BMad Method PRD process
+- **Light escalation** — Recommends creating a plan before implementation
+- **Heavy escalation** — Recommends switching to the full BMad Method PRD process
 
-You can also escalate manually at any time. Your tech-spec work carries forward - it becomes input for the broader planning process rather than being discarded.
+You can also escalate manually at any time. Your tech-spec work carries forward — it becomes input for the broader planning process rather than being discarded.

docs/explanation/quick-flow.md

@@ -81,7 +81,7 @@ You have two primary options depending on the scope of changes:
 
 | Scope                          | Recommended Approach                                                                                                          |
 | ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------- |
-| **Small updates or additions** | Use `bmad-quick-flow-solo-dev` to create a tech-spec and implement the change. The full four-phase BMad Method is likely overkill. |
+| **Small updates or additions** | Run `bmad-quick-dev` to clarify intent, plan, implement, and review in a single workflow. The full four-phase BMad Method is likely overkill. |
 | **Major changes or additions** | Start with the BMad Method, applying as much or as little rigor as needed.                                                    |
 
 ### During PRD Creation

docs/how-to/established-projects.md

@@ -83,7 +83,7 @@ https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt
 :::note[Example]
 **Q:** "Tell me the fastest way to build something with BMad"
 
-**A:** Use Quick Flow: Run `bmad-quick-spec` to write a technical specification, then `bmad-quick-dev` to implement it—skipping the full planning phases.
+**A:** Use Quick Flow: Run `bmad-quick-dev` — it clarifies your intent, plans, implements, reviews, and presents results in a single workflow, skipping the full planning phases.
 :::
 
 ## What You Get

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

@@ -24,7 +24,7 @@ Use the **DEV agent** directly for bug fixes, refactorings, or small targeted ch
 | Situation | Agent | Why |
 | --- | --- | --- |
 | Fix a specific bug or make a small, scoped change | **DEV agent** | Jumps straight into implementation without planning overhead |
-| Change touches several files or you want a written plan first | **Quick Flow Solo Dev** | Creates a quick-spec before implementation so the agent stays aligned to your standards |
+| Change touches several files or you want a written plan first | **Quick Flow Solo Dev** | Clarifies intent, plans, implements, and reviews in a single workflow so the agent stays aligned to your standards |
 
 If you are unsure, start with the DEV agent. You can always escalate to Quick Flow if the change grows.
 
@@ -44,7 +44,7 @@ This loads the agent's persona and capabilities into the session. If you decide
 bmad-quick-flow-solo-dev
 ```
 
-Once the Solo Dev agent is loaded, describe your change and ask it to create a **quick-spec**. The agent drafts a lightweight spec capturing what you want to change and how. After you approve the quick-spec, tell the agent to start the **Quick Flow dev cycle** -- it will implement the change, run tests, and perform a self-review, all guided by the spec you just approved.
+Once the Solo Dev agent is loaded, describe your change and tell it to run **quick-dev**. The workflow will clarify your intent, create a plan, implement the change, run a code review, and present results — all in a single run.
 
 :::tip[Fresh Chats]
 Always start a new chat session when loading an agent. Reusing a session from a previous workflow can cause context conflicts.

docs/how-to/quick-fixes.md

@@ -97,7 +97,7 @@ Workflow skills run a structured, multi-step process without loading an agent pe
 | `bmad-create-epics-and-stories` | Create epics and stories |
 | `bmad-dev-story` | Implement a story |
 | `bmad-code-review` | Run a code review |
-| `bmad-quick-spec` | Define an ad-hoc change (Quick Flow) |
+| `bmad-quick-dev` | Unified quick flow — clarify intent, plan, implement, review, present |
 
 See [Workflow Map](./workflow-map.md) for the complete workflow reference organized by phase.
 

docs/reference/commands.md

@@ -66,10 +66,9 @@ Build it, one story at a time. Coming soon, full phase 4 automation!
 
 Skip phases 1-3 for small, well-understood work.
 
-| Workflow              | Purpose                                    | Produces                                      |
-| --------------------- | ------------------------------------------ | --------------------------------------------- |
-| `bmad-quick-spec` | Define an ad-hoc change                    | `tech-spec.md` (story file for small changes) |
-| `bmad-quick-dev`  | Implement from spec or direct instructions | Working code + tests                          |
+| Workflow           | Purpose                                                                     | Produces               |
+| ------------------ | --------------------------------------------------------------------------- | ---------------------- |
+| `bmad-quick-dev`   | Unified quick flow — clarify intent, plan, implement, review, and present   | `tech-spec.md` + code  |
 
 ## Context Management
 

docs/reference/workflow-map.md

@@ -146,7 +146,7 @@ All workflows in this phase are optional:
 3. Output: `PRD.md`
 
 **For Quick Flow track:**
-- Use the `bmad-quick-spec` workflow (`bmad-quick-spec`) instead of PRD, then skip to implementation
+- Run `bmad-quick-dev` — it handles planning and implementation in a single workflow, 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.
@@ -268,7 +268,7 @@ BMad-Help inspects your project, detects what you've completed, and tells you ex
 :::tip[Remember These]
 - **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
+- **Track matters** — Quick Flow uses `bmad-quick-dev`; Method/Enterprise need PRD and architecture
 - **BMad-Help runs automatically** — Every workflow ends with guidance on what's next
 :::