ldy26098
/
BMAD-METHOD
mirror of https://github.com/bmad-code-org/BMAD-METHOD.git
1
0
Fork 0
Code Packages Projects Releases Wiki Activity
BMAD-METHOD/docs/examples/basic-projects.md

9.2 KiB
Raw Blame History

Basic Projects

Learn the BMAD-Spec Orchestrator through hands-on examples. Each example shows different agent interactions and complexity levels.

Prerequisites

  • BMAD-Spec Orchestrator installed (Installation Guide)
  • Claude Code with the .claude folder in your project
  • Basic understanding of software development concepts

Project Examples by Complexity

Complexity Level 1-2: Simple Applications

Personal Blog Platform

Request:

I want to create a personal blog platform where I can write and publish markdown articles with basic categorization.

Expected Agent Flow:

  1. Analyst Agent (optional) - Quick market overview
  2. PM Agent - Simple feature list and user stories
  3. Developer Agent - Direct implementation

What You'll See:

  • Minimal planning phase
  • Focus on core functionality
  • Single-agent implementation
  • Basic testing strategy

Outcome:

  • Static site generator with markdown support
  • Category system
  • Basic responsive design
  • Deploy-ready code

Task Tracker

Request:

Build a simple personal task tracker with add, complete, and delete functionality.

Agent Interaction:

  • Developer Agent handles everything
  • Uses think for standard implementation
  • Follows code quality rules (80% test coverage)
  • WCAG 2.1 AA compliance

Generated Features:

  • Local storage persistence
  • Clean, accessible interface
  • Comprehensive test suite
  • Mobile-friendly design

Complexity Level 3-4: Small Business Applications

Restaurant Menu Manager

Request:

Create a web application for restaurant owners to manage their menu items, pricing, and availability with customer-facing display.

Agent Flow:

  1. Analyst - Restaurant industry research
  2. PM - Detailed requirements gathering
  3. UX Expert - User interface design
  4. Developer - Implementation with testing

Key Features:

  • Admin panel for menu management
  • Public menu display
  • Real-time availability updates
  • Mobile-first design

Inventory Tracking System

Request:

I need an inventory management system for a small retail business with product tracking, low stock alerts, and basic reporting.

Expected Workflow:

  1. Analyst - think hard about retail inventory challenges
  2. PM - Comprehensive feature planning
  3. Architect - think harder about data structure and scalability
  4. UX Expert - Dashboard and workflow design
  5. Developer - Full-stack implementation
  6. QA - Testing and validation

Enterprise Features Applied:

  • Security-first data handling
  • Performance-optimized queries
  • Comprehensive audit trails
  • Accessibility compliance

Complexity Level 5-6: Medium Enterprise Applications

Customer Relationship Management (CRM)

Request:

Design and build a CRM system for a growing sales team with contact management, deal tracking, and basic analytics.

Full Agent Orchestra:

  1. Analyst - think hard competitive analysis
  2. PM - Comprehensive PRD with user stories
  3. Architect - ultrathink system architecture and security
  4. UX Expert - Complete user experience design
  5. Developer - Full-stack implementation
  6. QA - Comprehensive testing strategy

Quality Gates Applied:

  • Cross-agent validation
  • Security review at each stage
  • Performance optimization
  • Accessibility compliance

Project Management Platform

Request:

Create a project management platform with team collaboration, task assignment, time tracking, and progress reporting capabilities.

Complex Agent Interactions:

  • Parallel execution - UX Expert and Architect work simultaneously
  • Context preservation - Each agent builds on previous work
  • Quality validation - Multiple validation layers

Enterprise Standards:

  • Zero-trust security architecture
  • 80%+ test coverage
  • Performance optimization throughout
  • Professional documentation

Step-by-Step Walkthrough: Blog Platform

Let's walk through creating a personal blog platform to see how the system works.

Step 1: Project Initialization

# Set up your project
mkdir my-blog-platform
cd my-blog-platform
cp -r /path/to/BMAD-SPEC-KIT/bmad-spec-orchestrator-kit/.claude .

