Note: This workflow is designed for projects that are in the initial scaffolding phase. It assumes no prior project structure, dependencies, or core technologies are in place.
Below is a visual representation of the workflow (simplified for brevity). Each phase has an associated prompt to guide the developer through that phase.
This workflow represents a chained sequence of AI-assisted processes for planning and implementing the initial project scaffolding. Each phase produces specific outputs that become required inputs for subsequent phases, creating a connected chain of development activities.
The workflow operates through the following sequential phases:
Phase 1: Vision Statement Generation
↓ [Outputs feed Phase 2]
Phase 2: Initial Project Requirements Management
↓ [Outputs feed Phase 3]
Phase 3: Technology Stack Generation
↓ [Outputs feed Phase 4]
Phase 4: Architecture Design Generation
↓ [Outputs feed Phase 5]
Phase 5: Scaffolding Sprint Story Generation
↓ [Outputs feed Phase 6]
Phase 6: Story Analysis
↓ [Outputs feed Phase 7A]
Phase 7A: Implementation
↓ [Outputs feed Phase 7B]
Phase 7B: Unit Testing
Vision Statement Generation Prompt
Define a comprehensive project vision statement that aligns with project requirements.
Initial Inputs Required:
- Project idea or problem statement
Key Outputs → [Feed into Phase 2]:
- Vision Statement Document (
project_vision.md)
Initial Project Requirements Management Prompt
Define and document core project requirements based on the vision statement.
Required Inputs (including Phase 1 outputs):
- Vision Statement Document
Key Outputs → [Feed into Phase 3]:
- Core Requirements Document (
core_requirements.md)
Technology Stack Generation Prompt
Define and document a compatible, version-locked technology stack.
Required Inputs (including Phase 2 outputs):
- Core Requirements Document
Key Outputs → [Feed into Phase 4]:
- Technology Stack Document (
tech_stack.md)
Architecture Design Generator Prompt
Define core architectural components needed for initial project scaffolding.
Required Inputs (including Phase 3 outputs):
- Technology Stack Document
Key Outputs → [Feed into Phase 5]:
- Architecture Design Document (
initial_architecture.md)
Scaffolding Sprint Story Generation Prompt
Generate focused user stories for the initial project scaffolding sprint.
Required Inputs (including Phase 4 outputs):
- Architecture Design Document
Key Outputs → [Feed into Phase 6]:
- Scaffolding Sprint Stories (
sprint_1_stories.md)
Break down user stories into atomic, implementable functional steps.
Initial Inputs Required:
- Scaffolding Sprint Story
Key Outputs → [Feed into Phase 7A]:
- Story Steps Report (
S<X.Y>-story-steps.md)
Systematically implement one specific step from the story analysis.
Key Outputs → [Feed into Phase 7B]:
- Code changes implementing the specified step
Conditional Prompt:* During the implementation phase, if the Implementation Prompt determines that new dependencies may be required to implement a user story step, it will prompt the user to execute the Dependency Management Prompt. This ensures that all necessary dependencies are evaluated and approved before proceeding with the implementation.
Iteration Note: Phases 7A and 7B iterate until all steps for a user story have been implemented and unit tested.
Generate and verify unit tests for the implemented story step.
Required Inputs (including Phase 6 outputs):
- Story Steps Report (
S<X.Y>-story-steps.md) - Scaffolding Sprint Story
Key Outputs:
- Unit tests for the implemented step
- Test results indicating pass/fail status
-
Initiate Vision Statement Generation:
#generate-vision- Ensure all Phase 1 inputs are available
- Wait for complete vision statement before proceeding
-
Generate Requirements:
#generate-requirements- Must have all Phase 1 outputs available
- Proceeds only when vision statement is complete
-
Generate Technology Stack:
#generate-stack- Ensure all Phase 2 outputs are available
- Wait for stack generation to complete before proceeding
-
Generate Architecture Design:
#generate-architecture- Ensure all Phase 3 outputs are available
- Wait for architecture design to complete before proceeding
-
Generate Scaffolding Stories:
#generate-scaffold-stories- Ensure all Phase 4 outputs are available
- Wait for story generation to complete before proceeding
-
Analyze Story:
#analyze-story S<X.Y>- Ensure the specific user story is available in the context
- Wait for story analysis to complete before proceeding
-
Implement Stories, step by step:
#implement-step S<X.Y> [step-number]- Requires complete story analysis outputs
- Execute for each story and step, in sequence
Monitor chain progress using status commands:
#vision-status
#requirements-status
#stack-status
#architecture-status
#scaffold-stories-status
#analysis-status
#implementation-status
Vision Statement Generation
└── Outputs required for Requirements Management:
├── Vision Statement Document
└── Requirements Management
└── Outputs required for Technology Stack Generation:
├── Core Requirements Document
└── Technology Stack Generation
└── Outputs required for Architecture Design:
├── Technology Stack Document
└── Architecture Design
└── Outputs required for Scaffolding Story Generation:
├── Architecture Design Document
└── Scaffolding Story Generation
└── Outputs required for Story Analysis:
├── Scaffolding Sprint Stories
└── Story Analysis
└── Outputs required for Implementation:
├── Story Steps Report
├── Scaffolding Sprint Story
└── Implementation
└── Outputs required for Unit Testing:
├── Code changes implementing the specified step
└── Unit Testing
Each phase has specific verification points where the chain integrity must be confirmed:
-
Vision → Requirements
- Verify vision statement is complete
-
Requirements → Technology Stack
- Verify all requirements are documented
-
Technology Stack → Architecture Design
- Verify technology stack is complete
-
Architecture Design → Scaffolding Stories
- Verify architecture design is complete
-
Scaffolding Stories → Story Analysis
- Verify all stories have required components
-
Story Analysis → Implementation
- Verify story steps report is complete
To maintain workflow integrity:
- Never skip phases or assume outputs
- Verify all outputs before proceeding to next phase
- Keep all documentation updated as you progress
- Use status commands to confirm current state
- Don't proceed if required inputs are missing
-
Document Management
- Keep all phase outputs in accessible locations
- Document any modifications to outputs
- Version control all artifacts
-
Phase Transitions
- Explicitly verify all required outputs exist
- Validate output quality before proceeding
- Document any assumptions or decisions
-
Dependency Handling
- Track both technical and workflow dependencies
- Verify dependency satisfaction at each step
- Document any dependency changes
-
Preparation
- Gather all initial inputs
- Verify input completeness
- Set up documentation structure
-
Execution
- Follow the chain sequence strictly
- Verify outputs at each step
- Maintain documentation of progress
-
Verification
- Use status commands frequently
- Verify chain integrity at each phase
- Document completion of each phase
This workflow chain has been tested with different LLMs:
- AI Assistant: aider
- Implementation Prompt: Claude 3.5 Sonnet (October 22, 2024 release)
- Other Workflow Prompts: Claude 3.5 Haiku (October 22, 2024 release)
The chain assumes:
- AI can handle file operations
- Developer verifies all outputs
- Each phase completes fully before chain proceeds
Before starting each phase, verify:
- All required inputs are available
- Previous phase outputs are complete
- All dependencies are satisfied
- Documentation is current
Remember: The strength of this workflow lies in its chained nature. Each phase builds upon the outputs of the previous phase, creating a comprehensive and connected development process.