# Tutorial: von der Idee zum Schwarm > Kompletter Durchgang mit echter Ausgabe: installieren, Atelier fragt zuerst, Briefing, simuliertes Panel im Budget, ehrliche Auswertung, Deinstallation mit erhaltenem Gedächtnis. Canonical: https://bmad-plus.rochetta.fr/de/docs/guides/idea-to-swarm/ Language: de BMAD+ version: 0.23.1 Documentation reviewed: 2026-10-19 Author: Laurent Rochetta License: MIT BMAD+ Dokumentation › [Anleitungen](https://bmad-plus.rochetta.fr/de/docs/guides/) › Tutorial: von der Idee zum Schwarm Dieses Tutorial begleitet eine kleine Idee von der ersten Frage bis zur letzten Datei. Das Szenario: Eine Kaffeebar namens Orbit möchte eine Landingpage, deren einzige Aufgabe es ist, einen neuen Besucher dazu zu bringen, eine Treuekarte zu eröffnen. Du lässt Atelier (den Design-Agent) dich befragen, bevor er irgendetwas anfasst, testest den Pitch der Bar an einem Panel simulierter Käufer, liest das Ergebnis, ohne dir etwas vorzumachen, und entfernst dann BMAD+, während das Projektgedächtnis bleibt. Jeder Terminal-Block unten ist eine echte Ausgabe. > **Hinweis · Was echt ist und was nicht** Die Befehle und ihre Ausgabe sind echt (BMAD+ 0.23.0, auf einem Testserver in einem Wegwerf-Projekt ausgeführt). Es lief kein Modell. Wo ein Sub-Agent eine Antwort schreiben würde, schreibt das Tutorial fünf von Hand und sagt das; die Zitate in der Auswertung sind daher Demonstrationstext, keine Worte von Käufern. Die Kaffeebar ist erfunden, und ihr Pitch und ihr Profil sind die Test-Fixtures des BMAD+-Repositorys. ## Schritt 1. core und design (und memory) installieren Core bringt die vier Agenten und die Skills für Intake, Schwarm und Abnahme. Design bringt Atelier und seinen Intake. Das Memory-Pack kommt dazu, damit es am Ende des Tutorials etwas zu bewahren gibt. Das Design-Pack bezieht seine drei Skills bei der Installation aus dem Paket `design-skill`; dieser Schritt braucht also Zugriff auf die Pakete, von denen BMAD+ abhängt, wie jeder Lauf von `npx bmad-plus`. **Installation und Gesundheitsprüfung** ```text $ npx bmad-plus install --yes --lang en --packs core,design,memory --tools claude-code ◆ Selected packs: ⚙️ Core, 🧠 Memory, 🎨 Design ● 🧠 Global brain created: /work/demo/home/.bmad-plus/brain ◇ ✅ 6 agents, 9 skills, 5 files copied ◇ ✅ 1 IDE(s) configured │ 🎨 Design: "/design read" → Atelier interviews you, then builds └ BMAD+ is ready! Talk to Atlas to get started 🚀 $ npm install --save-dev bmad-plus # Einmalig, damit die `npx --no-install`-Befehle unten eine lokale Kopie finden (npm gibt eine eigene Zusammenfassung aus, hier nicht wiedergegeben). Ohne sie brechen sie mit „npx canceled due to missing packages and no YES option“ ab. $ npx --no-install bmad-plus doctor │ 98/98 checks passed │ 0 error(s), 0 warning(s) │ Ownership inventory: complete # Auszug. Das globale Brain wurde in einem Wegwerf-Home-Verzeichnis angelegt, weil auf dieser Maschine keines existierte. ``` Ausgabe eines echten Laufs. Quelle: Auf einem Testserver am 2026-10-18 mit dem Quellcode 0.23.0 (tools/cli/bmad-plus-cli.js) in einem Wegwerf-Git-Projekt nachgespielt ## Schritt 2. Atelier zuerst fragen lassen Tippe im Chat deines KI-Tools `/design read`. Atelier fängt nicht an zu entwerfen: Er führt den Intake des Design-Packs aus. Hinter dem Gespräch ruft er `bmad-plus intake plan` auf, stellt dir den ersten Block (höchstens sechs Fragen, die drei Pflichtfragen zuerst) und erfasst dann deine Antworten. Du antwortest in eigenen Worten; das Protokoll unten zeigt die Befehle, die der Assistent für dich ausführt. ### Das Design Read starten Nutze es mit installiertem Design-Pack im Chat deines KI-Tools. **In deinem KI-Assistenten** ```text /design read für die Startseite von Orbit, einer Kaffeebar. Ich antworte mit meinen Worten, immer ein paar Fragen auf einmal. ``` **Das solltest du erhalten** Atelier stellt den ersten Block der Fragen des Intakes `design-read`: um welche Oberfläche es geht, wer sie in welcher Situation nutzt und die eine Aufgabe, die die Seite erfüllen muss, dann Markenelemente, Designsystem und ästhetische Familie. Er erfasst, was du sagst, sobald du antwortest, als `answered` in `_bmad-output/design/intake.json`, schlägt Standardwerte vor, wo er kann, und wartet. Es wird noch kein Briefing erzeugt und noch nichts gestaltet. **Was der Assistent ausführt, während du antwortest** ```text $ npx --no-install bmad-plus intake check .agents/skills/pack-design/intake.yaml .agents/skills/pack-design/intake.yaml: valid intake design-read (design), 13 questions, 3 must-have. $ npx --no-install bmad-plus intake plan --intake .agents/skills/pack-design/intake.yaml --answers _bmad-output/design/intake.json design-read (design): not ready — 0 answered, 0 defaulted, 0 unknown, 13 not asked yet. Must-haves still open: surface_kind, audience, job # Exit-Code 2. Die Liste „Ask next“ (sechs Fragen) folgt in der echten Ausgabe. $ npx --no-install bmad-plus intake record --intake .agents/skills/pack-design/intake.yaml --answers _bmad-output/design/intake.json --set surface_kind=landing --set "audience=Urban professionals who buy coffee most days; on a phone, on the way to work, a few seconds of attention" --set "job=Get a first-time visitor to open a loyalty card; success is the sign-up button being tapped" Recorded surface_kind, audience, job in _bmad-output/design/intake.json. design-read (design): ready — 3 answered, 0 defaulted, 0 unknown, 10 not asked yet. $ npx --no-install bmad-plus intake record --intake .agents/skills/pack-design/intake.yaml --answers _bmad-output/design/intake.json --set brand_assets=partial --default design_system --default aesthetic_family --set motion=3 --set variance=UNKNOWN Recorded brand_assets, motion, variance, design_system, aesthetic_family in _bmad-output/design/intake.json. design-read (design): ready — 5 answered, 2 defaulted, 1 unknown, 5 not asked yet. Unknown: variance $ npx --no-install bmad-plus intake render --intake .agents/skills/pack-design/intake.yaml --answers _bmad-output/design/intake.json --out _bmad-output/design/brief.md Brief written to _bmad-output/design/brief.md (3043 bytes); the intake is ready. ``` Ausgabe eines echten Laufs. Quelle: Auf einem Testserver am 2026-10-18 mit dem Quellcode 0.23.0 (tools/cli/bmad-plus-cli.js) in einem Wegwerf-Git-Projekt nachgespielt ## Schritt 3. Das Briefing lesen, bevor etwas gebaut wird Öffne `_bmad-output/design/brief.md`. Es ist der Vertrag für die weitere Arbeit, prüfe also drei Dinge. Erstens: Die drei Pflichtangaben sagen, was du meintest. Zweitens: Die als „proposed default, not confirmed by the user“ markierten Antworten (hier Designsystem `none` und ästhetische Familie `none`) sind akzeptable Vorschläge und keine Tatsachen, die du genannt hast. Drittens: die Liste „Open questions“ am Ende: Hier ist `variance` unbekannt, und `density`, `stack`, `accessibility_target`, `languages` und `required_states` wurden noch nicht gefragt. Atelier setzt einen offenen Regler aus der Oberfläche und vermerkt, dass er ihn abgeleitet hat; den Stack liest er aus dem Repository. Wenn dir eine fehlende Antwort wichtig ist (etwa die Sprachen der Seite), gib sie jetzt mit einem weiteren `intake record` an. ## Schritt 4. Aus dem Briefing bauen Fordere nun den Bau an. Atelier öffnet seinen Skill `design`, dessen erster Schritt durch das Briefing erfüllt ist (er stellt dieselben Fragen nicht zweimal), und baut die Landingpage im aus dem Repository gelesenen Stack. Nach den Regeln des Design-Packs behält das Ergebnis den Status jeder Antwort an der Stelle, an der sie genutzt wurde (ein Standard oder eine Ableitung wird gekennzeichnet), trägt unbekannte Pflichtangaben mit ihrem Risiko im ersten Absatz und endet mit der Auslieferungs-Checkliste des Skills, sodass „bereit“ oder „nicht bereit“ aus der Checkliste kommt und nicht aus dem Aussehen der Seite. Dieses Tutorial gibt das Ergebnis nicht wieder: Es ist keine CLI-Ausgabe, und kein Modell lief. ### Die Seite aus dem erfassten Briefing bauen Nutze es, wenn das Briefing gerendert und gelesen ist. **In deinem KI-Assistenten** ```text /design build landing — nutze _bmad-output/design/brief.md als Briefing und stelle mir dessen Fragen nicht erneut. Zeige mir die abgeleiteten Regler samt Begründung, kennzeichne jede Stelle, an der ein vorgeschlagener Standard oder eine Ableitung verwendet wurde, und schließe mit der Auslieferungs-Checkliste und ihrem Urteil. ``` **Das solltest du erhalten** Die Seite in deinem Stack, ein kurzer Bericht über die abgeleiteten Regler, die gekennzeichneten Standards und die offenen Fragen mit ihren Risiken, und das Urteil der Checkliste als Letztes. Belege im Bericht sind als `tool` (ein Befehl lief, seine Ausgabe ist zitiert) oder `inspection` (gegen die Checkliste gelesen) gekennzeichnet. ## Schritt 5. Den Pitch an einem Panel testen Die Seite sagt, was die Bar bietet; kommt das Angebot an? Ein Panel simulierter Käufer liest den Pitch aus zwei Sätzen und füllt ein festes Formular aus. Du brauchst die vier Dateien eines Panels (Definition, Profil, Briefing-Vorlage und den Pitch als Kontextdatei). Hier sind es die Test-Fixtures von BMAD+, unter `swarm/` kopiert; ihren vollständigen Inhalt findest du in [den Beispieldateien der Schwarm-CLI-Seite](https://bmad-plus.rochetta.fr/de/docs/reference/cli-swarm/#sample-files). Fordere 30 Einheiten an. Das Budget ist 26, der erste Versuch hält also an und bittet um deine Freigabe. **Über Budget abgelehnt, dann mit demselben Seed freigegeben** ```text $ npx --no-install bmad-plus swarm init --definition swarm/buyer-panel.json --profile swarm/profile.json --context pitch=swarm/pitch.md --n 30 --seed 7 buyer-panel-20261018-ghku: needs approval. The run needs 30 sub-agents and the budget is 26: ask the user, then re-run init with --approved --seed 7. # Exit-Code 2. Dir wird ein Satz gestellt: „Dieses Panel braucht 30 Sub-Agenten; das Budget ist 26. Starten?“ Du sagst Ja. $ npx --no-install bmad-plus swarm init --definition swarm/buyer-panel.json --profile swarm/profile.json --context pitch=swarm/pitch.md --n 30 --seed 7 --approved buyer-panel-20261018-nhq4: panel of 30 units, budget 26, approval user. Seed 7 (same seed, same cards). Next: bmad-plus swarm briefs buyer-panel-20261018-nhq4 $ npx --no-install bmad-plus swarm briefs buyer-panel-20261018-nhq4 buyer-panel-20261018-nhq4: 30 of 30 units need a sub-agent, in waves of 10. Wave 1: B001 /work/demo/app/.bmad-plus/swarm/runs/buyer-panel-20261018-nhq4/briefs/B001.md # ... 29 weitere Einheiten in drei Wellen ... Each sub-agent: Read the brief and follow it exactly; it is your whole instruction. Disclosure: Simulated units are not people. Read rates as an upper bound and confirm with real ones. ``` Ausgabe eines echten Laufs. Quelle: Auf einem Testserver am 2026-10-18 mit dem Quellcode 0.23.0 (tools/cli/bmad-plus-cli.js) in einem Wegwerf-Git-Projekt nachgespielt Hier startet dein Assistent pro Briefing einen Sub-Agenten, Welle für Welle, mit der einzigen Anweisung, sein Briefing zu lesen und genau zu befolgen. Dieser Teil gehört zu deinem KI-Tool und wird hier nicht wiedergegeben. Für die Demonstration wurden fünf Antworten von Hand in `answers/` geschrieben (vier als Dateien, eine über `save` aus einer Antwort mit einem Satz um das JSON), und eine sechste Antwort mit `"buys": "maybe"` wurde abgelehnt. **Die sechs Antworten der Demonstration (von Hand geschrieben, wie der Text oben sagt)** ```text # .bmad-plus/swarm/runs//answers/B001.json { "id": "B001", "buys": false, "reason_code": "price", "reason": "Four twenty is steep for a drink I can get closer to home." } # .../answers/B002.json { "id": "B002", "buys": true, "reason_code": "habit", "reason": "The free tenth drink and the remembered order fit my routine.", "price_floor": 3.5 } # .../answers/B003.json { "id": "B003", "buys": true, "reason_code": "habit", "reason": "I pass the street every morning and order the same thing.", "visits_per_week": 5 } # .../answers/B004.json { "id": "B004", "buys": false, "reason_code": "other", "reason": "I do not know the brand yet." } # swarm/reply-b005.txt, filed with: swarm save B005 --input swarm/reply-b005.txt Here is my answer as the buyer in my card: { "id": "B005", "buys": true, "reason_code": "need", "reason": "A quick stop two streets from the station is what my mornings need." } # swarm/reply-b006.txt, refused by swarm save: field "buys" must be true or false { "id": "B006", "buys": "maybe", "reason_code": "price", "reason": "Not sure." } ``` ### Das Panel laufen lassen und ehrlich berichten Nutze es mit den Panel-Dateien an ihrem Platz. Der Assistent muss vor dem Überschreiten des Budgets fragen und darf für keine Einheit antworten. **In deinem KI-Assistenten** ```text Starte den Schwarm buyer-panel mit swarm/buyer-panel.json, swarm/profile.json und swarm/pitch.md als Pitch, 30 Einheiten, Seed 7. Frage mich, bevor du das Budget überschreitest. Starte eine Welle Sub-Agenten nach der anderen, jeder mit der einzigen Anweisung, sein Briefing zu lesen und zu befolgen. Schreibe, repariere oder erfinde keine Antwort. Berichte nach der Auswertung zuerst den Offenlegungshinweis, dann die Zahl gültiger Antworten von 30, die Kaufrate mit Nenner je Segment und Verhalten, die Begründungscodes und die ersten Zitate, und nenne die Einheiten, die nicht geantwortet haben. ``` **Das solltest du erhalten** Die Ablehnung mit Exit-Code 2 und die Ein-Satz-Frage, dann drei Wellen zu je 10, ein `check`, das fehlende Einheiten listet, und ein Bericht, der mit „Simulated units are not people. Read rates as an upper bound and confirm with real ones.“ beginnt, gefolgt von Zahlen mit ihren Nennern. Einheiten ohne Antwort werden genannt, nicht still weggelassen. ## Schritt 6. Die Auswertung lesen, ohne sich etwas vorzumachen **check, tally und inspect nach fünf gültigen Antworten** ```text $ npx --no-install bmad-plus swarm check buyer-panel-20261018-nhq4 buyer-panel-20261018-nhq4: 5 of 30 valid answers. B006 missing: no answer file # ... B007 bis B030 ebenso. Exit-Code 1. $ npx --no-install bmad-plus swarm tally buyer-panel-20261018-nhq4 /work/demo/app/.bmad-plus/swarm/runs/buyer-panel-20261018-nhq4/tally.md 5 of 30 units counted; 25 skipped. Disclosure: Simulated units are not people. Read rates as an upper bound and confirm with real ones. ``` Ausgabe eines echten Laufs. Quelle: Auf einem Testserver am 2026-10-18 mit dem Quellcode 0.23.0 (tools/cli/bmad-plus-cli.js) in einem Wegwerf-Git-Projekt nachgespielt **tally.md, Anfang und Raten-Abschnitt (von obigem Befehl geschriebene Datei)** ```md > Simulated units are not people. Read rates as an upper bound and confirm with real ones. # Simulated buyers see the pitch (run buyer-panel-20261018-nhq4) 5 of 30 units gave a valid answer; 25 skipped: B006 (no answer file), B007 (no answer file), ... ## Rate: buys | group | yes | of | rate | |---|---|---|---| | all | 3 | 5 | 60.0% | | segment = mid career | 2 | 4 | 50.0% | | segment = high earner | 1 | 1 | 100.0% | | segment = early career | 0 | 0 | n/a | | behaviour = occasional | 1 | 3 | 33.3% | | behaviour = daily regular | 2 | 2 | 100.0% | | behaviour = explorer | 0 | 0 | n/a | ``` 1. Lies die erste Zeile: den Offenlegungshinweis. Das sind simulierte Einheiten, keine Kunden. 2. Lies den Nenner vor der Rate: „3 von 5“ sind nicht „60 Prozent deines Marktes“, und hier zählten nur 5 von 30 Einheiten. In einem echten Lauf ist eine große Zahl fehlender Einheiten selbst ein Befund (ein Sub-Agent, der sein Briefing nicht befolgt hat), kein Rauschen. 3. Eine Gruppe ohne gültige Antwort zeigt `n/a`. Sie zeigt nicht 0. 4. Die Raten sind eine Obergrenze, die mit echten Menschen zu bestätigen ist. Nutze das Panel, um zu sehen, welcher Einwand wo auftaucht, und frage dann echte Kunden danach. 5. Die Zitate in dieser Demonstration sind von Hand geschrieben. In einem echten Lauf sind sie wörtlich das, was eine simulierte Einheit schrieb, mit ihrer Einheiten-ID versehen. Präsentiere sie nie als Testimonials. ## Schritt 7. Einen zweiten Pitch mit denselben Käufern vergleichen Bearbeite eine Kopie des Pitches und führe dann `init` erneut mit demselben Profil, `--n 30` und `--seed 7` aus, wobei du nur `--context pitch=...` änderst. Die Lauf-ID ist neu, die Karten sind dieselben. Hier blieb der Pitch unverändert, um den Punkt zu belegen: Die beiden `cards.json` sind Byte für Byte identisch, jeder spätere Unterschied zwischen zwei Auswertungen stammt also allein vom Pitch. **Gleicher Seed, gleiche Karten** ```text $ npx --no-install bmad-plus swarm init --definition swarm/buyer-panel.json --profile swarm/profile.json --context pitch=swarm/pitch.md --n 30 --seed 7 --approved buyer-panel-20261018-5ucw: panel of 30 units, budget 26, approval user. Seed 7 (same seed, same cards). Next: bmad-plus swarm briefs buyer-panel-20261018-5ucw $ cmp .bmad-plus/swarm/runs/buyer-panel-20261018-nhq4/cards.json .bmad-plus/swarm/runs/buyer-panel-20261018-5ucw/cards.json && echo identical identical ``` Ausgabe eines echten Laufs. Quelle: Auf einem Testserver am 2026-10-18 mit dem Quellcode 0.23.0 (tools/cli/bmad-plus-cli.js) in einem Wegwerf-Git-Projekt nachgespielt ## Schritt 8. Festhalten, was du entschieden hast Die Entscheidung, auf die es hier ankam (die Seite hat eine einzige Aufgabe, die Eröffnung der Treuekarte), gehört ins Projektgedächtnis, damit die Sitzung von morgen sie nicht neu entdecken muss. Bitte Zecher, sie in `decisions.md` festzuhalten und eine Sitzungsübergabe zu schreiben. Der Journal-Befehl erfasst das Ereignis für den späteren Abruf. **Ein Ereignis ins Journal schreiben, dann abrufen** ```text $ npx --no-install bmad-plus mem write --agent atelier --cli claude-code --task "Design read for the Orbit landing page: one job, the loyalty card sign-up" --outcome success --ci pass mem write: event 4d5cbf08d26e appended (2026-10-18T20:19:27.139Z) $ npx --no-install bmad-plus mem recall "loyalty card sign-up" mem recall: 2 match(es) for "loyalty card sign-up" (scope: project) 1. [0.707] event journal.ndjson#4d5cbf08d26e 2. [0.507] note decisions.md § 2026-10-18 — The landing page has one job, the loyalty card sign-up # Auszug. Der zweite Treffer ist ein von Hand in decisions.md ergänzter Entscheidungseintrag im Format der installierten Vorlage. ``` Ausgabe eines echten Laufs. Quelle: Auf einem Testserver am 2026-10-18 mit dem Quellcode 0.23.0 (tools/cli/bmad-plus-cli.js) in einem Wegwerf-Git-Projekt nachgespielt ## Schritt 9. Deinstallieren und das Gedächtnis behalten Die Deinstallation entfernt nur Dateien, die BMAD+ gehören, also byte-identisch mit dem Gelieferten, und die von ihm geschriebenen Adapter, dazu das Manifest. Sie behält dein Projektgedächtnis, deine Einstellungen und alles Unbekannte oder Geänderte. Der Laufzustand der Schwärme, der Design-Intake und das Briefing bleiben ebenfalls, denn sie sind deine Arbeit. Ohne Terminal ist `--yes` nötig. **Deinstallieren und was übrig bleibt** ```text $ npx --no-install bmad-plus uninstall --yes ● BMAD+ v0.23.0 (installed 2026-10-18) ● Selected packs: core, memory, design ◇ ✅ BMAD+ removed (120 items) └ Project memory, settings, and unknown or modified files have been preserved. $ find . -path ./.git -prune -o -path "./.bmad-plus/swarm/runs/*" -prune -o -print | sort ./.agents/memory/.brain-link ./.agents/memory/context.md ./.agents/memory/decisions.md ./.agents/memory/lessons.md ./.agents/memory/patterns.md ./.agents/memory/sessions ./.bmad/memory/journal.ndjson ./.bmad-plus/swarm/runs ./_bmad-output/design/brief.md ./_bmad-output/design/intake.json ./_bmad/config.yaml # Auszug: Deine eigenen Dateien (README.md, swarm/, swarm-inbox/) und leere Ordner fehlen. `AGENTS.md`, `CLAUDE.md`, `.agents/skills/` und das Manifest sind weg. ``` Ausgabe eines echten Laufs. Quelle: Auf einem Testserver am 2026-10-18 mit dem Quellcode 0.23.0 (tools/cli/bmad-plus-cli.js) in einem Wegwerf-Git-Projekt nachgespielt ### Die Sitzung abschließen und das Wichtige behalten Nutze es am Ende des Tutorials, vor dem Deinstallieren, mit installiertem Memory-Pack. **In deinem KI-Assistenten** ```text Zecher, schließe diese Sitzung ab. Halte in decisions.md die Entscheidung fest, dass die Landingpage eine einzige Aufgabe hat (die Eröffnung der Treuekarte), samt Begründung, ergänze eine Erkenntnis zum Lesen der Panel-Auswertung mit ihrem Nenner und schreibe eine Übergabe in sessions/. Erfasse Lauf-ID und Seed des Panels. Daten als JJJJ-MM-TT, archiviere nichts. ``` **Das solltest du erhalten** Ein datierter Entscheidungseintrag, eine Erkenntnis, eine Übergabe in `.agents/memory/sessions/` und ein aktualisierter `context.md`. Die Deinstallation überschreibt Gedächtnisdateien nie, die nächste Sitzung kann also, mit oder ohne installiertes BMAD+, von ihnen ausgehen. ## Zusammenfassung **Die neun Schritte** | Schritt | Du tust | Du erhältst | | --- | --- | --- | | 1 | `install --packs core,design,memory`; `doctor` | Agenten, Skills, Adapter, ein sauberer Gesundheitscheck | | 2 | `/design read` und antworten | Antworten mit je einem Status | | 3 | `brief.md` lesen | Ein von dir geprüfter Vertrag: Standards und Unbekanntes sichtbar | | 4 | `/design build landing` | Eine Seite, die ihr eigenes Checklisten-Urteil zitiert | | 5 | `swarm init` (freigeben), `briefs`, Wellen starten | Ein Panel im Budget, mit einer Ablehnung, die du beantwortet hast | | 6 | `check`, `tally` | Raten mit Nennern, Zitate, der Offenlegungshinweis zuerst | | 7 | `init` erneut, gleicher Seed | Dieselben Käufer für ein Vorher und Nachher | | 8 | Zecher, `mem write` | Eine Entscheidung, eine Erkenntnis und eine Übergabe auf der Platte | | 9 | `uninstall --yes` | BMAD+ entfernt, deine Arbeit und dein Gedächtnis bleiben | **Siehe auch** - [Der Intake im Detail](https://bmad-plus.rochetta.fr/de/docs/concepts/intake/) - [Schwärme im Detail](https://bmad-plus.rochetta.fr/de/docs/concepts/swarm/) - [Das Gedächtnis im Detail](https://bmad-plus.rochetta.fr/de/docs/concepts/how-memory-works/) - [Das Design-Pack](https://bmad-plus.rochetta.fr/de/docs/packs/design/) - [Installieren, aktualisieren, deinstallieren](https://bmad-plus.rochetta.fr/de/docs/guides/install-lifecycle/) [BMAD+ Dokumentation](https://bmad-plus.rochetta.fr/de/docs/) · [Anleitungen](https://bmad-plus.rochetta.fr/de/docs/guides/) [Quellcode auf GitHub](https://github.com/lrochetta/BMAD-PLUS)