AI-Driven Development Workflow

"Ultra Think before you build and you won't break anything"

A streamlined, autonomous development workflow where AI agents prioritize deep thinking, prevention over fixing, and intelligent automation over rapid delivery.

🚀 Quick Start

# 1. Setup MCP servers (one-time)
/setup-mcp

# 2. Feedback-driven development (recommended)
/plan --complete         # Create all tasks upfront
/auto --interactive      # Interactive mode for frontend tasks  
/auto                    # Default mode for backend tasks
/auto --silent           # Silent mode for utilities

# 3. Smart continuous development
/plan                    # Initial planning (3-5 primary tasks)
/auto --continuous       # Processes backlog with appropriate feedback modes
/plan-continue           # Generate remaining tasks from summaries
/auto --continuous       # Continue with smart feedback adaptation

# 4. Step-by-step approach
/project  # Initialize with 15+ app types
/plan     # Deep thinking + dependency mapping (MCP enhanced)
/build    # TDD implementation (MCP enhanced)
/test     # 90%+ coverage validation (MCP enhanced)
/ship     # Production deployment (MCP enhanced)

🎯 Core Philosophy

Ultra Think Before You Build - Comprehensive analysis prevents problems before they occur
Test-Driven Quality - Write tests first, ensure >90% coverage
Autonomous Execution - Minimal human intervention
Granular Tasks - Break work into <4 hour actionable items
Blocker Resolution - Automatically resolve dependencies

⚡ Key Features

What's New ✨

🤖 Fully Autonomous Workflow - /auto command handles everything
⚡ Continuous Task Processing - /auto --continuous processes entire backlog automatically
📋 Enhanced Planning Options - /plan --complete creates all tasks upfront, /plan-continue generates remaining tasks
🔄 Automatic Task Management - Tasks move through backlog → in-progress → testing → completed automatically
🧠 Deep Thinking Planning - 30-45 minute analysis phases (standard) or 45-60 minute complete planning
📱 15+ Application Types - Web apps, mobile, APIs, CLIs with auto tech stacks
🔗 Dependency Mapping - Comprehensive analysis of all dependencies
🚧 Smart Blocker Detection - Identifies and resolves blockers automatically
🧪 Strict TDD - Red-Green-Refactor methodology enforced
📊 90%+ Test Coverage - Comprehensive validation requirements
🔔 Alert System - Audio/visual alerts when attention needed
🔌 MCP Integration - Enhanced with 9 essential servers: Memory Bank, GitHub, Database, Puppeteer, Context7, and more

Application Types Supported

🌐 Web Applications

Next.js Full-Stack: Next.js 14+ + shadcn/ui + Tailwind CSS + Prisma
React + Node.js: Vite + React 18 + Express + PostgreSQL
Vue + Python: Nuxt 3 + FastAPI + SQLAlchemy
Custom Stack Builder: Complete flexibility with guided selection

📱 Mobile Applications

Native iOS: Swift + SwiftUI + Core Data
Native Android: Kotlin + Jetpack Compose + Room
Cross-Platform: React Native/Flutter + TypeScript/Dart

🔌 APIs & Backend

Python: FastAPI + SQLAlchemy + PostgreSQL + pytest
Node.js: Express/Fastify + TypeScript + TypeORM + Jest
Go: Gin/Echo + GORM + comprehensive testing

🤖 Enhanced Commands

