Implement

# Claude Color Implementation Loop

> Autonomous implementation command for Claude Color

## Objective

Implement Claude Color from start to finish, following the design document and feature list.

## Pre-Loop Checks

Before starting, verify:
1. `feature_list.json` exists and is valid JSON
2. `CLAUDE.md` exists with full context
3. All scripts in `scripts/` are executable

```bash
chmod +x scripts/*.sh
cat feature_list.json | jq '.' > /dev/null && echo "feature_list.json valid"

The Loop

1. Read Current State

# What phase are we in?
cat feature_list.json | jq '.phases[] | select(.features[].status == "in_progress" or (.status == "pending" and (.features | all(.status == "pending")))) | {name, status}'

# What feature is in progress?
cat feature_list.json | jq '.phases[].features[] | select(.status == "in_progress")'

# If none in progress, what's next?
cat feature_list.json | jq '.phases[].features[] | select(.status == "pending") | {id, name}' | head -20

2. Mark Feature In Progress

Before starting work on a feature:

./scripts/update-feature.sh <feature-id> in_progress

3. Implement the Feature

Follow these rules:

• Read the feature definition from feature_list.json
• Check CLAUDE.md for relevant architecture details
• Create/modify only the files listed for that feature
• Write tests alongside implementation
• Commit after each logical chunk

4. Test the Feature

Run the feature's specific tests:

# Unit tests
npm test -- --testPathPattern="<relevant-pattern>"

# Or run phase verification
./scripts/verify-phase-X.sh

5. Update Status

If tests pass:

./scripts/update-feature.sh <feature-id> passing
./scripts/update-progress.sh "Completed <feature-name>: <brief description>"
git add -A && git commit -m "feat(<phase>): <feature-name>"

If tests fail:

# DO NOT mark as passing
# Fix the issue and re-test
# Only mark passing when tests actually pass

6. Check Phase Completion

After each feature, check if phase is complete:

./scripts/verify-phase-X.sh

If phase verification passes, update phase status and move to next phase.

7. Context Management

Every 3-5 features, or when context is getting long:

./scripts/snapshot-context.sh
./scripts/update-progress.sh "Context snapshot created, continuing..."

8. Repeat

Go back to step 1 until all features are passing.

Error Recovery

If a feature is stuck

1. Mark as failing with notes
2. Document in issues.md
3. Skip to next non-dependent feature
4. Return later with fresh context

If build breaks

1. Stop and fix immediately
2. Don't proceed with broken build
3. Run full test suite before continuing

If context is lost

1. Read context-snapshot.md
2. Read claude-progress.txt (last 50 lines)
3. Read feature_list.json for current state
4. Continue from where we left off

Commit Conventions

feat(phase-1): add electron shell boilerplate
feat(phase-2): implement bridge client
fix(phase-3): correct tool parameter types
test(phase-4): add classifier unit tests
docs: update progress log

Success Criteria

Implementation is complete when:

1. All features in feature_list.json are passing
2. All phase verification scripts pass
3. npm run build succeeds
4. E2E tests pass
5. App launches and basic workflow works

Start Command

/ralph-loop

Then follow the loop above, one feature at a time. ```