BB Planning Templates

A collection of template examples that BB can create for different types of tasks and projects. Use these as inspiration when asking BB to create custom templates for your specific needs.

These templates demonstrate how BB can help structure your work. You can ask BB to create similar templates tailored to your specific needs, or to document your current conversation's progress in a similar format.

Basic Planning Template

A versatile template suitable for most projects. Helps organize thoughts and plan conversations effectively.

View Template
# Project Task Planning Document

## Overview
- Task Description: [Brief description of what needs to be done]
- Estimated Scope: [Small/Medium/Large]
- Related Files: [List of key files that will be involved]

## Objectives
1. [Primary objective]
2. [Secondary objective]
3. [Additional objectives...]

## File Management
### Core Files
- `path/to/file1.ext`
- `path/to/file2.ext`

### Related Files
- `path/to/related1.ext`
- `path/to/related2.ext`

## Conversation Planning

### Initial Conversation
**Purpose:** [What this conversation will accomplish]
**Key Files:** [Files needed for this conversation]
**Instructions for BB:**
1. [First instruction]
2. [Second instruction]
3. [Additional instructions...]

### Follow-up Conversations
1. **Conversation: [Topic]**
   - Purpose: [What this conversation will accomplish]
   - Key Files: [Files needed]
   - Instructions: [Specific instructions]

## Notes
- [Important considerations]
- [Potential challenges]
- [Dependencies]

## Success Criteria
- [ ] [Criterion 1]
- [ ] [Criterion 2]
- [ ] [Additional criteria...]

API Refactoring Example

An example of planning a complex API refactoring project, showing how to break down the work into manageable conversations.

View Template
# API Refactoring Project Plan

## Overview
- Task Description: Refactor authentication API to support OAuth 2.0
- Estimated Scope: Large
- Related Files: Authentication system and API endpoints

## Objectives
1. Implement OAuth 2.0 support
2. Maintain backward compatibility
3. Update documentation
4. Add new test coverage

## File Management
### Core Files
- `src/auth/authenticator.ts`
- `src/auth/middleware.ts`
- `src/api/auth-routes.ts`

### Related Files
- `tests/auth/*.test.ts`
- `docs/api/auth.md`
- `config/auth-config.ts`

## Conversation Planning

### Initial Conversation: Architecture Planning
**Purpose:** Design the OAuth implementation approach
**Key Files:**
- `src/auth/authenticator.ts`
- `docs/api/auth.md`

**Instructions for BB:**
1. Review current authentication implementation
2. Analyze OAuth 2.0 requirements
3. Propose architecture changes
4. Document key decision points

### Follow-up Conversations
1. **Conversation: Core Implementation**
   - Purpose: Implement OAuth 2.0 authenticator
   - Key Files: `src/auth/authenticator.ts`, `config/auth-config.ts`
   - Instructions:
     1. Implement OAuth 2.0 flow
     2. Add configuration options
     3. Ensure backward compatibility

2. **Conversation: API Routes Update**
   - Purpose: Update API endpoints for OAuth
   - Key Files: `src/api/auth-routes.ts`, `src/auth/middleware.ts`
   - Instructions:
     1. Add OAuth endpoints
     2. Update middleware
     3. Add validation

3. **Conversation: Testing**
   - Purpose: Add test coverage
   - Key Files: `tests/auth/*.test.ts`
   - Instructions:
     1. Add OAuth flow tests
     2. Update existing tests
     3. Add integration tests

## Notes
- Must maintain existing session-based auth for legacy clients
- Consider rate limiting for OAuth endpoints
- Plan for token storage and refresh flows

## Success Criteria
- [ ] OAuth 2.0 flow working end-to-end
- [ ] Existing auth still works
- [ ] 90%+ test coverage
- [ ] Documentation updated
- [ ] Performance tests pass

Documentation Update Template

A template for planning documentation updates, incorporating user feedback and ensuring comprehensive coverage.

View Template
# Documentation Update Plan