Command	Purpose	Key Features
`/setup-mcp`	MCP server installation	One-time setup of 9 essential MCP servers
`/project`	Intelligent project setup	15+ app types, auto tech stacks, custom builder
`/plan`	Deep thinking planning	Problem analysis, dependency mapping, blocker detection, MCP enhanced
`/plan --complete`	Complete task planning	Create ALL tasks in one session (45-60 min)
`/plan-continue`	Continue planning	Generate remaining tasks from analysis summaries
`/build`	TDD implementation	Red-Green-Refactor, auto-approval, quality gates, MCP enhanced
`/test`	Comprehensive validation	90%+ coverage, security, performance, auto-retry, MCP enhanced
`/dev`	Development server management	Unified start/stop for frontend + backend with automatic port cleanup
`/context`	Intelligent context management	Proactive context optimization and task-aware memory
`/ship`	Production deployment	Monitoring, rollback, documentation, MCP enhanced
`/auto`	Feedback-driven workflow	Task execution with human checkpoints (2-3 per task)
`/auto --interactive`	Interactive frontend development	High-frequency feedback with visual previews (4-6 per task)
`/auto --continuous`	Smart continuous execution	Process entire backlog with context-appropriate feedback
`/auto --silent`	Fully autonomous workflow	Zero-interruption execution for utilities and infrastructure

📁 Enhanced Project Structure

your-project/
├── tasks/
│   ├── analysis/       # Deep thinking phase
│   ├── backlog/        # Ready for implementation  
│   ├── in-progress/    # TDD development
│   ├── testing/        # Validation phase
│   └── completed/      # Fully verified
├── src/                # Source code (varies by type)
├── tests/              # Comprehensive test suites
│   ├── unit/           # >90% coverage
│   ├── integration/    # API/component tests
│   └── e2e/            # End-to-end workflows
└── .claude/
    ├── commands/       # Enhanced slash commands
    ├── workflow/       # Autonomous orchestration
    ├── hooks/          # Alert system
    └── settings.local.json # Auto-approval config

🧠 Deep Thinking Process (MCP Enhanced)

Every /plan command includes:

Documentation Reading (First step - analyze docs/ + Context7 MCP for framework docs)
Problem Analysis (30-45 minutes comprehensive analysis with Memory Bank MCP)
Multiple Solution Evaluation (2-3 approaches considered using GitHub MCP analysis)
Dependency Mapping (internal/external dependencies with Database MCP)
Blocker Classification (technical, resource, knowledge, process)
Critical Path Analysis (task dependency graphs with Sequential Thinking MCP)
Granular Breakdown (every task <4 hours, actionable)

🧪 Test-Driven Development (Mandatory)

Red Phase: Write failing tests first
Green Phase: Implement minimal code to pass tests
Refactor Phase: Improve code while keeping tests green
Coverage: Maintain >90% test coverage
Auto-retry: Failed tests trigger build phase fixes

🔌 MCP Integration

This workflow is enhanced with 9 essential MCP servers for autonomous development:

Core MCP Servers

🧠 Memory Bank MCP: Preserve insights and architectural decisions across sessions
🐙 GitHub MCP: Repository analysis, PR automation, CI/CD integration
🎯 Sequential Thinking MCP: Enhanced problem breakdown for planning phase
🗄️ Database MCP: Schema analysis and migration automation
🤖 Puppeteer MCP: Automated E2E testing and web interaction
📁 File System MCP: Enhanced file operations and structure creation
📋 Notion MCP: Documentation and requirements management
🎨 Figma MCP: Design-to-code workflow integration
📚 Context7 MCP: Tech documentation understanding and framework guidance

Setup (One-time)

/setup-mcp  # Installs all 9 MCP servers automatically

🔧 Dependency Management & Auto-Approved Commands

📦 Project-Isolated Dependencies (Required)

All application dependencies MUST be contained within the project directory. No global installations.

Python Backend - Use Astral UV

# ✅ Auto-approved (project-isolated)
uv add fastapi uvicorn          # Add runtime dependencies
uv add --dev pytest black      # Add development dependencies  
uv run python main.py          # Run in isolated environment
uv sync                         # Install all dependencies

# ❌ Requires approval (global/system)
pip install fastapi            # Global installation
sudo pip install package      # System-level installation

Frontend - Use Local Package Managers

