From dd25e12f96cc9473015e75606ddee92627d640f7 Mon Sep 17 00:00:00 2001 From: Jonah Schulte Date: Fri, 26 Dec 2025 14:03:42 -0500 Subject: [PATCH] docs: document future enhancements (super-dev, auto-epic) - Super-dev mode concept (post-dev validation + auto review) - Autonomous epic processing vision - Future roadmap for quality automation --- docs/autonomous-epic-processing.md | 169 +++++++++++ docs/super-dev-mode.md | 435 +++++++++++++++++++++++++++++ 2 files changed, 604 insertions(+) create mode 100644 docs/autonomous-epic-processing.md create mode 100644 docs/super-dev-mode.md diff --git a/docs/autonomous-epic-processing.md b/docs/autonomous-epic-processing.md new file mode 100644 index 00000000..f0a2f569 --- /dev/null +++ b/docs/autonomous-epic-processing.md @@ -0,0 +1,169 @@ +# Autonomous Epic Processing + +## Concept + +**Full-auto epic completion** - Create and develop all stories in an epic with zero human intervention. + +``` +/auto-epic epic-2 + +→ Creates story 2.1 → Super-dev → Done +→ Creates story 2.2 → Super-dev → Done +→ Creates story 2.3 → Super-dev → Done +... +→ Entire epic complete! ✅ +``` + +## Workflow + +``` +┌──────────────────────────────────────┐ +│ Auto-Epic Processor │ +│ │ +│ 1. Read epic definition │ +│ 2. For each story in epic: │ +│ ├─ create-story │ +│ ├─ super-dev-story │ +│ │ ├─ Pre gap analysis │ +│ │ ├─ Development │ +│ │ ├─ Post gap analysis │ +│ │ ├─ Code review │ +│ │ └─ Fix issues │ +│ └─ Mark done │ +│ 3. Epic retrospective │ +│ 4. Report completion │ +└──────────────────────────────────────┘ +``` + +## Use Cases + +### 1. Overnight Processing +```bash +# Start before leaving office +/auto-epic epic-3 + +# Come back next morning +# → Epic 100% complete +``` + +### 2. CI/CD Integration +```bash +# In GitHub Actions +bmad auto-epic epic-2 --config production.yaml +``` + +### 3. Batch Sprints +```bash +# Process multiple epics +/auto-epic epic-1,epic-2,epic-3 +``` + +## Configuration + +```yaml +# _bmad/bmm/config.yaml + +autonomous_mode: + enabled: true + + # Fail behavior + halt_on_error: false # Continue even if story fails + max_retry_per_story: 3 # Retry failed stories + + # Quality gates + require_super_dev: true # Use super-dev for all stories + require_100_percent: false # Require 100% test coverage + + # Notification + notify_on_complete: true # Send notification when done + notify_webhook: "" # Slack/Discord webhook +``` + +## Safety + +### Validation Before Start + +``` +Autonomous processing will: +- Create 15 stories +- Develop all automatically +- Take approximately 8 hours +- Commit all changes to: feature/epic-2-auto + +Confirm? [Y/n]: +``` + +### Checkpoints + +- Creates git branch for the epic +- Commits after each story +- Saves progress if interrupted +- Can resume from last completed story + +### Rollback + +```bash +# If something goes wrong +/auto-epic rollback epic-2 + +# Restores to pre-processing state +``` + +## Example Output + +``` +🤖 AUTONOMOUS EPIC PROCESSING: Epic 2 - User Management + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +Story 2.1: User Registration +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + +✅ create-story complete +✅ Pre-gap analysis: 0 changes needed +✅ Development: 8 tasks completed +✅ Post-gap analysis: All verified +✅ Code review: 2 minor issues found +✅ Fixes applied +✅ Story 2.1 DONE + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +Story 2.2: User Login +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + +✅ create-story complete +✅ Pre-gap analysis: Reuse registration code +✅ Development: 6 tasks completed +✅ Post-gap analysis: All verified +✅ Code review: No issues +✅ Story 2.2 DONE + +... + +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ +EPIC 2 COMPLETE! 🎉 +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + +Stories completed: 15/15 +Total time: 7h 23m +Test coverage: 94% +Code review issues: 12 (all fixed) + +Branch: feature/epic-2-auto +Ready to merge! +``` + +## Implementation Status + +- 🚧 **Planned** for BMAD v6.1.0 +- Requires: Super-dev mode (v6.0.0-alpha.23) +- Depends on: Robust error handling, progress tracking + +## Contributing + +Want to help build autonomous epic processing? + +See [CONTRIBUTING.md](../CONTRIBUTING.md) + +--- + +**The future: Tell BMAD what you want built, come back when it's done** ✨ diff --git a/docs/super-dev-mode.md b/docs/super-dev-mode.md new file mode 100644 index 00000000..5721c87d --- /dev/null +++ b/docs/super-dev-mode.md @@ -0,0 +1,435 @@ +# Super-Dev Mode: Comprehensive Quality Workflow + +## TL;DR + +**Super-Dev Mode** ensures stories are **truly complete** through multi-stage validation: + +``` +Pre-validation → Development → Post-validation → Code Review → Fixes → Done ✅ +``` + +No more "stupid-dev" where tasks get checked off without actually being complete! + +## The Problem with "Stupid-Dev" + +### Standard dev-story Flow + +``` +1. Read tasks +2. Implement features +3. Check off tasks +4. Mark story "review" +5. ??? (Hope it's actually done) +``` + +**What goes wrong:** +- ❌ Dev agent marks tasks complete prematurely +- ❌ Partial implementations claimed as "done" +- ❌ Missing edge cases not caught +- ❌ Code issues discovered later in manual review +- ❌ Story bounces back for rework + +### Super-Dev Flow + +``` +1. PRE-DEV GAP ANALYSIS ✅ + ↓ Validate tasks match codebase + +2. DEVELOPMENT ✅ + ↓ Implement features + +3. POST-DEV GAP ANALYSIS 🆕 + ↓ Verify nothing was missed + +4. ADVERSARIAL CODE REVIEW 🆕 + ↓ Catch issues, security, quality problems + +5. FIX REVIEW FINDINGS 🆕 + ↓ Address all problems + +6. MARK DONE ✅ + ↓ Only when truly complete +``` + +**What this prevents:** +- ✅ No premature task completion +- ✅ Catches partial implementations +- ✅ Finds missed edge cases +- ✅ Code review happens automatically +- ✅ Story only "done" when verified complete + +## How It Works + +### Stage 1: Pre-Dev Gap Analysis + +Same as standard dev-story Step 1.5: +- Scans codebase +- Validates tasks against reality +- Proposes task updates +- User approves + +### Stage 2: Development + +Standard implementation cycle: +- Follows tasks sequentially +- Red-green-refactor (TDD) +- Runs tests +- Updates story file + +### Stage 3: **NEW** - Post-Dev Gap Analysis + +**This is the game-changer!** + +After all tasks are checked off: + +```xml + + 🔍 VERIFY COMPLETION - Did we actually build everything? + + Re-scan codebase with original requirements + Compare what should exist vs what actually exists + + + ⚠️ POST-DEV GAPS DETECTED! + + Tasks marked complete but code missing or incomplete: + {{list_of_gaps}} + + Adding missing work to task list... + + + Add new tasks for missing work + GOTO step 5 - Continue implementation + + + + ✅ Post-dev validation passed - all work verified complete + Continue to code review + + +``` + +### Stage 4: **NEW** - Adversarial Code Review + +Auto-run code review workflow: + +```xml + + 👀 INDEPENDENT REVIEW - Catch issues before human review + + Run code-review workflow automatically + Generate review findings + + + 🚨 CODE REVIEW FOUND CRITICAL ISSUES: + + {{list_of_critical_issues}} + + Auto-fixing issues... + + + Add review findings as tasks + GOTO step 5 - Implement fixes + + + + ℹ️ CODE REVIEW FOUND MINOR ISSUES: + + {{list_of_minor_issues}} + + + Auto-fix minor issues? [Y/n]: + + + Add review findings as tasks + GOTO step 5 - Implement fixes + + + + + ✅ Code review passed - no issues found + Continue to completion + + +``` + +### Stage 5: Mark Done + +Only after passing ALL validation: + +``` +✅ Pre-dev gap analysis passed +✅ Development completed +✅ Post-dev gap analysis passed +✅ Code review passed +✅ All issues fixed + +→ NOW mark story "review" +``` + +## Configuration + +### Enable Super-Dev Mode + +Add to `_bmad/bmm/config.yaml`: + +```yaml +# Super-Dev Mode (comprehensive quality workflow) +super_dev_mode: true # Default: false + +# Super-Dev Options +super_dev: + post_dev_gap_analysis: true # Re-validate after implementation + auto_code_review: true # Run code review automatically + auto_fix_minor_issues: false # Auto-fix minor review findings without asking + fail_on_gaps: false # Fail hard if post-dev gaps found (vs auto-fix) +``` + +### Per-Story Override + +In story file frontmatter: + +```yaml +--- +super_dev_mode: true +--- +``` + +## Usage + +### Enable for All Stories + +```bash +# Edit config +vim _bmad/bmm/config.yaml + +# Add: +super_dev_mode: true + +# Now all dev-story runs use super-dev mode +``` + +### Enable for One Story + +```bash +# Edit story file +vim docs/sprint-artifacts/1-2-auth.md + +# Add to frontmatter: +super_dev_mode: true + +# Run dev-story as normal +/dev-story +``` + +### Batch Enable + +```bash +# Enable for all stories in epic 2 +for story in docs/sprint-artifacts/2-*.md; do + # Add super_dev_mode to frontmatter + sed -i '1a super_dev_mode: true' "$story" +done +``` + +## Examples + +### Example 1: Post-Dev Gap Catches Missing Test + +``` +Story: "Implement user authentication" + +Tasks after development: +[x] Create auth service +[x] Implement login endpoint +[x] Write tests + +POST-DEV GAP ANALYSIS: +✅ auth.service.ts exists +✅ login endpoint exists +❌ Tests claim 90% coverage but only 60% actual +❌ Edge case tests missing + +ACTION: Add missing tests to task list, continue development + +RESULT: Story truly complete with full test coverage +``` + +### Example 2: Code Review Catches Security Issue + +``` +Story: "Add password reset feature" + +Development complete, all tasks checked. + +CODE REVIEW: +❌ CRITICAL: Password reset tokens not expiring +❌ MEDIUM: Error messages leak user existence +✅ All other checks passed + +ACTION: Add security fixes to task list, continue development + +RESULT: Secure implementation, no vulnerabilities +``` + +### Example 3: Everything Passes First Try + +``` +Story: "Update dashboard UI" + +Tasks completed perfectly. + +POST-DEV GAP ANALYSIS: ✅ All work verified +CODE REVIEW: ✅ No issues found + +RESULT: Story marked "review" immediately +``` + +## Performance Impact + +| Stage | Time | Value | +|-------|------|-------| +| Pre-dev gap analysis | 5-10s | Prevents duplicate work | +| Development | Normal | Standard implementation | +| Post-dev gap analysis | 5-10s | Catches incomplete work | +| Code review | 30-60s | Finds quality/security issues | +| **Total overhead** | **40-80s** | **Prevents hours of rework** | + +**ROI:** Spending 1 minute extra per story prevents hours of: +- Rework from incomplete implementations +- Bug fixes from missed edge cases +- Security patches from vulnerabilities +- Review cycles from quality issues + +## Comparison + +### Standard Dev-Story + +``` +Time: 30 minutes dev work +Quality: ??? (unknown until manual review) +Rework: High probability +Cycle time: Long (multiple review iterations) +``` + +### Super-Dev Mode + +``` +Time: 31 minutes (30 dev + 1 validation) +Quality: High (multi-stage verified) +Rework: Minimal (issues caught early) +Cycle time: Short (passes review first time) +``` + +## Best Practices + +### 1. Enable for Complex Stories + +Stories with: +- Security implications +- Complex business logic +- Multiple integrations +- High test coverage requirements + +### 2. Disable for Trivial Stories + +Stories like: +- Documentation updates +- Simple UI tweaks +- Configuration changes + +### 3. Use Auto-Fix for Minor Issues + +```yaml +super_dev: + auto_fix_minor_issues: true +``` + +Saves time on: +- Linting issues +- Formatting problems +- Simple refactoring + +### 4. Batch Process with Caution + +Super-dev mode increases time per story. For batch processing: +- Enable for critical stories only +- Or run overnight batch processing +- Or accept longer processing time for quality + +## Troubleshooting + +### "Post-dev gap analysis found missing work every time" + +**Cause:** Dev agent marks tasks complete prematurely + +**Solution:** This is EXACTLY what super-dev catches! Let it add the missing work and continue. + +### "Code review fails every story" + +**Cause:** Common coding issues not caught during development + +**Solution:** This is working as designed. Review the patterns and add to "Dev Agent Guardrails" in future stories. + +### "Super-dev mode takes too long" + +**Cause:** Multiple validation stages add time + +**Solution:** +- Disable for trivial stories +- Use `auto_fix_minor_issues: true` +- Accept quality over speed trade-off + +### "Post-dev analysis conflicts with pre-dev analysis" + +**Cause:** Codebase changed during development (other stories completed) + +**Solution:** This is normal for batch planning. Post-dev analysis adapts to evolved codebase. + +## FAQ + +### Q: Does this replace manual code review? + +**A:** No. This catches obvious issues automatically. Human review still needed for: +- Architecture decisions +- Business logic correctness +- UX/design decisions + +### Q: Can I use post-dev gap analysis without code review? + +**A:** Yes: +```yaml +super_dev: + post_dev_gap_analysis: true + auto_code_review: false +``` + +### Q: Does this work with custom workflows? + +**A:** Yes, if your custom dev-story preserves the hook points for gap analysis and code review. + +### Q: What if I disagree with code review findings? + +**A:** You can reject auto-fixes and continue. The findings are logged for human review. + +## Implementation Status + +- ✅ **Pre-dev gap analysis** - Available in BMAD v6.0.0-alpha.22+ +- 🚧 **Post-dev gap analysis** - Planned for v6.0.0-alpha.23 +- 🚧 **Auto code review** - Planned for v6.0.0-alpha.23 +- 🚧 **Super-dev mode config** - Planned for v6.0.0-alpha.23 + +## Contributing + +Want to help implement super-dev mode? + +1. Post-dev gap analysis implementation +2. Code review integration +3. Config system for super-dev options +4. Documentation and examples + +See [CONTRIBUTING.md](../CONTRIBUTING.md) for guidelines. + +--- + +**Super-Dev Mode: Because "done" should mean DONE, not "hope so"** ✅