opensource/BMAD-METHOD
3
0
Fork 0
mirror of https://github.com/bmad-code-org/BMAD-METHOD.git synced 2026-09-01 15:09:07 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
bb45db4aa4496c69239f9c0629c290fd1b072fc9
BMAD-METHOD/docs/cs/tutorials/getting-started.md
T
Brian bb45db4aa4 feat(core): consolidate research trio into bmad-deep-recon (#2611) 
* feat(bmm): consolidate research trio into bmad-deep-recon

Replace bmad-market-research, bmad-domain-research, and bmad-technical-research
(5,136 lines of near-duplicate legacy step files) with one modern skill,
bmad-deep-recon (~650 lines):

- Research-master-orchestrator persona; conclusions never rest on training
  data alone; lead-following rounds with coverage/novelty-exhaustion stops
- Six type packs as ~25-line policy+craft cards (market, domain, technical,
  competitive, user-voice, academic-lit) + select decision shape layering a
  weighted-matrix method over any type
- Three acquisition modes: Generate (subagent fan-out), Delegate (engine
  registry: CLI/MCP, engine-first strategy), Import (provenance-tracked)
- Claims-ledger verification (normal/high/max) with independence rules and
  optional red-team pass; cited synthesis with staleness map
- Effort presets (quick/standard/deep) over four knobs (subagents,
  sources/round, depth, validation); precedence request > knob > preset
- Plan gate with surface discovery (MCPs/CLIs/engines), routing table, and
  time estimate; use_workflows and subagent_models config
- Create/Refresh/Deepen intents, memlog run-folder workspace, headless JSON
- v6 shims forward the three old IDs with type pre-set; analyst menu,
  catalog, marketplace, docs and translation mirrors updated

* feat(bmm): runtime output_format for bmad-deep-recon (v7 artifact protocol)

Replace the output_formats array with output_format = auto|html|md|both
(default auto): interactive runs render the HTML briefing, headless or
skill-invoked runs present the canonical markdown only. research.md always
exists in the workspace as the machine-readable report; the briefing is its
regenerable face. First instance of the v7 artifact protocol (memlog = truth,
md = distillation under contract, html = face).

* feat(core): move bmad-deep-recon to core-skills; address review findings

Move: research is not code-project-specific — home it in core-skills
(brainstorming precedent) so CIS and core-only installs get it. Skill ID
unchanged; standalone marketplace plugin added; catalogs moved to Core;
{planning_artifacts} falls back to {output_folder} on core-only installs.
v6 shims stay in bmm-skills (the legacy trio were bmm skills).

Review fixes (CodeRabbit):
- Engine briefs are now file-based: invoke templates substitute
  {brief_file} (a skill-generated path), never inline brief text — quotes
  and shell metacharacters in researched content can't shape a command.
- Refresh/Deepen preserve verification statuses for out-of-scope claims.
- HTML briefing: http(s)-only source links, escape source-derived text.
- user-voice pack: redact usernames/handles/emails from verbatim quotes;
  communities complement surveys (triangulate) rather than beat them.
- engine.md: explicit single-writer rule — digests return to the lead,
  which alone writes research.md in plan order.

* feat(core): deep-recon v2 — draft/process/run, faster defaults, research firewall

Rework after first real-run feedback (slow, token-heavy, locally biased
report, end-pass verification degraded quality, digests stranded in
subagent contexts):

- Three modes replace the acquisition-mode machinery: Draft (build a
  deep-research prompt the user runs in their own subscribed tool),
  Process (file a finished report into imports/, extract to digests/,
  distill research.md summary + metadata so downstream never reprocesses),
  Run (native fan-out, first-class). Bare research asks get the choice up
  front with the trade stated honestly.
- Engine/Delegate registry cut: the Draft->Process round-trip is the
  integration with dedicated deep-research tools; engine.md -> run.md.
- Files-first: digests hit {doc_workspace}/digests/ on landing, sections
  commit per dimension, synthesis reads files never conversation memory,
  dead runs resume from disk.
- Research firewall: persistent_facts default now empty, assistants get
  only their brief, project context frames questions but is inadmissible
  as evidence.
- Verification at landing, not end-of-run: normal = spot-check
  load-bearing claims only; red_team default off; heavy passes behind
  high/max. Presets rescaled faster (standard 3 subagents/8 sources/
  depth 2).
- Multi-agent research lessons folded into run.md and the plan gate:
  decomposition topology (breadth/depth/straightforward), per-assistant
  tool-call budgets, query craft with OODA pause, shared source-quality
  card, stop-and-write valve, mechanical citation check at finalize.
- Ripple: v6 shims, catalogs, marketplace, docs one-liners (all five
  languages), template gains source: provenance field.

* feat(core): deep-recon quality pass — carve SKILL.md, recon_kit scripts, single-source verification

- SKILL.md 3989→2091 tokens: Draft/Process/Refresh+Deepen/Finalize carved to
  references/{draft,process,lifecycle,finalize}.md; Run effort knobs + plan
  gate moved into run.md; Overview and pack prose trimmed
- verification.md: red-team pass is the single adversarial mechanism (max
  runs it at full breadth — no double-spawn); level semantics single-sourced
- scripts/recon_kit.py + tests: citations cross-check, memlog claim tally
  (ref=/status= convention, last wins), staleness date math from per-class
  windows, deterministic run-folder slugs, escaped source-appendix HTML
- Draft wired with preferred/banned source policies and an open-floor opening
- external_sources examples (Tavily/Sonar/xAI X-Search MCPs); source-quality
  card: answer engines are aggregators — chase their citations

* docs: Deep Recon explanation page + integration

- new docs/explanation/deep-recon.md: three modes, mode-choice guidance,
  research types, native-run internals diagram, firewall/verification, refresh
- analysis-phase.md research section rewritten for bmad-deep-recon
- core-tools.md: deep-recon in thinking-skills table, full catalog entry,
  migration note for the merged market/domain/technical trio
- workflow-map.md + getting-started.md link the new page
- vi-vn developer guide: last stale old-skill flow mention updated
2026-07-22 21:49:24 -05:00

277 lines
14 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
---
title: "Začínáme"
description: Nainstalujte BMad a vytvořte svůj první projekt
---
Vytvářejte software rychleji pomocí pracovních postupů řízených AI se specializovanými agenty, kteří vás provedou plánováním, architekturou a implementací.
## Co se naučíte
- Nainstalovat a inicializovat BMad Method pro nový projekt
- Používat **BMad-Help** — vašeho inteligentního průvodce, který ví, co dělat dál
- Vybrat správnou plánovací cestu pro velikost vašeho projektu
- Postupovat fázemi od požadavků k fungujícímu kódu
- Efektivně používat agenty a pracovní postupy
:::note[Předpoklady]
- **Node.js 20.12+** — Vyžadováno pro instalátor
- **Git** — Doporučeno pro správu verzí
- **AI-powered IDE** — Claude Code, Cursor nebo podobné
- **Nápad na projekt** — I jednoduchý stačí pro učení
:::
:::tip[Nejsnadnější cesta]
**Instalace** → `npx bmad-method install`
**Zeptejte se** → `bmad-help what should I do first?`
**Tvořte** → Nechte BMad-Help vás provést workflow po workflow
:::
## Seznamte se s BMad-Help: Váš inteligentní průvodce
**BMad-Help je nejrychlejší způsob, jak začít s BMad.** Nemusíte si pamatovat workflow nebo fáze — prostě se zeptejte a BMad-Help:
- **Prozkoumá váš projekt** a zjistí, co už bylo uděláno
- **Ukáže vaše možnosti** na základě nainstalovaných modulů
- **Doporučí, co dál** — včetně prvního povinného úkolu
- **Odpoví na otázky** jako „Mám nápad na SaaS, kde začít?“
### Jak používat BMad-Help
Spusťte ho ve vašem AI IDE vyvoláním skillu:
```
bmad-help
```
Nebo ho spojte s otázkou pro kontextové poradenství:
```
bmad-help I have an idea for a SaaS product, I already know all the features I want. where do I get started?
```
BMad-Help odpoví s:
- Co je doporučeno pro vaši situaci
- Jaký je první povinný úkol
- Jak vypadá zbytek procesu
### Řídí i pracovní postupy
BMad-Help nejen odpovídá na otázky — **automaticky se spouští na konci každého workflow** a řekne vám přesně, co dělat dál. Žádné hádání, žádné prohledávání dokumentace — jen jasné pokyny k dalšímu povinnému workflow.
:::tip[Začněte zde]
Po instalaci BMad okamžitě vyvolejte skill `bmad-help`. Detekuje, jaké moduly máte nainstalované, a navede vás ke správnému výchozímu bodu pro váš projekt.
:::
## Pochopení BMad
BMad vám pomáhá vytvářet software prostřednictvím řízených pracovních postupů se specializovanými AI agenty. Proces probíhá ve čtyřech fázích:
| Fáze | Název | Co se děje |
| ---- | -------------- | ------------------------------------------------------- |
| 1 | Analýza | Brainstorming, průzkum, product brief nebo PRFAQ *(volitelné)* |
| 2 | Plánování | Vytvoření požadavků (PRD nebo specifikace) |
| 3 | Solutioning | Návrh architektury *(pouze BMad Method/Enterprise)* |
| 4 | Implementace | Budování epic po epicu, story po story |
**[Otevřete Mapu pracovních postupů](../reference/workflow-map.md)** pro prozkoumání fází, workflow a správy kontextu.
Na základě složitosti vašeho projektu nabízí BMad tři plánovací cesty:
| Cesta | Nejlepší pro | Vytvořené dokumenty |
| --------------- | -------------------------------------------------------------- | -------------------------------------- |
| **Quick Flow** | Opravy chyb, jednoduché funkce, jasný rozsah (1–15 stories) | Pouze tech-spec |
| **BMad Method** | Produkty, platformy, složité funkce (10–50+ stories) | PRD + architektura + UX |
| **Enterprise** | Compliance, multi-tenant systémy (30+ stories) | PRD + architektura + bezpečnost + DevOps |
:::note
Počty stories jsou orientační, ne definitivní. Vyberte si cestu podle potřeb plánování, ne podle počtu stories.
:::
## Instalace
Otevřete terminál v adresáři vašeho projektu a spusťte:
```bash
npx bmad-method install
```
Pokud chcete nejnovější prereleaseový build místo výchozího release kanálu, použijte `npx bmad-method@next install`.
Při výzvě k výběru modulů zvolte **BMad Method**.
Instalátor vytvoří dvě složky:
- `_bmad/` — agenti, workflow, úkoly a konfigurace
- `_bmad-output/` — prozatím prázdná, ale zde se budou ukládat vaše artefakty
:::tip[Váš další krok]
Otevřete vaše AI IDE ve složce projektu a spusťte:
```
bmad-help
```
BMad-Help detekuje, co jste dokončili, a doporučí přesně, co dělat dál. Můžete mu také klást otázky jako „Jaké mám možnosti?“ nebo „Mám nápad na SaaS, kde začít?“
:::
:::note[Jak načítat agenty a spouštět workflow]
Každý workflow má **skill**, který vyvoláte jménem ve vašem IDE (např. `bmad-prd`). Váš AI nástroj rozpozná název `bmad-*` a spustí ho — nemusíte načítat agenty zvlášť. Můžete také vyvolat agentní skill přímo pro obecnou konverzaci (např. `bmad-agent-pm` pro PM agenta).
:::
:::caution[Nové chaty]
Vždy začněte nový chat pro každý workflow. Tím předejdete problémům s kontextovými omezeními.
:::
## Krok 1: Vytvořte svůj plán
Projděte fázemi 1–3. **Pro každý workflow používejte nové chaty.**
:::tip[Kontext projektu (volitelné)]
Před začátkem zvažte vytvoření `project-context.md` pro dokumentaci vašich technických preferencí a pravidel implementace. Tím zajistíte, že všichni AI agenti budou dodržovat vaše konvence v průběhu celého projektu.
Vytvořte ho ručně na `_bmad-output/project-context.md` nebo ho vygenerujte po architektuře pomocí `bmad-generate-project-context`. [Zjistit více](../explanation/project-context.md).
:::
### Fáze 1: Analýza (volitelná)
Všechny workflow v této fázi jsou volitelné:
- **brainstorming** (`bmad-brainstorming`) — Řízená ideace
- **průzkum** (`bmad-deep-recon`) — Navrhne prompt pro váš vlastní nástroj hloubkového výzkumu, zpracuje hotovou zprávu do stručného shrnutí pro navazující práci, nebo výzkum provede přímo — tržní, doménový, technický, konkurenční, uživatelský a akademický — s ověřováním tvrzení a životním cyklem obnovy
- **product-brief** (`bmad-product-brief`) — Doporučený základní dokument, když je váš koncept jasný
- **prfaq** (`bmad-prfaq`) — Working Backwards výzva pro zátěžový test a zformování vašeho produktového konceptu
### Fáze 2: Plánování (povinná)
**Pro BMad Method a Enterprise cesty:**
1. Vyvolejte **PM agenta** (`bmad-agent-pm`) v novém chatu
2. Spusťte workflow `bmad-prd` (`bmad-prd`)
3. Výstup: `PRD.md`
**Pro Quick Flow cestu:**
- Spusťte `bmad-quick-dev` — zvládne plánování i implementaci v jednom workflow, přeskočte k implementaci
:::note[UX Design (volitelné)]
Pokud má váš projekt uživatelské rozhraní, vyvolejte **UX-Designer agenta** (`bmad-agent-ux-designer`) a spusťte UX design workflow (`bmad-ux`) po vytvoření PRD.
:::
### Fáze 3: Solutioning (BMad Method/Enterprise)
**Vytvoření architektury**
1. Vyvolejte **Architect agenta** (`bmad-agent-architect`) v novém chatu
2. Spusťte `bmad-architecture` (`bmad-architecture`)
3. Výstup: Dokument architektury s technickými rozhodnutími
**Vytvoření epiců a stories**
:::tip[Vylepšení ve V6]
Epicy a stories se nyní vytvářejí *po* architektuře. Tím vznikají kvalitnější stories, protože architektonická rozhodnutí (databáze, API vzory, tech stack) přímo ovlivňují rozklad práce.
:::
1. Vyvolejte **PM agenta** (`bmad-agent-pm`) v novém chatu
2. Spusťte `bmad-create-epics-and-stories` (`bmad-create-epics-and-stories`)
3. Workflow využívá jak PRD, tak architekturu k vytvoření technicky informovaných stories
**Kontrola připravenosti k implementaci** *(vysoce doporučeno)*
1. Vyvolejte **Architect agenta** (`bmad-agent-architect`) v novém chatu
2. Spusťte `bmad-check-implementation-readiness` (`bmad-check-implementation-readiness`)
3. Validuje soudržnost všech plánovacích dokumentů
## Krok 2: Sestavte svůj projekt
Jakmile je plánování dokončeno, přejděte k implementaci. **Každý workflow by měl běžet v novém chatu.**
### Inicializace plánování sprintu
Vyvolejte **Developer agenta** (`bmad-agent-dev`) a spusťte `bmad-sprint-planning` (`bmad-sprint-planning`). Tím se vytvoří `sprint-status.yaml` pro sledování všech epiců a stories.
### Cyklus vývoje
Pro každou story opakujte tento cyklus s novými chaty:
| Krok | Agent | Workflow | Příkaz | Účel |
| ---- | ----- | -------------------- | -------------------------- | ---------------------------------- |
| 1 | DEV | `bmad-create-story` | `bmad-create-story` | Vytvoření story souboru z epicu |
| 2 | DEV | `bmad-dev-story` | `bmad-dev-story` | Implementace story |
| 3 | DEV | `bmad-code-review` | `bmad-code-review` | Validace kvality *(doporučeno)* |
Po dokončení všech stories v epicu vyvolejte **Developer agenta** (`bmad-agent-dev`) a spusťte `bmad-retrospective` (`bmad-retrospective`).
## Co jste dosáhli
Naučili jste se základy budování s BMad:
- Nainstalovali BMad a nakonfigurovali ho pro vaše IDE
- Inicializovali projekt s vybranou plánovací cestou
- Vytvořili plánovací dokumenty (PRD, architektura, epicy a stories)
- Pochopili cyklus vývoje pro implementaci
Váš projekt nyní obsahuje:
```text
váš-projekt/
├── _bmad/ # Konfigurace BMad
├── _bmad-output/
│ ├── planning-artifacts/
│ │ ├── PRD.md # Váš dokument požadavků
│ │ ├── architecture.md # Technická rozhodnutí
│ │ └── epics/ # Soubory epiců a stories
│ ├── implementation-artifacts/
│ │ └── sprint-status.yaml # Sledování sprintu
│ └── project-context.md # Pravidla implementace (volitelné)
└── ...
```
## Rychlý přehled
| Workflow | Příkaz | Agent | Účel |
| ------------------------------------- | ------------------------------------------ | --------- | ----------------------------------------------- |
| **`bmad-help`** ⭐ | `bmad-help` | Jakýkoli | **Váš inteligentní průvodce — ptejte se na cokoli!** |
| `bmad-prd` | `bmad-prd` | PM | Vytvoření dokumentu požadavků (PRD) |
| `bmad-architecture` | `bmad-architecture` | Architect | Vytvoření dokumentu architektury |
| `bmad-generate-project-context` | `bmad-generate-project-context` | Analyst | Vytvoření souboru kontextu projektu |
| `bmad-create-epics-and-stories` | `bmad-create-epics-and-stories` | PM | Rozklad PRD na epicy |
| `bmad-check-implementation-readiness` | `bmad-check-implementation-readiness` | Architect | Validace soudržnosti plánování |
| `bmad-sprint-planning` | `bmad-sprint-planning` | DEV | Inicializace sledování sprintu |
| `bmad-create-story` | `bmad-create-story` | DEV | Vytvoření souboru story |
| `bmad-dev-story` | `bmad-dev-story` | DEV | Implementace story |
| `bmad-code-review` | `bmad-code-review` | DEV | Revize implementovaného kódu |
## Časté otázky
**Potřebuji vždy architekturu?**
Pouze pro BMad Method a Enterprise cesty. Quick Flow přeskakuje ze specifikace rovnou k implementaci.
**Mohu později změnit svůj plán?**
Ano. Workflow `bmad-correct-course` (`bmad-correct-course`) řeší změny rozsahu během implementace.
**Co když chci nejdřív brainstormovat?**
Vyvolejte Analyst agenta (`bmad-agent-analyst`) a spusťte `bmad-brainstorming` (`bmad-brainstorming`) před zahájením PRD.
**Musím dodržovat striktní pořadí?**
Ne striktně. Jakmile se naučíte postup, můžete spouštět workflow přímo pomocí Rychlého přehledu výše.
## Získání pomoci
:::tip[První zastávka: BMad-Help]
**Vyvolejte `bmad-help` kdykoli** — je to nejrychlejší způsob, jak se odpoutat. Zeptejte se na cokoli:
- „Co mám dělat po instalaci?“
- „Zasekl jsem se na workflow X“
- „Jaké mám možnosti pro Y?“
- „Ukaž mi, co bylo dosud uděláno“
BMad-Help prozkoumá váš projekt, detekuje, co jste dokončili, a řekne vám přesně, co dělat dál.
:::
- **Během workflow** — Agenti vás provázejí otázkami a vysvětleními
- **Komunita** — [Discord](https://discord.gg/gk8jAdXWmj) (#bmad-method-help, #report-bugs-and-issues)
## Klíčové poznatky
:::tip[Zapamatujte si]
- **Začněte s `bmad-help`** — Váš inteligentní průvodce, který zná váš projekt a možnosti
- **Vždy používejte nové chaty** — Začněte nový chat pro každý workflow
- **Cesta záleží** — Quick Flow používá `bmad-quick-dev`; Method/Enterprise vyžadují PRD a architekturu
- **BMad-Help se spouští automaticky** — Každý workflow končí pokyny, co dělat dál
:::
Jste připraveni začít? Nainstalujte BMad, vyvolejte `bmad-help` a nechte svého inteligentního průvodce ukázat cestu.
Reference in New Issue View Git Blame Copy Permalink