# ✅ Auto-approved (project-local)
pnpm add react typescript      # Preferred: fastest package manager
yarn add react typescript     # Alternative: good performance
npm install react typescript  # Fallback: widely supported
npx create-next-app           # Run tools from local packages

# ❌ Requires approval (global)
npm install -g typescript     # Global installation
yarn global add package       # Global installation

Auto-Approved Commands

Package Managers (Local): uv add, uv run, pnpm add, yarn add, npm install, npx
Development: python, node, go, tsc, pytest, jest
Version Control: git status, git add, git commit, git diff
File Operations: mkdir, touch, cp, mv, chmod
Utilities: curl, echo, cat, grep, find, ls
Servers: uvicorn, gunicorn, flask run

See docs/guidelines/dependency-management.md for comprehensive guidelines.

📋 Adding Requirements & Specifications

The workflow automatically discovers and processes documentation you provide:

📁 Document Structure

your-project/
├── docs/
│   ├── requirements/     # Business requirements, user stories
│   ├── design/          # Technical specs, architecture, UI/UX
│   │   ├── ui-mockups/  # Wireframes, mockups, screenshots
│   │   ├── api-specs/   # OpenAPI/Swagger specifications
│   │   └── architecture/# System architecture diagrams
│   └── guidelines/      # Coding standards, style guides
├── .env.example         # API keys, service URLs, configuration
└── README.md           # Project overview

📄 Requirements Documents

# Add business requirements (any format)
mkdir -p docs/requirements
cp your-requirements.pdf docs/requirements/
cp user-stories.md docs/requirements/
cp acceptance-criteria.xlsx docs/requirements/

# System automatically reads: PDF, Word, Markdown, Excel, plain text

🎨 Design Documents & UI Guidelines