## Overview
- Task Description: [Description of documentation changes needed]
- Motivation: [Why these changes are needed]
- User Feedback: [Summary of user feedback/issues]

## Documentation Scope
### Core Documents
- `path/to/doc1.md`: [Brief description of changes needed]
- `path/to/doc2.md`: [Brief description of changes needed]

### Related Documents
- `path/to/related1.md`: [Impact/changes needed]
- `path/to/related2.md`: [Impact/changes needed]

### New Documents Needed
- `path/to/new1.md`: [Purpose and content outline]
- `path/to/new2.md`: [Purpose and content outline]

## User Feedback Analysis
### Key Issues
1. [Issue 1]
   - User Impact: [Description]
   - Proposed Solution: [Solution]

2. [Issue 2]
   - User Impact: [Description]
   - Proposed Solution: [Solution]

## Conversation Planning

### Initial Conversation: Content Review
**Purpose:** Review current documentation and plan updates
**Files to Review:**
- [List of files]
**Instructions for BB:**
1. Review current documentation structure
2. Analyze user feedback points
3. Suggest improvements
4. Plan content organization

### Follow-up Conversations
1. **Conversation: Content Updates**
   - Purpose: Update existing documentation
   - Files: [List of files]
   - Instructions:
     1. Update content for clarity
     2. Add missing information
     3. Improve examples

2. **Conversation: New Content Creation**
   - Purpose: Create new documentation
   - Files: [List of new files]
   - Instructions:
     1. Create initial content
     2. Add examples
     3. Ensure consistency

3. **Conversation: Review & Integration**
   - Purpose: Final review and integration
   - Files: [All affected files]
   - Instructions:
     1. Review all changes
     2. Check cross-references
     3. Verify completeness

## Style Guidelines
- [Specific style requirements]
- [Formatting conventions]
- [Voice and tone guidelines]

## Success Criteria
- [ ] All user feedback points addressed
- [ ] New documentation created and integrated
- [ ] Existing documentation updated
- [ ] Cross-references and links verified
- [ ] Style guidelines followed
- [ ] Technical accuracy verified

## Follow-up Plan
- Plan for gathering new user feedback
- Schedule for regular reviews
- Process for maintaining updates

Code Review Template

A template for structuring code review conversations, focusing on different aspects of the review process.

View Template
# Code Review Plan

## Overview
- Review Scope: [Description of code to be reviewed]
- Type of Changes: [Feature/Bug Fix/Refactor/etc.]
- Priority Level: [High/Medium/Low]

## Files to Review
### Primary Changes
- `path/to/file1.ext`: [Description of changes]
- `path/to/file2.ext`: [Description of changes]

### Related Files
- `path/to/related1.ext`: [Why relevant]
- `path/to/related2.ext`: [Why relevant]

## Review Categories

### Functionality
- [ ] Logic correctness
- [ ] Edge cases handled
- [ ] Error handling
- [ ] Input validation

### Performance
- [ ] Algorithm efficiency
- [ ] Resource usage
- [ ] Caching considerations
- [ ] Query optimization

### Security
- [ ] Input sanitization
- [ ] Authentication/Authorization
- [ ] Data protection
- [ ] Security best practices

### Code Quality
- [ ] Code style consistency
- [ ] Documentation
- [ ] Test coverage
- [ ] Code duplication

## Conversation Planning

### Initial Conversation: Overview
**Purpose:** Understand changes and plan review
**Instructions for BB:**
1. Review change summary
2. Identify critical areas
3. Plan review approach
4. Note potential concerns

### Follow-up Conversations
1. **Conversation: Detailed Review**
   - Purpose: In-depth code analysis
   - Focus Areas:
     1. Functionality verification
     2. Performance analysis
     3. Security review

2. **Conversation: Improvements**
   - Purpose: Suggest enhancements
   - Areas:
     1. Code organization
     2. Performance optimizations
     3. Security hardening

## Review Notes
- [Important observations]
- [Potential issues]
- [Improvement suggestions]

