361 lines
7.8 KiB
Markdown
361 lines
7.8 KiB
Markdown
# BAIME Quick Start Guide
|
||
|
||
**Version**: 1.0
|
||
**Framework**: Bootstrapped AI Methodology Engineering
|
||
**Time to First Iteration**: 45-90 minutes
|
||
|
||
Quick start guide for applying BAIME to create project-specific methodologies.
|
||
|
||
---
|
||
|
||
## What is BAIME?
|
||
|
||
**BAIME** = Bootstrapped AI Methodology Engineering
|
||
|
||
A meta-framework for systematically developing project-specific development methodologies through Observe-Codify-Automate (OCA) cycles.
|
||
|
||
**Use when**: Creating testing strategy, CI/CD pipeline, error handling patterns, documentation systems, or any reusable development methodology.
|
||
|
||
---
|
||
|
||
## 30-Minute Quick Start
|
||
|
||
### Step 1: Define Objective (10 min)
|
||
|
||
**Template**:
|
||
```markdown
|
||
## Objective
|
||
Create [methodology name] for [project] to achieve [goals]
|
||
|
||
## Success Criteria (Dual-Layer)
|
||
**Instance Layer** (V_instance ≥ 0.80):
|
||
- Metric 1: [e.g., coverage ≥ 75%]
|
||
- Metric 2: [e.g., tests pass 100%]
|
||
|
||
**Meta Layer** (V_meta ≥ 0.80):
|
||
- Patterns documented: [target count]
|
||
- Tools created: [target count]
|
||
- Transferability: [≥ 85%]
|
||
```
|
||
|
||
**Example** (Testing Strategy):
|
||
```markdown
|
||
## Objective
|
||
Create systematic testing methodology for meta-cc to achieve 75%+ coverage
|
||
|
||
## Success Criteria
|
||
Instance: coverage ≥ 75%, 100% pass rate
|
||
Meta: 8 patterns documented, 3 tools created, 90% transferable
|
||
```
|
||
|
||
### Step 2: Iteration 0 - Observe (20 min)
|
||
|
||
**Actions**:
|
||
1. Analyze current state
|
||
2. Identify pain points
|
||
3. Measure baseline metrics
|
||
4. Document problems
|
||
|
||
**Commands**:
|
||
```bash
|
||
# Example: Testing
|
||
go test -cover ./... # Baseline coverage
|
||
grep -r "TODO.*test" . # Find gaps
|
||
|
||
# Example: CI/CD
|
||
cat .github/workflows/*.yml # Current pipeline
|
||
# Measure: build time, failure rate
|
||
```
|
||
|
||
**Output**: Baseline document with metrics and problems
|
||
|
||
### Step 3: Iteration 1 - Codify (30 min)
|
||
|
||
**Actions**:
|
||
1. Create 2-3 initial patterns
|
||
2. Document with examples
|
||
3. Apply to project
|
||
4. Measure improvement
|
||
|
||
**Template**:
|
||
```markdown
|
||
## Pattern 1: [Name]
|
||
**When**: [Use case]
|
||
**How**: [Steps]
|
||
**Example**: [Code snippet]
|
||
**Time**: [Minutes]
|
||
```
|
||
|
||
**Output**: Initial patterns document, applied examples
|
||
|
||
### Step 4: Iteration 2 - Automate (30 min)
|
||
|
||
**Actions**:
|
||
1. Identify repetitive tasks
|
||
2. Create automation scripts/tools
|
||
3. Measure speedup
|
||
4. Document tool usage
|
||
|
||
**Example**:
|
||
```bash
|
||
# Coverage gap analyzer
|
||
./scripts/analyze-coverage.sh coverage.out
|
||
|
||
# Test generator
|
||
./scripts/generate-test.sh FunctionName
|
||
```
|
||
|
||
**Output**: Working automation tools, usage docs
|
||
|
||
---
|
||
|
||
## Iteration Structure
|
||
|
||
### Standard Iteration (60-90 min)
|
||
|
||
```
|
||
ITERATION N:
|
||
├─ Observe (20 min)
|
||
│ ├─ Apply patterns from iteration N-1
|
||
│ ├─ Measure results
|
||
│ └─ Identify gaps
|
||
├─ Codify (25 min)
|
||
│ ├─ Refine existing patterns
|
||
│ ├─ Add new patterns for gaps
|
||
│ └─ Document improvements
|
||
└─ Automate (15 min)
|
||
├─ Create/improve tools
|
||
├─ Measure speedup
|
||
└─ Update documentation
|
||
```
|
||
|
||
### Convergence Criteria
|
||
|
||
**Instance Layer** (V_instance ≥ 0.80):
|
||
- Primary metrics met (e.g., coverage, quality)
|
||
- Stable across iterations
|
||
- No critical gaps
|
||
|
||
**Meta Layer** (V_meta ≥ 0.80):
|
||
- Patterns documented and validated
|
||
- Tools created and effective
|
||
- Transferability demonstrated
|
||
|
||
**Stop when**: Both layers ≥ 0.80 for 2 consecutive iterations
|
||
|
||
---
|
||
|
||
## Value Function Calculation
|
||
|
||
### V_instance (Instance Quality)
|
||
|
||
```
|
||
V_instance = weighted_average(metrics)
|
||
|
||
Example (Testing):
|
||
V_instance = 0.5 × (coverage/target) + 0.3 × (pass_rate) + 0.2 × (speed)
|
||
= 0.5 × (75/75) + 0.3 × (1.0) + 0.2 × (0.9)
|
||
= 0.5 + 0.3 + 0.18
|
||
= 0.98 ✓
|
||
```
|
||
|
||
### V_meta (Methodology Quality)
|
||
|
||
```
|
||
V_meta = 0.4 × completeness + 0.3 × reusability + 0.3 × automation
|
||
|
||
Where:
|
||
- completeness = patterns_documented / patterns_needed
|
||
- reusability = transferability_score (0-1)
|
||
- automation = time_saved / time_manual
|
||
|
||
Example:
|
||
V_meta = 0.4 × (8/8) + 0.3 × (0.90) + 0.3 × (0.75)
|
||
= 0.4 + 0.27 + 0.225
|
||
= 0.895 ✓
|
||
```
|
||
|
||
---
|
||
|
||
## Common Patterns
|
||
|
||
### Pattern 1: Gap Closure
|
||
|
||
**When**: Improving metrics systematically (coverage, quality, etc.)
|
||
|
||
**Steps**:
|
||
1. Measure baseline
|
||
2. Identify gaps (prioritized)
|
||
3. Create pattern to address top gap
|
||
4. Apply pattern
|
||
5. Re-measure
|
||
|
||
**Example**: Test coverage 60% → 75%
|
||
- Identify 10 uncovered functions
|
||
- Create table-driven test pattern
|
||
- Apply to top 5 functions
|
||
- Coverage increases to 68%
|
||
- Repeat
|
||
|
||
### Pattern 2: Problem-Pattern-Solution
|
||
|
||
**When**: Documenting reusable solutions
|
||
|
||
**Template**:
|
||
```markdown
|
||
## Problem
|
||
[What problem does this solve?]
|
||
|
||
## Context
|
||
[When does this problem occur?]
|
||
|
||
## Solution
|
||
[How to solve it?]
|
||
|
||
## Example
|
||
[Concrete code example]
|
||
|
||
## Results
|
||
[Measured improvements]
|
||
```
|
||
|
||
### Pattern 3: Automation-First
|
||
|
||
**When**: Task done >3 times
|
||
|
||
**Steps**:
|
||
1. Identify repetitive task
|
||
2. Measure time manually
|
||
3. Create script/tool
|
||
4. Measure time with automation
|
||
5. Calculate ROI = time_saved / time_invested
|
||
|
||
**Example**:
|
||
- Manual coverage analysis: 15 min
|
||
- Script creation: 30 min
|
||
- Script execution: 30 sec
|
||
- ROI: (15 min × 20 uses) / 30 min = 10x
|
||
|
||
---
|
||
|
||
## Rapid Convergence Tips
|
||
|
||
### Achieve 3-4 Iteration Convergence
|
||
|
||
**1. Strong Iteration 0**
|
||
- Comprehensive baseline analysis
|
||
- Clear problem taxonomy
|
||
- Initial pattern seeds
|
||
|
||
**2. Focus on High-Impact**
|
||
- Address top 20% problems (80% impact)
|
||
- Create patterns for frequent tasks
|
||
- Automate high-ROI tasks first
|
||
|
||
**3. Parallel Pattern Development**
|
||
- Work on 2-3 patterns simultaneously
|
||
- Test on multiple examples
|
||
- Iterate quickly
|
||
|
||
**4. Borrow from Prior Work**
|
||
- Reuse patterns from similar projects
|
||
- Adapt proven solutions
|
||
- 70-90% transferable
|
||
|
||
---
|
||
|
||
## Anti-Patterns
|
||
|
||
### ❌ Don't Do
|
||
|
||
1. **No baseline measurement**
|
||
- Can't measure progress without baseline
|
||
- Always start with Iteration 0
|
||
|
||
2. **Premature automation**
|
||
- Automate before understanding problem
|
||
- Manual first, automate once stable
|
||
|
||
3. **Pattern bloat**
|
||
- Too many patterns (>12)
|
||
- Keep it focused and actionable
|
||
|
||
4. **Ignoring transferability**
|
||
- Project-specific hacks
|
||
- Aim for 80%+ transferability
|
||
|
||
5. **Skipping validation**
|
||
- Patterns not tested on real examples
|
||
- Always validate with actual usage
|
||
|
||
### ✅ Do Instead
|
||
|
||
1. Start with baseline metrics
|
||
2. Manual → Pattern → Automate
|
||
3. 6-8 core patterns maximum
|
||
4. Design for reusability
|
||
5. Test patterns immediately
|
||
|
||
---
|
||
|
||
## Success Indicators
|
||
|
||
### After Iteration 1
|
||
|
||
- [ ] 2-3 patterns documented
|
||
- [ ] Baseline metrics improved 10-20%
|
||
- [ ] Patterns applied to 3+ examples
|
||
- [ ] Clear next steps identified
|
||
|
||
### After Iteration 3
|
||
|
||
- [ ] 6-8 patterns documented
|
||
- [ ] Instance metrics at 70-80% of target
|
||
- [ ] 1-2 automation tools created
|
||
- [ ] Patterns validated across contexts
|
||
|
||
### Convergence (Iteration 4-6)
|
||
|
||
- [ ] V_instance ≥ 0.80 (2 consecutive)
|
||
- [ ] V_meta ≥ 0.80 (2 consecutive)
|
||
- [ ] No critical gaps remaining
|
||
- [ ] Transferability ≥ 85%
|
||
|
||
---
|
||
|
||
## Examples by Domain
|
||
|
||
### Testing Methodology
|
||
- **Iterations**: 6
|
||
- **Patterns**: 8 (table-driven, fixture, CLI, etc.)
|
||
- **Tools**: 3 (coverage analyzer, test generator, guide)
|
||
- **Result**: 72.5% coverage, 5x speedup
|
||
|
||
### Error Recovery
|
||
- **Iterations**: 3
|
||
- **Patterns**: 13 error categories, 10 recovery patterns
|
||
- **Tools**: 3 (path validator, size checker, read-before-write)
|
||
- **Result**: 95.4% error classification, 23.7% automated prevention
|
||
|
||
### CI/CD Pipeline
|
||
- **Iterations**: 5
|
||
- **Patterns**: 7 pipeline stages, 4 optimization patterns
|
||
- **Tools**: 2 (pipeline analyzer, config generator)
|
||
- **Result**: Build time 8min → 3min, 100% reliability
|
||
|
||
---
|
||
|
||
## Getting Help
|
||
|
||
**Stuck on**:
|
||
- **Iteration 0**: Read baseline-quality-assessment skill
|
||
- **Slow convergence**: Read rapid-convergence skill
|
||
- **Validation**: Read retrospective-validation skill
|
||
- **Agent prompts**: Read agent-prompt-evolution skill
|
||
|
||
---
|
||
|
||
**Source**: BAIME Framework (Bootstrap experiments 001-013)
|
||
**Status**: Production-ready, validated across 13 methodologies
|
||
**Success Rate**: 100% convergence, 3.1x average speedup
|