# UI/UX specifications
mkdir -p docs/design/ui-mockups
cp wireframes.figma docs/design/ui-mockups/
cp mockups/*.png docs/design/ui-mockups/
cp design-system.pdf docs/design/

# Style guide (structured format recommended)
cat > docs/design/style-guide.json << EOF
{
  "brand": {
    "name": "TaskMaster Pro",
    "colors": {
      "primary": "#1a73e8",
      "secondary": "#34a853", 
      "accent": "#ea4335",
      "background": "#f8f9fa",
      "text": "#202124"
    },
    "typography": {
      "headings": "Inter",
      "body": "Roboto",
      "code": "JetBrains Mono"
    },
    "spacing": {
      "unit": "8px",
      "scale": [4, 8, 16, 24, 32, 48, 64]
    }
  },
  "components": {
    "buttons": {
      "borderRadius": "6px",
      "padding": "12px 24px",
      "variants": ["primary", "secondary", "outline", "ghost"]
    },
    "forms": {
      "inputHeight": "40px",
      "validation": "inline-errors"
    }
  }
}
EOF

⚙️ Technical Specifications

# Architecture and tech stack preferences
cat > docs/design/tech-specifications.md << EOF
# Technical Specifications

## Architecture
- **Pattern**: Microservices with API Gateway
- **Frontend**: Next.js 14+ with App Router
- **Backend**: Node.js + TypeScript + Express
- **Database**: PostgreSQL with Prisma ORM
- **Cache**: Redis for sessions and caching
- **Queue**: Bull Queue with Redis

## API Design
- **Style**: RESTful with OpenAPI 3.0 documentation
- **Authentication**: JWT tokens with refresh mechanism
- **Rate Limiting**: 100 requests/minute per user
- **Pagination**: Cursor-based for performance
- **Error Format**: RFC 7807 Problem Details

## Code Standards
- **Linting**: ESLint with Airbnb config
- **Formatting**: Prettier with 2-space indentation
- **Testing**: Jest + Testing Library, >90% coverage
- **Documentation**: TSDoc for all functions
EOF

# API specifications (OpenAPI/Swagger)
cp api-specification.yaml docs/design/api-specs/

🔧 Environment & Configuration

# Development environment setup
cat > .env.example << EOF
# Database
DATABASE_URL=postgresql://user:password@localhost:5432/taskmaster_dev
REDIS_URL=redis://localhost:6379

# Authentication
JWT_SECRET=your-jwt-secret-key
JWT_EXPIRES_IN=7d
REFRESH_TOKEN_EXPIRES_IN=30d

# External Services
SENDGRID_API_KEY=SG.your-api-key
STRIPE_PUBLISHABLE_KEY=pk_test_your-key
STRIPE_SECRET_KEY=sk_test_your-key
STRIPE_WEBHOOK_SECRET=whsec_your-webhook-secret

# File Storage
AWS_ACCESS_KEY_ID=your-access-key
AWS_SECRET_ACCESS_KEY=your-secret-key
AWS_S3_BUCKET=taskmaster-uploads
AWS_REGION=us-east-1

# Monitoring
SENTRY_DSN=your-sentry-dsn
LOG_LEVEL=info
EOF

📐 Coding Guidelines & Standards

# Project-specific coding standards
cat > docs/guidelines/coding-standards.md << EOF
# Coding Standards

## File Organization
- **Components**: PascalCase (UserProfile.tsx)
- **Utilities**: camelCase (formatDate.ts)
- **Constants**: UPPER_SNAKE_CASE (API_ENDPOINTS.ts)
- **Types**: PascalCase with T prefix (TUser, TApiResponse)

## Code Patterns
- **Error Handling**: Always use Result<T, E> pattern
- **Async Operations**: Prefer async/await over Promises
- **State Management**: Zustand for client state, TanStack Query for server state
- **Component Structure**: Props interface, component, export default

## Testing Requirements
- **Unit Tests**: Every utility function and hook
- **Integration Tests**: All API endpoints
- **E2E Tests**: Critical user journeys
- **Coverage**: >90% line coverage, >85% branch coverage

## Performance Standards
- **Page Load**: <2 seconds on 3G
- **API Response**: <200ms for simple queries
- **Bundle Size**: <500KB initial load
- **Lighthouse**: >90 Performance, >95 Accessibility
EOF

🎯 Usage Examples

Starting with Documentation

# 1. Add all your documentation first
mkdir -p docs/{requirements,design,guidelines}
cp requirements.pdf docs/requirements/
cp mockups.figma docs/design/ui-mockups/
cp api-spec.yaml docs/design/api-specs/
cp .env.example ./

# 2. Initialize project (automatically discovers documents)
/project

# 3. AI analyzes all documents and creates comprehensive plan
/plan
# System reads all docs and creates tasks based on requirements, 
# following design specs and coding guidelines

# 4. Execute (AI follows all specifications automatically)
/auto

Fully Autonomous with Specifications

# Place documentation
cp project-spec.pdf docs/requirements/
cp wireframes/* docs/design/ui-mockups/
cp style-guide.json docs/design/

# Single command handles everything
/auto "Build the application according to the specifications in docs/"
# System: reads specs → analyzes requirements → follows design → implements → tests → deploys

Adding Requirements Mid-Development

# Add new requirements anytime
cp new-feature-spec.md docs/requirements/

# Plan new features (AI considers existing code + new requirements)
/plan "Implement the notification system as specified in new-feature-spec.md"

Custom Tech Stack with Guidelines

# Specify exact tech choices
cat > docs/design/tech-stack.json << EOF
{
  "frontend": {
    "framework": "React 18",
    "bundler": "Vite", 
    "ui": "Mantine + Tailwind CSS",
    "state": "Zustand",
    "routing": "React Router v6"
  },
  "backend": {
    "runtime": "Node.js 20",
    "framework": "Fastify",
    "orm": "Drizzle",
    "database": "PostgreSQL",
    "validation": "Zod"
  }
}
EOF

/project
# Choose: Custom Tech Stack → System reads tech-stack.json and configures exactly as specified

Step-by-Step Development

# 1. Initialize with discovered documentation
/project
# System automatically finds and reads all docs/ content

# 2. Plan feature following specifications
/plan "Add user authentication as specified in requirements"
# AI creates tasks that follow design specs and coding guidelines

# 3. Build with TDD
/build
# Automatically follows tech specs and coding standards

# 4. Comprehensive testing  
/test
# Validates against requirements and performance standards

# 5. Deploy
/ship
# Production deployment following deployment guidelines

📊 Quality Standards

>90% test coverage with comprehensive edge case testing
Security validation on all inputs and dependencies
Performance benchmarks must pass
TDD methodology strictly enforced
Automatic blocker resolution before implementation
Dependency awareness with critical path analysis

🔔 Alert System

Automatic audio/visual alerts when:

Manual approval required
Errors need attention
Tasks complete successfully
Workflow gets blocked
Agent handoffs occur

🔄 Enhanced Workflow Options

Feedback-Driven Development Modes

Interactive Mode (`/auto --interactive`) - Frontend Focus

Best For: UI components, pages, styling, user interactions, design-heavy tasks Feedback Frequency: 4-6 checkpoints per task Includes:

Live preview generation and screenshots
Design mockup comparisons
Accessibility testing results
Cross-browser compatibility checks
Real-time style guide compliance

/auto --interactive "Create responsive product catalog with filters"
# Checkpoints: Component structure → Layout design → Filter functionality → Mobile responsive → Final review

Default Mode (`/auto`) - Balanced Approach

Best For: General development, APIs, business logic, mixed frontend/backend Feedback Frequency: 2-3 checkpoints per task Includes:

Implementation approach approval
Functional testing and validation
Security and performance review

/auto "Implement user authentication with JWT tokens"
# Checkpoints: API design approval → Implementation demo → Security audit

Continuous Mode (`/auto --continuous`) - Smart Automation

Best For: Processing entire backlog with minimal interruption Feedback Frequency: Context-adaptive (automatically switches modes) Includes:

Automatic mode selection based on task type
Interactive mode for frontend tasks
Default mode for mixed tasks
Silent mode for utilities

Silent Mode (`/auto --silent`) - Full Automation

Best For: Utilities, tests, documentation, refactoring, infrastructure Feedback Frequency: Final review only Includes:

Comprehensive automated testing
Extra validation and quality checks
Detailed completion reports

Planning Approaches

Complete Planning (All Tasks Upfront)

/plan --complete         # 45-60 min session, creates ALL tasks
/auto --continuous       # Process entire backlog autonomously

Iterative Planning (Phased Approach)

/plan                    # Initial planning (3-5 primary tasks)
/auto                    # Work on first tasks
/plan-continue           # Generate remaining tasks from summaries
/auto --continuous       # Continue autonomous processing

Task Lifecycle Management

Tasks automatically move through folders:

tasks/backlog/ → tasks/in-progress/ → tasks/testing/ → tasks/completed/

Autonomous Execution Options

# Feedback-driven development (recommended for most tasks)
/auto                    # Single task with 2-3 human checkpoints
/auto "specific task"    # Execute specific task with feedback

# Frontend development (high-frequency feedback)  
/auto --interactive      # 4-6 checkpoints with visual previews
/auto --interactive "Create user dashboard with charts"

# Smart continuous processing
/auto --continuous       # Entire backlog with context-appropriate feedback
                        # (Automatically uses interactive mode for frontend tasks)

# Zero-interruption automation
/auto --silent          # Fully autonomous for utilities/infrastructure
/auto --silent "Add unit tests for authentication module"

🚦 Quick Commands

# Development server management (single command for full-stack)
/dev start              # Start frontend + backend + services
/dev stop               # Stop all development servers
/dev status             # Show running services and ports
/dev logs               # Combined logs from all services

# Project status and monitoring
cat ./.claude/project_status.json
tail -f ./.claude/logs/autonomous-workflow.log
find tasks/ -name "*.md" | sort

# Manual testing after build completion
/dev start              # Single command starts entire development environment
# Access at: http://localhost:3000 (frontend) + http://localhost:8000/docs (backend API)

# Test alert system
./.claude/hooks/user-attention-alert.sh complete "Test message"

# Run continuous processing script
./.claude/scripts/continuous-auto.sh --continuous

🧠 Intelligent Context Management

The Context Window Problem

Traditional AI workflows suffer from degraded performance as context fills up. The /compact command is reactive and loses critical task context.

Proactive Context Optimization

Smart Context Zones:

Green (0-60%): Full context, optimal AI performance
Yellow (60-80%): Selective pruning of low-priority content
Orange (80-90%): Aggressive pruning, keep only task-critical context
Red (90%+): Emergency preservation and intelligent reset

Task-Aware Memory Management

# Automatic context optimization (enabled by default)
/context auto

# Task-specific context snapshots  
/context save "implementing user authentication"
/context restore "user authentication"

# Context-aware task execution
/auto --context-aware "build shopping cart feature"

Intelligent Context Preservation

High Priority (Always Kept):

Current task details and progress
Active file modifications and errors
Recent user feedback and decisions
Project requirements and constraints

Medium Priority (Selectively Kept):

Related task context and dependencies
Recent code understanding and test results
Architectural decisions and configurations

Low Priority (First to Prune):

Historical conversation and completed tasks
Exploratory file reads and documentation
Status queries and general information

Automatic Context Snapshots

Context is automatically saved at key moments:

Before starting new tasks
After completing milestones
Before major refactoring
When context reaches 80% usage
When switching between features

🛠️ Advanced Features

Autonomous Orchestration

Zero Human Intervention: Runs until completion or unrecoverable failure
Intelligent Retry: Build failures (3 attempts), test failures (2 attempts)
Dependency Awareness: Respects task dependencies automatically
Progress Tracking: Comprehensive logging and status monitoring
Context Optimization: Maintains optimal AI performance throughout long sessions

Blocker Resolution

Automatically resolves:

Missing dependencies and tools
Environment configuration issues
Development database setup
CI/CD pipeline configuration

Task Format

Every task includes:

Context & purpose with user value
Testable success criteria
TDD implementation plan
Risk assessment & definition of done

📚 Key Principles for AI Agents

Deep Analysis First - Always understand before implementing
Break Down Ruthlessly - No task >4 hours, make them actionable/testable
Test-First Always - Write failing tests before any code
Resolve Blockers Automatically - Don't wait for human intervention
Quality Over Speed - Better to build right once than fix repeatedly
Alert Only When Necessary - Minimize human interruptions

🔄 Updating Existing Projects

To add the new features to an existing AI-driven workflow project:

# 1. Navigate to your existing project
cd /path/to/your/existing/project

# 2. Create the enhanced task folder structure
mkdir -p tasks/{analysis,backlog,in-progress,testing,completed}
touch tasks/{in-progress,testing}/.gitkeep

# 3. Move any existing tasks to backlog
mv tasks/*.md tasks/backlog/ 2>/dev/null || true

# 4. Copy enhanced command files from this template
cp /path/to/template/.claude/commands/plan.md .claude/commands/
cp /path/to/template/.claude/commands/auto.md .claude/commands/
cp /path/to/template/.claude/commands/plan-continue.md .claude/commands/

# 5. Update settings.local.json to use relative paths
# Edit .claude/settings.local.json and change:
# "/full/path/.claude/hooks/script.sh" → ".claude/hooks/script.sh"

# 6. Test the enhanced features
/plan --complete      # Complete planning
/auto --continuous    # Continuous execution

Your existing project now has enhanced autonomous capabilities!

Built for autonomous AI development. Quality-driven. Human-optional.

This workflow prioritizes thoughtful execution and autonomous quality delivery over rapid feature development.

ClaudeAutonomous

Links

README