Blueprint

Transform specifications into executable implementation plans with system architecture, component design, and dependency-ordered task breakdown.

When To Use

Use this command when you need to:

• Convert specification into implementation plan
• Design system architecture from requirements
• Break down work into dependency-ordered tasks
• Estimate effort and plan sprints
• Define component interfaces and data flow
• Create concrete roadmap for execution

When NOT To Use

Avoid this command if:

• No specification exists yet (use /attune:specify first)
• Still defining requirements (complete specification phase)
• Ready to execute existing plan (use /attune:execute instead)
• Adjusting running project (update plan incrementally)

Usage

# Create plan from specification
/attune:blueprint

# Plan with custom input
/attune:blueprint --input docs/specification.md

# Focus on specific component
/attune:blueprint --component "authentication"

What This Command Does

1. Loads specification from specify phase
2. Invokes planning skill with superpowers integration
3. Designs system architecture (components, interfaces, data flow)
4. Breaks down into tasks with dependencies and estimates
5. Produces implementation plan for execution phase

Integration with Superpowers

When superpowers plugin is available:

• Uses Skill(superpowers:writing-plans) for structured planning
• Applies dependency analysis
• Creates checkpoint-based execution flow

Without superpowers:

• Falls back to attune's native planning skill
• Provides similar step-by-step approach
• Documents tasks systematically

Workflow

# 1. Invoke planning skill
Skill(attune:project-planning)

# 2. Design architecture:
#    - System components
#    - Component interfaces
#    - Data flow diagrams
#    - Technology selections

# 3. Break down into tasks:
#    - Development tasks with dependencies
#    - Testing tasks
#    - Deployment tasks
#    - Documentation tasks

# 4. Generate implementation plan
#    - Saved to docs/implementation-plan.md
#    - Includes architecture + task breakdown
…

Workflow Continuation Protocol (MANDATORY)

After planning completes successfully, auto-proceed to the next phase unless --standalone was specified:

1. Verify artifact: Confirm docs/implementation-plan.md exists and is non-empty
2. Checkpoint message: Display brief summary to user:

   Implementation plan complete. Saved to docs/implementation-plan.md.
   Proceeding to execution phase...

1. Auto-invoke next phase:

   Skill(attune:project-execution)

Bypass Conditions (skip auto-continuation if ANY true):

• --standalone flag was provided
• docs/implementation-plan.md does not exist or is empty
• User explicitly requests to stop after planning

Plan Structure

Section 1: Architecture Design

Components:

## System Architecture

### Component Diagram

┌─────────────┐ ┌──────────────┐ ┌─────────────┐ │ Web UI │─────▶│ API Server │─────▶│ Database │ │ (React) │ │ (FastAPI) │ │ (Postgres) │ └─────────────┘ └──────────────┘ └─────────────┘ │ ▼ ┌──────────────┐ │ GitHub API │ └──────────────┘

### Components

#### Component 1: Web UI
**Responsibility**: User interface for debt tracking
**Technology**: React 18 + TypeScript + Vite
**Interfaces**:
- REST API client
- OAuth callback handler
**Data**: Client-side state management (React Context)

#### Component 2: API Server
**Responsibility**: Business logic and GitHub integration
**Technology**: FastAPI + Python 3.10
**Interfaces**:
- REST API endpoints
- GitHub webhook receiver
- Database access layer
…

Section 2: Task Breakdown

Task Format:

### TASK-001: [Task Name]

**Description**: Clear description of what needs to be done

**Type**: Implementation | Testing | Documentation | Deployment
**Priority**: P0 (Critical) | P1 (High) | P2 (Medium) | P3 (Low)
**Estimate**: [Story points or hours]
**Dependencies**: TASK-002, TASK-005
**Assignee**: [Team member or TBD]

**Acceptance Criteria**:
- [ ] Criterion 1
- [ ] Criterion 2

**Technical Notes**:
- Implementation detail 1
- Implementation detail 2
…

Section 3: Development Phases

Phase 1: Foundation (Weeks 1-2)

• Project initialization
• Database schema
• GitHub OAuth setup
• Basic API scaffolding

Phase 2: Core Features (Weeks 3-6)

• Issue discovery
• Prioritization algorithm
• Dashboard implementation