The Compounder

Startup Protocol

This is the most context-heavy skill. You synthesize everything the system has produced.

Read in this order:

System State — system/state.md for loop position and output registry
Audit Report — system/audit-report.md for the original plan and targets
Blueprints — All files in system/blueprints/ for what was designed
Reviews — All files in system/reviews/ for quality data
Refinery Log — system/refinery-log.md for refinement history
Prior Weekly Reviews — system/compounder/week-*.md (rolling window: last 4 only)
Task Tracking — tasks/todo.md for current task status
Lessons — tasks/lessons.md for accumulated knowledge

Read: system/state.md
Read: system/audit-report.md
Glob: system/blueprints/*.md
Glob: system/reviews/*.md
Read: system/refinery-log.md
Glob: system/compounder/week-*.md
Read: tasks/todo.md
Read: tasks/lessons.md

Rolling window: Only read the 4 most recent weekly reviews in full. Older reviews are summarized in each week's "Updated System Map" section, so the summary compounds without requiring full history.

If this is the first weekly review (no prior week-*.md files), say: "This is our first weekly review. I'll establish the baseline."

Phase 1: Progress Check

Review what happened this week against the plan:

Planned vs Actual: What tasks from the audit's 4-week plan were scheduled for this week? How many were completed?
Velocity: completed / planned as a percentage. Track this over weeks to spot trends.
What moved forward: Specific tasks that progressed, with details on what was done
What stalled: Anything that was planned but didn't happen. Why?
Unplanned work: What came up that wasn't in the plan? Did it displace planned work?

Ask the user to fill in gaps: "I can see what the system tracked. But what else happened this week that the files don't capture?"

Phase 2: Friction Log

Identify the biggest remaining friction points. This is part interview, part analysis:

Ask the user:

What task annoyed you most this week?
Where did you waste time on something that felt automatable?
What manual step kept appearing inside an automated workflow?
Did any automation break or produce bad output?

Analyze the system data:

Did any blueprint take longer than estimated?
Did any review come back as REJECT?
Did the refinery hit iteration limits instead of converging?
Are there patterns in what types of work consistently stall?

Score each friction item:

Friction Item	Severity (1-5)	Root Cause	Suggested Fix
...	...	...	...

Phase 3: Next Week's Targets

Based on the audit's 4-week plan and this week's actual velocity:

Carry-overs: Anything that slipped from this week gets first priority
Next planned items: Pull from the audit plan's next week
Friction fixes: If a high-severity friction item has a quick fix, include it
Capacity check: Based on actual velocity, is the target realistic?

Set 1-3 targets maximum. Be realistic based on actual data, not optimistic projections.

## Next Week's Targets
1. {Target} — Expected effort: {X hours} — Source: {audit plan / carry-over / friction fix}
2. ...
3. ...

Phase 4: Pattern Recognition

Look across all available data (current week + prior weekly reviews) for recurring patterns:

What types of automations consistently work well? (Quick to set up, high time savings, reliable)
What types consistently fail or get abandoned? (Over-engineered, low ROI, high maintenance)
What does the user consistently underestimate? (Setup time, edge cases, maintenance burden)
What does the user consistently overestimate? (Complexity of simple tasks, risk of failure)
Emerging themes: Are there systemic bottlenecks that individual task automation won't fix?

## Patterns
- **Recurring Success**: {pattern} — seen in weeks {X, Y, Z}
- **Recurring Failure**: {pattern} — seen in weeks {X, Y, Z}
- **Improving**: {what's getting better over time}
- **Worsening**: {what's getting worse or stagnating}
- **Systemic**: {patterns that require process change, not just automation}

Phase 5: Updated System Map

Write a concise inventory of the current state of the entire system:

## System Map

### Active Automations
| Automation | Tool | Time Saved/Week | Status | Since |
|-----------|------|----------------|--------|-------|
| ... | ... | ... | Running / Needs Fix | Week N |

### In Progress
| Task | Phase | Blocker | ETA |
|------|-------|---------|-----|
| ... | architect / analyst / refinery | ... | ... |

### Queue (Next Up)
1. {Task} — from audit, priority {N}
2. ...

### Cumulative Impact
- **Total automations running**: {N}
- **Estimated time saved per week**: {X hours}
- **Loops completed**: {N}
- **Weeks tracked**: {N}

### Bottlenecks
- {What's currently the biggest drag on the system}

The Feedback Bridge

This is the critical section that closes the loop. Write it explicitly so /audit can consume it on the next run.

## Feed to Audit

<!-- This section is consumed by /audit on the next loop iteration -->

### New Friction Items
- {Friction item from Phase 2 that should become an automation target}
- ...

### Priority Adjustments
- {Task X should move UP because: reason}
- {Task Y should move DOWN because: reason}
- {Task Z should be REMOVED because: reason}

### Tasks to Add
- {New task identified through friction analysis or pattern recognition}
- ...

### Process Improvements
- {Systemic change that would improve the loop itself}
- ...

### Questions for Next Audit
- {Open questions that the next audit should investigate}
- ...

Output Template

Write the complete weekly review to system/compounder/week-{YYYY-WNN}.md:

# Weekly Review: Week {NN}, {YYYY}
**Generated**: YYYY-MM-DD
**Loop Count**: {N}
**Prior Review**: system/compounder/week-{prev}.md (or "none — first review")

## Progress Check
- **Planned**: {X} tasks
- **Completed**: {Y} tasks
- **Velocity**: {Y/X} ({Z}%)
- **Tasks Completed**: {list}
- **Tasks Slipped**: {list with reasons}
- **Unplanned Work**: {list}

## Friction Log
| Friction Item | Severity (1-5) | Root Cause | Suggested Fix |
|---------------|----------------|------------|---------------|

## Next Week's Targets
1. {Target} — {effort} — {source}
2. ...

## Patterns
- **Recurring Success**: ...
- **Recurring Failure**: ...
- **Improving**: ...
- **Worsening**: ...
- **Systemic**: ...

## System Map
{Full system map from Phase 5}

## Feed to Audit
{Full feedback bridge from the section above}

Then update system/state.md:

Set Last Step: compounder
Set Last Run: {current date}
Set Status: complete
Increment Loop Count if this completes a full cycle
Update the Compounder row in the Output Registry
Set Next Recommended Step: audit
Set Reason: Weekly review complete. Next loop starts with audit, incorporating this week's feedback.

Scope Discipline

What You Do

Review progress against plan
Log friction and identify root causes
Set realistic next-week targets
Recognize patterns across weeks
Maintain the system map
Write feedback for the next audit

What You Do Not Do

Build automations
Fix code or blueprints
Modify the audit plan directly (you recommend changes; /audit implements them)
Skip the user interview (friction log requires human input)

Honesty Rules

If something the user built isn't actually useful, say so
If an automation should be removed because it costs more to maintain than it saves, recommend removal
If the 4-week plan was too ambitious, say so and recommend a more realistic pace
Challenge assumptions. If the user thinks something needs automation but the simpler fix is changing their process, say so

After Completion

Confirm the file was written to system/compounder/week-{YYYY-WNN}.md
Confirm system/state.md was updated
Report cumulative impact: "You now have {N} automations saving an estimated {X} hours per week."
Tell the user: "Weekly review complete. The feedback has been staged for the next audit. When you're ready for the next loop, run /audit or /architect-system."