## Action Items
- [ ] [Required change 1]
- [ ] [Required change 2]
- [ ] [Suggested improvement 1]

## Follow-up Tasks
- [ ] Verify changes implemented
- [ ] Re-review critical sections
- [ ] Update documentation
- [ ] Add/update tests

Bug Investigation Template

A template for structuring bug investigation sessions, tracking progress, and documenting findings.

View Template
# Bug Investigation Plan

## Bug Overview
- Issue Description: [Detailed description]
- Severity: [Critical/High/Medium/Low]
- Affected Systems: [List of affected systems/features]
- Reported By: [Source of bug report]

## Reproduction Steps
1. [Step 1]
2. [Step 2]
3. [Step 3]

## Environment Details
- Environment: [Production/Staging/Development]
- Version: [Software version]
- Dependencies: [Relevant dependency versions]
- Configuration: [Relevant settings]

## Affected Files
### Primary Suspects
- `path/to/file1.ext`: [Why suspected]
- `path/to/file2.ext`: [Why suspected]

### Related Files
- `path/to/related1.ext`: [Relationship to issue]
- `path/to/related2.ext`: [Relationship to issue]

## Investigation Plan

### Initial Conversation: Bug Analysis
**Purpose:** Understand the bug and plan investigation
**Instructions for BB:**
1. Review bug description and reproduction steps
2. Analyze affected files
3. Identify potential causes
4. Plan investigation approach

### Follow-up Conversations
1. **Conversation: Code Investigation**
   - Purpose: Analyze suspicious code paths
   - Files: [List relevant files]
   - Focus Areas:
     1. Error handling
     2. Edge cases
     3. Data flow

2. **Conversation: Testing**
   - Purpose: Create/modify tests
   - Tasks:
     1. Reproduction test
     2. Edge case tests
     3. Regression tests

## Investigation Notes
### Observations
- [Observation 1]
- [Observation 2]

### Hypotheses
1. [Hypothesis 1]
   - Evidence for:
   - Evidence against:

2. [Hypothesis 2]
   - Evidence for:
   - Evidence against:

## Test Cases
### Reproduction Test
```typescript
// Test code here
```

### Edge Cases
1. [Edge case 1]
2. [Edge case 2]

## Fix Planning
### Proposed Solutions
1. [Solution 1]
   - Pros:
   - Cons:
   - Impact:

2. [Solution 2]
   - Pros:
   - Cons:
   - Impact:

## Success Criteria
- [ ] Bug can be reliably reproduced
- [ ] Root cause identified
- [ ] Fix implemented and tested
- [ ] Regression tests added
- [ ] Documentation updated

## Follow-up Actions
- [ ] Update error handling
- [ ] Add monitoring/logging
- [ ] Review similar code
- [ ] Update documentation

Feature Implementation Template

A template for planning and implementing new features, breaking down the work into manageable pieces.

View Template
# Feature Implementation Plan

## Feature Overview
- Name: [Feature name]
- Description: [Detailed description]
- Priority: [High/Medium/Low]
- Target Release: [Version/Sprint]

## Requirements
### Functional Requirements
1. [Requirement 1]
2. [Requirement 2]

### Technical Requirements
1. [Technical requirement 1]
2. [Technical requirement 2]

### UI/UX Requirements
1. [UI requirement 1]
2. [UX requirement 2]

## Implementation Scope
### New Files Needed
- `path/to/new1.ext`: [Purpose]
- `path/to/new2.ext`: [Purpose]

### Files to Modify
- `path/to/existing1.ext`: [Changes needed]
- `path/to/existing2.ext`: [Changes needed]

## Architecture
### Components
1. [Component 1]
   - Purpose:
   - Responsibilities:
   - Interactions:

2. [Component 2]
   - Purpose:
   - Responsibilities:
   - Interactions:

### Data Flow
1. [Flow step 1]
2. [Flow step 2]

## Conversation Planning