Step 2: Agent Activation

In Claude Code:

I want to create a personal blog platform where I can write and publish markdown articles with basic categorization.

Step 3: System Response

🎯 BMAD-Spec Orchestrator Activated
📊 Complexity Assessment: Level 2/10 - Simple Application  
🔄 Recommended Workflow: greenfield-ui

Activating streamlined workflow for simple application...

🔍 Analyst Agent (Optional): Quick market analysis
📋 PM Agent: Feature planning and user stories
💻 Developer Agent: Direct implementation

Step 4: PM Agent Planning

The PM Agent uses think for standard planning:

## Product Requirements Document: Personal Blog Platform

### Core Features
1. **Article Management**
   - Write articles in Markdown
   - Save drafts and publish
   - Edit existing articles

2. **Categorization System**  
   - Assign categories to articles
   - Filter articles by category
   - Category management interface

3. **Public Display**
   - Clean, readable article display
   - Category navigation
   - Mobile-responsive design

### User Stories
- As a writer, I can create new blog posts in Markdown
- As a writer, I can organize posts with categories
- As a reader, I can browse posts by category

Step 5: Developer Implementation

The Developer Agent follows enterprise rules:

// Generated with 80% test coverage requirement
// WCAG 2.1 AA accessibility compliance
// Performance optimized

// Article management with comprehensive validation
export interface Article {
  id: string
  title: string
  content: string
  category: string
  published: boolean
  createdAt: Date
  updatedAt: Date
}

// Secure, validated API endpoints
export class ArticleService {
  // Implementation with error handling
  // Input validation and sanitization
  // Performance optimizations
}

Step 6: Quality Assurance

Automatic quality gates ensure:

  • ✅ Code quality standards met
  • ✅ Accessibility requirements satisfied
  • ✅ Security best practices applied
  • ✅ Test coverage above 80%
  • ✅ Performance optimized

Common Patterns You'll See

Agent Selection Logic

Simple requests → Direct to Developer

"Create a calculator app"
→ Developer Agent with basic implementation

Business requests → PM + Developer

"Build a customer feedback system"
→ PM Agent (planning) → Developer Agent (implementation)

Complex systems → Full orchestration

"Design a multi-tenant SaaS platform"
→ All 10 agents with quality gates

Thinking Optimization Patterns

Simple logic → think

Validation, basic implementation, documentation

Important decisions → think hard

Technology selection, user experience design

Complex analysis → think harder

Architecture trade-offs, risk assessment

Critical decisions → ultrathink

Security architecture, system design

Quality Gate Patterns

Level 1-2 Projects:

  • Basic code quality checks
  • Accessibility validation
  • Simple security review

Level 3-4 Projects:

  • Cross-agent validation
  • Performance optimization
  • Comprehensive testing

Level 5+ Projects:

  • Multiple quality layers
  • Security audits
  • Enterprise compliance

Tips for Success

Request Formulation

Be specific about purpose: ✅ "Create a blog platform for personal writing" ❌ "Make a website"

Include key requirements: ✅ "Inventory system with low stock alerts" ❌ "Something for tracking stuff"

Mention complexity when known: ✅ "Simple task tracker for personal use" ✅ "Enterprise CRM system with advanced analytics"

Working with Agents

Let agents complete their work:

  • Don't interrupt mid-process
  • Allow full context building
  • Trust the quality gates

Provide feedback when needed:

  • "The UX design should focus more on mobile"
  • "Add two-factor authentication for security"
  • "Include API documentation"

Request specific thinking levels:

  • "Use ultrathink for the security architecture"
  • "Think harder about the database design trade-offs"

Customizing Output

Modify enterprise rules in .claude/rules/:

  • Adjust coding standards
  • Update design requirements
  • Modify security policies

Add domain knowledge in .claude/data/:

  • Industry-specific information
  • Technical preferences
  • Custom methodologies

Next Steps

Try More Examples

Learn the System

Get Help

Start building with AI orchestration today