Atlas Full

Phase 1: Research

Goal: Deep understanding of requirements, feasibility, and technical landscape.

Time allocation: 20-30 minutes

Steps:

1. Define the problem space

   • What problem are we solving?
   • Who are the users?
   • What are the business requirements?
   • What are the technical constraints?

2. Explore current implementation

   # Find all related code
   grep -r "related_feature" src/
   
   # Find similar patterns
   find src/ -name "*similar*"
   
   # Check git history for similar features
   git log --grep="similar feature" --oneline
   

3. Research dependencies and integrations

   • What external services/APIs are involved?
   • What internal modules will be affected?
   • What platform-specific considerations exist?
   • What are the data flow implications?

4. Identify risks and constraints

   • Technical risks (performance, compatibility, security)
   • Timeline constraints
   • Resource constraints
   • Platform limitations

5. Evaluate alternatives

   • What are different approaches to solve this?
   • What are the trade-offs?
   • What's the recommended approach?

Research Checklist:

Problem Understanding:

• Clear problem statement
• User stories identified
• Success metrics defined
• Constraints documented

Technical Research:

• Current implementation mapped
• Similar patterns found
• Dependencies identified
• Platform considerations noted

Risk Analysis:

• Technical risks listed
• Security implications assessed
• Performance implications considered
• Migration/rollback strategy outlined

Feasibility:

• Technically feasible
• Timeline realistic
• Resources available
• No blockers identified

Research Output Template:

## Research Findings: [Feature Name]

### Problem Statement:
[Clear description of what we're solving]

### Users Affected:
- [User type 1]: [how they benefit]
- [User type 2]: [how they benefit]

### Technical Approach:
[High-level approach, alternatives considered]

### Files to Create/Modify:
- /path/to/new/file.js - [purpose]
- /path/to/existing/file.js - [what changes]
- /path/to/test/file.test.js - [test coverage]

### Dependencies:
- External: [external packages, APIs]
- Internal: [internal modules, services]

### Platform Considerations:
- **Platform A**: [specific notes]
- **Platform B**: [specific notes]
- **Platform C**: [specific notes]

### Risks:
1. [Risk 1] - Mitigation: [strategy]
2. [Risk 2] - Mitigation: [strategy]

### Success Metrics:
- [Metric 1]: [target]
- [Metric 2]: [target]

### Timeline Estimate:
- Research: [time]
- Implementation: [time]
- Testing: [time]
- Total: [time]

Phase 2: Story Creation

Goal: Create formal user stories with acceptance criteria and success metrics.

Time allocation: 15-20 minutes

Steps:

1. Write user stories

   • Use standard format: "As a [user], I want [goal], so that [benefit]"
   • Break down complex features into multiple stories
   • Prioritize stories (must-have, should-have, nice-to-have)

2. Define acceptance criteria

   • Specific, measurable, testable criteria
   • Cover happy path and edge cases
   • Include performance requirements
   • Include platform-specific criteria (if applicable)

3. Set success metrics

   • How will we measure success?
   • What are the targets?
   • How will we collect data?

4. Create testing scenarios

   • Manual testing checklist
   • Automated test requirements
   • Cross-platform testing plan (if applicable)

Story Template:

Use the template in resources/story-template.md for consistent formatting.

Story Validation Checklist:

• User story follows "As a...I want...So that" format
• Acceptance criteria are specific and testable
• Edge cases covered
• Platform-specific requirements included (if applicable)
• Success metrics defined with targets
• Testing scenarios documented
• Dependencies identified
• Risks documented with mitigation

Phase 3: Planning

Goal: Create detailed technical design and implementation plan.

Time allocation: 20-30 minutes

Steps:

1. Architecture design

   • How will components interact?
   • What's the data flow?
   • Where does state live?
   • How does it integrate with existing systems?

2. File-by-file implementation plan

   • What files to create?
   • What files to modify?
   • What changes in each file?
   • What order to implement?

3. Data schema design

   • What new fields/structures?
   • How to migrate existing data?
   • How does synchronization handle it (if applicable)?
   • What validations needed?

4. Testing strategy

   • Unit tests for each module
   • Integration tests for workflows
   • Platform-specific tests (if applicable)
   • Performance tests

5. Rollout strategy

   • Phased rollout plan
   • Feature flags needed?
   • Rollback plan
   • Monitoring strategy

Planning Template:

## Implementation Plan: [Feature Name]

### Architecture

#### Component Structure:

[Describe component hierarchy or architecture]

#### Data Flow:

User Action → Component → Service → State → UI Update [Detailed flow description]

#### State Management:
- **State location**: [where state lives]
- **State shape**: [schema]
- **Update methods**: [new methods needed]

### File-by-File Plan

#### New Files:
1. **/src/services/newService.js**
   - Purpose: [what it does]
   - Functions:
     - `function1()`: [description]
     - `function2()`: [description]
   - Dependencies: [what it imports]

2. **/src/components/NewComponent.js**
   - Purpose: [what it does]
   - Props: [prop schema]
   - State: [local state]

#### Modified Files:
1. **/src/existing/file.js**
   - Add: [new functionality]
   - Modify: [existing behavior]

#### Test Files:
1. **/tests/services/newService.test.js**
   - Test coverage:
     - [ ] Unit tests for all functions
     - [ ] Edge cases
     - [ ] Error handling

### Data Schema

#### New Fields:
```javascript