### Initial Conversation: Design
**Purpose:** Plan feature implementation
**Instructions for BB:**
1. Review requirements
2. Design component structure
3. Plan implementation phases
4. Identify potential challenges

### Follow-up Conversations
1. **Conversation: Core Implementation**
   - Purpose: Implement main functionality
   - Files: [List files]
   - Tasks:
     1. Create base structure
     2. Implement core logic
     3. Add error handling

2. **Conversation: UI Implementation**
   - Purpose: Implement user interface
   - Files: [List UI files]
   - Tasks:
     1. Create components
     2. Add styling
     3. Implement interactions

3. **Conversation: Testing**
   - Purpose: Add test coverage
   - Tasks:
     1. Unit tests
     2. Integration tests
     3. UI tests

## Testing Strategy
### Unit Tests
- [Test area 1]
- [Test area 2]

### Integration Tests
- [Test scenario 1]
- [Test scenario 2]

### UI Tests
- [UI test 1]
- [UI test 2]

## Success Criteria
- [ ] All requirements implemented
- [ ] Tests passing
- [ ] Documentation complete
- [ ] Performance metrics met
- [ ] Accessibility requirements met

## Rollout Plan
1. [Development phase]
2. [Testing phase]
3. [Deployment phase]

## Documentation Needs
- [ ] API documentation
- [ ] User documentation
- [ ] Development notes
- [ ] Configuration guide

Project Analysis Template

A template for analyzing existing codebases, understanding patterns, and planning improvements.

View Template
# Project Analysis Plan

## Analysis Overview
- Project Name: [Project name]
- Purpose: [Analysis goals]
- Focus Areas: [Key areas to analyze]

## Project Structure
### Core Components
- `path/to/component1`: [Purpose and role]
- `path/to/component2`: [Purpose and role]

### Key Files
- `path/to/file1.ext`: [Significance]
- `path/to/file2.ext`: [Significance]

## Analysis Categories

### Architecture
- [ ] Component organization
- [ ] Dependency patterns
- [ ] Communication flows
- [ ] Data management

### Code Patterns
- [ ] Design patterns used
- [ ] Common implementations
- [ ] Consistency analysis
- [ ] Anti-patterns

### Technical Debt
- [ ] Outdated patterns
- [ ] Maintenance issues
- [ ] Performance bottlenecks
- [ ] Security concerns

## Conversation Planning

### Initial Conversation: Overview
**Purpose:** Understand project structure
**Instructions for BB:**
1. Review project organization
2. Identify key patterns
3. Note areas of interest
4. Plan detailed analysis

### Follow-up Conversations
1. **Conversation: Architecture Analysis**
   - Purpose: Analyze system architecture
   - Focus:
     1. Component relationships
     2. Dependency management
     3. System boundaries

2. **Conversation: Pattern Analysis**
   - Purpose: Review code patterns
   - Focus:
     1. Common patterns
     2. Implementation consistency
     3. Improvement opportunities

3. **Conversation: Technical Debt**
   - Purpose: Identify improvement needs
   - Focus:
     1. Maintenance issues
     2. Performance problems
     3. Security concerns

## Analysis Notes
### Strengths
- [Strength 1]
- [Strength 2]

### Areas for Improvement
- [Area 1]
- [Area 2]

### Recommendations
1. [Recommendation 1]
   - Impact:
   - Effort:
   - Priority:

2. [Recommendation 2]
   - Impact:
   - Effort:
   - Priority:

## Metrics
### Code Quality
- [Metric 1]: [Value]
- [Metric 2]: [Value]

### Performance
- [Metric 1]: [Value]
- [Metric 2]: [Value]

## Action Items
### Immediate Actions
- [ ] [Action 1]
- [ ] [Action 2]

### Long-term Improvements
- [ ] [Improvement 1]
- [ ] [Improvement 2]

## Documentation Needs
- [ ] Architecture documentation
- [ ] Pattern guidelines
- [ ] Improvement roadmap
- [ ] Best practices guide