Momentum Keeper

Overview

momentum-keeper provides systematic strategies for maintaining forward progress and preventing development stalls. It helps detect momentum loss early, identify and resolve blockers, find quick wins, manage energy, and ensure projects continue to completion.

Purpose: Keep development moving forward consistently until objectives achieved

The 6 Momentum Operations:

Detect Stalls - Identify momentum loss early before it becomes critical
Resolve Blockers - Systematically address obstacles preventing progress
Find Quick Wins - Identify achievable tasks for momentum boost
Manage Energy - Maintain sustainable pace, prevent burnout
Ensure Continuation - Strategies for resuming after interruptions
Track to Completion - Monitor progress toward objectives, ensure finish

Key Principles:

Prevention Over Recovery: Detect stalls early, prevent rather than fix
Forward Progress: Any progress > no progress, even small wins matter
Systematic Approach: Use frameworks, not willpower alone
Completion Focus: Start with end in mind, drive toward done
Sustainable Pace: Marathon not sprint, manage energy strategically

Research Foundation: Based on productivity research, momentum psychology, and project management best practices

When to Use

Use momentum-keeper when:

Progress Has Stalled - No meaningful progress in 24-48 hours
Facing Major Blockers - Obstacles preventing forward movement
Losing Energy/Motivation - Feeling stuck, losing interest
After Interruptions - Resuming work after breaks, context loss
Complex Long Projects - Multi-week efforts need momentum management
Approaching Completion - Final push to finish (often hardest part)
Multiple Competing Priorities - Risk of abandoning projects
Team Coordination - Keeping group momentum aligned

Operations

Operation 1: Detect Stalls

Purpose: Identify momentum loss early through progress indicators and warning signs

When to Use This Operation:

Daily/weekly progress checks
When progress feels slow
Before it becomes critical stall
Preventive monitoring

Stall Indicators:

Objective Indicators (Measurable):

No completed tasks in 24-48 hours
Same task "in progress" for >4 hours without completion
Multiple blocked tasks accumulating
Burn rate << completion rate (falling behind)
No commits/updates in 48+ hours

Subjective Indicators (Feeling-based):

Avoiding work on project
Decreased interest/enthusiasm
Difficulty starting sessions
Frequent context switching to other work
Feeling stuck or overwhelmed

Process:

Check Objective Metrics
- Last task completed: when?
- Current task duration: how long?
- Blocked tasks: how many?
- Completion rate: on track?
Assess Subjective State
- Energy level: high/medium/low?
- Interest level: high/medium/low?
- Confidence: high/medium/low?
- Stuck feeling: yes/no?
Identify Cause Category
- Technical Blocker: Don't know how, need information
- Decision Blocker: Uncertain about approach, need decision
- Complexity Blocker: Task too large, need breakdown
- Energy Blocker: Low motivation, need energy boost
- Context Blocker: Lost context after interruption
Assess Severity
- Mild (<48h stall): Early detection, easy recovery
- Moderate (2-4 days): Needs intervention
- Severe (>4 days): Critical, risk of abandonment
Trigger Appropriate Operation
- Technical/Decision blocker → Operation 2 (Resolve Blockers)
- Energy low → Operation 4 (Manage Energy)
- After interruption → Operation 5 (Ensure Continuation)
- Need boost → Operation 3 (Find Quick Wins)

Validation Checklist:

Objective indicators checked (metrics)
Subjective state assessed (how you feel)
Stall cause identified (blocker type)
Severity assessed (mild/moderate/severe)
Appropriate operation selected
Intervention plan created

Outputs:

Stall assessment (yes/no, severity)
Identified cause (blocker type)
Recommended intervention
Action plan

Time Estimate: 10-15 minutes

Example:

Stall Detection: Skill Development Project
===========================================

Objective Indicators:
✅ Last completed task: 2 hours ago (healthy)
❌ Current task "in progress": 6 hours (too long - should be 1-2h)
❌ Blocked tasks: 2 accumulating
⚠️ Completion rate: 40% but burn rate: 60% (falling behind)

Subjective State:
⚠️ Energy: Medium (not low, but not high)
❌ Interest: Low (avoiding this task)
❌ Confidence: Low (unsure how to proceed)
✅ Stuck: Yes (don't know next step)

Stall Assessment: ⚠️ MODERATE STALL DETECTED

Cause: Technical + Decision Blocker
- Don't know how to implement feature (technical)
- Uncertain about architecture approach (decision)

Severity: Moderate (2 days since meaningful progress)

Recommended Intervention:
1. Operation 2: Resolve Blockers (address technical/decision blockers)
2. Operation 3: Find Quick Win (complete something achievable for momentum boost)

Action Plan:
1. Break current task into smaller pieces (1-2h each)
2. Seek help/research for technical blocker (skill-researcher)
3. Make architecture decision (planning-architect review)
4. Complete one small task today (quick win)

Operation 2: Resolve Blockers

Purpose: Systematically address obstacles preventing forward progress

When to Use This Operation:

Task blocked >4 hours
Clear blocker identified
Progress stopped by specific obstacle
Multiple blockers accumulating

Blocker Types and Resolutions:

1. Technical Blocker ("I don't know how to do this")

Resolution Process:

Research: Use skill-researcher to find patterns/solutions
Ask: Get help from documentation, team, or expert
Learn: Study similar implementations
Experiment: Try approaches in isolated test
Simplify: Reduce scope, do minimal viable version first

2. Decision Blocker ("I don't know which approach to take")

Resolution Process:

List options: Enumerate possible approaches
Criteria: Define decision criteria (speed, quality, maintainability)
Evaluate: Score options against criteria
Decide: Choose highest-scoring option
Move forward: Accept "good enough" decision, iterate if needed

3. Complexity Blocker ("This task is too big/complex")

Resolution Process:

Break down: Use task-development to decompose
Start smallest: Pick simplest piece, complete it
Build incrementally: Add complexity gradually
Validate frequently: Ensure each piece works before adding more

4. Dependency Blocker ("Waiting on external dependency")

Resolution Process:

Parallel work: Find independent tasks to work on
Mock/stub: Create temporary placeholder for dependency
Escalate: Follow up on dependency if delayed
Adjust plan: If critical, may need to replan

5. Context Blocker ("Lost context after interruption")

Resolution Process:

Review artifacts: Read plan, task list, recent work
Check progress: Use todo-management to see status
Quick summary: Scan quick references, not full deep dive
Resume gradually: Start with small task to rebuild context

Process:

Identify Blocker Specifically
- What exactly is blocking progress?
- What type of blocker?
- How long has it blocked?
Apply Resolution Strategy
- Use appropriate strategy for blocker type
- Take concrete action (not just think about it)
- Set time limit (e.g., 1 hour to resolve or escalate)
Validate Resolution
- Is blocker resolved? Can you proceed?
- If not, escalate or try different approach
- Update task status (unblock)
Resume Progress
- Start working on previously blocked task
- Mark task in_progress
- Complete it
Document Learning
- What was the blocker?
- How was it resolved?
- How to prevent similar blockers?

Validation Checklist:

Blocker identified specifically
Blocker type determined
Appropriate resolution strategy applied
Concrete action taken (not just planning)
Resolution validated (blocker actually resolved)
Progress resumed (task in progress again)
Learning documented (prevent recurrence)

Outputs:

Resolved blocker
Resumed progress
Documented resolution approach
Prevention strategies

Time Estimate: 30-90 minutes (varies by blocker complexity)

Example:

Blocker Resolution: API Integration Implementation
===================================================

Blocker: Don't know how to handle OAuth token refresh

Type: Technical Blocker
Duration: Blocked for 8 hours
Impact: Can't proceed with implementation

Resolution Strategy: Research + Experiment

Actions Taken:
1. Used skill-researcher Operation 2 (GitHub) - 20 min
   - Found 3 OAuth refresh implementations
   - Identified pattern: refresh before expiry

2. Read OAuth RFC documentation - 15 min
   - Understood refresh token flow
   - Clear on required parameters

3. Implemented minimal test - 25 min
   - Created isolated refresh function
   - Tested with dummy tokens
   - Validated approach works

Resolution Time: 60 minutes

Result: ✅ BLOCKER RESOLVED
- Now understand OAuth refresh flow
- Have working implementation pattern
- Can proceed with integration

Task Status: Unblocked → In Progress → Completed in 2h

Learning: When facing technical blocker, research first (don't experiment blindly)

Prevention: Research OAuth patterns at start of auth work (not when stuck)

Operation 3: Find Quick Wins

Purpose: Identify and complete achievable tasks for momentum boost and psychological win

When to Use This Operation:

Energy/motivation low
After completing difficult task (need breather)
Stalled on complex work (need confidence boost)
Multiple failures/setbacks (need success)
Beginning of session (warm up)

What is a Quick Win?

Characteristics:

Completable in 15-60 minutes
Clear, well-defined outcome
Low complexity
High confidence can complete
Tangible result (something done)

Examples:

Add Quick Reference section
Write README file
Run validation script
Fix simple bug
Update documentation
Add one example
Refactor small function

NOT Quick Wins:

Complex features (too big)
Ambiguous tasks (unclear outcome)
Blocked tasks (has obstacles)
Exploratory work (no clear completion)

Process:

Scan Todo List
- Look for simple, clear tasks
- Identify tasks you're confident about
- Find tasks requiring 15-60 minutes
- Prefer tasks with tangible output
Select Quick Win
- Must be achievable now
- Must have clear completion
- Prefer visible progress (user-facing)
- Should feel satisfying when done
Complete It
- Focus 100% on this task
- Complete fully (not partially)
- Mark as completed
- Verify done (validation criteria)
Celebrate
- Acknowledge completion
- Note the win (psychological boost)
- Feel the momentum
Build on Success
- Use energy from win for next task
- Tackle slightly harder task next
- Ride the momentum wave

Validation Checklist:

Outputs:

Completed task (quick win)
Momentum boost
Increased confidence
Energy for next tasks

Time Estimate: 15-60 minutes (the quick win itself)

Example:

Quick Win Session: Low Energy Day
==================================

State: Low energy, avoiding complex task (API integration)

Quick Win Search:
- Write README for skill? → 30 min ✅ Achievable
- Add validation to operation? → 45 min ✅ Achievable
- Implement OAuth refresh? → 4h ❌ Too complex (not quick win)
- Run structure validation? → 10 min ✅ Very achievable

Selected Quick Win: Write README for skill (30 min)

Execution:
- Focused on README only
- Completed in 28 minutes
- Result: README.md fully written and validated

Impact:
✅ Tangible progress (README done)
✅ Momentum boost (completed something)
✅ Confidence increase (I can finish things)
✅ Energy higher (ready for next task)

Next Task: Add validation to operations (riding momentum)
- Started immediately after README
- Completed in 42 minutes
- Two wins in one session!

Outcome: Low energy day → 2 completions (README + validation)
Without quick win: Might have stalled all day on complex API task

Operation 4: Manage Energy

Purpose: Maintain sustainable pace and prevent burnout through strategic energy management

When to Use This Operation:

Feeling fatigued or low energy
Long sessions (>4 hours)
After intense work periods
Planning work sessions
Sustainable pace needed

Energy Management Strategies:

1. Energy Matching (Match task to energy level)

High Energy (Morning, start of session):

Complex tasks (architecture, design)
Creative work (planning, problem-solving)
High-focus work (critical implementations)
Decision-making

Medium Energy (Mid-session):

Implementation tasks (following plan)
Testing and validation
Documentation writing
Standard operations

Low Energy (End of session, tired):

Quick wins (simple completions)
Mechanical tasks (formatting, cleanup)
Reading/research (passive)
TODO updates, progress tracking

2. Strategic Breaks

Pomodoro-Style (25 min work, 5 min break):

Good for sustained focus
Regular energy renewal
Prevents fatigue buildup

Natural Breaks (after completing tasks):

Take break after completing task
Celebrate completion
Return refreshed for next task

Longer Breaks (every 2-3 hours):

15-30 minute breaks
Physical movement
Full context switch
Return energized

3. Session Planning

Ideal Session Structure:

Hour 1: High-energy complex work (architecture, critical decisions)
Hour 2: Medium-energy implementation (following plan)
Hour 3: Break (15-30 min)
Hour 4: Medium-energy continued implementation
Hour 5: Low-energy quick wins, documentation
Hour 6: Wrap-up, todo updates, planning next session

Avoid: 6+ hours continuous without significant breaks

4. Momentum Riding

Strategy: Use completion energy for next task immediately

Application:

Complete Task 1 → Immediately start Task 2 (ride momentum)
Don't take break after completion if energy high
Chain completions for maximum momentum

Caution: Monitor for fatigue, don't override exhaustion signals

5. Sustainable Pace

Marathon Mindset:

Consistent progress > sporadic heroics
3-4 hours quality work/day > 10 hours mediocre work
Regular schedule > irregular bursts
Completion focus > perfection focus

Process:

Assess Current Energy
- High/medium/low?
- Trending up or down?
- Sustainable or approaching burnout?
Match Work to Energy
- High energy → complex work
- Medium energy → implementation
- Low energy → quick wins, mechanical
Plan Strategic Breaks
- Schedule breaks before fatigue
- Take breaks when energy drops
- Don't power through exhaustion
Monitor Sustainability
- Can you maintain this pace?
- Are you burning out?
- Is progress consistent?
Adjust as Needed
- Reduce pace if unsustainable
- Take longer break if fatigued
- Resume when energy returns

Validation Checklist:

Energy level assessed honestly
Work matched to energy (not fighting fatigue)
Breaks taken strategically
Pace sustainable (can maintain for duration)
No burnout signals (exhaustion, avoidance, errors)
Consistent progress maintained

Outputs:

Energy assessment
Work-energy matching plan
Break schedule
Sustainable pace
Maintained momentum

Time Estimate: Ongoing (throughout session)

Operation 5: Ensure Continuation

Purpose: Resume work effectively after interruptions, breaks, or context loss

When to Use This Operation:

Returning after overnight/weekend break
Resuming after interruption (meeting, task switch)
Starting new session on existing project
Lost context and need to rebuild

Continuation Strategies:

1. Context Rebuilding (15-30 min)

Quick Context Rebuild:

1. Check todo-management (what's in progress? what's next?)
2. Read Quick Reference of relevant skill (not full re-read)
3. Review last completed task (what was I doing?)
4. Check plan/task breakdown (where am I in overall flow?)
5. Start with small task (rebuild flow gradually)

Avoid: Reading everything from scratch (time-consuming, not necessary)

2. Momentum Restart

Strategy: Start with quick win to rebuild momentum

Process:

Don't start with hardest task
Pick 30-minute achievable task
Complete it (warm up, rebuild context)
Use completion energy for harder tasks

3. Session Preparation (Before interruption)

Leave Breadcrumbs:

## Session End Notes (For Resume)

Completed Today:
- Finished X
- Made progress on Y

Next Session Start Here:
- Continue with task #7: [specific next action]
- Context: [brief reminder of what you're doing]
- Quick start: [first concrete step to take]

Blockers to Note:
- [Any blockers to remember]

Benefit: Reduces resume time from 30 min to 5-10 min

4. Fresh Start When Needed

When to Fresh Start:

Context completely lost (>1 week interruption)
Major context bloat (>70% context window)
Switching from planning to execution
Clean slate needed for focus

How:

Save all artifacts (plans, code, todos)
End current session
Start fresh session
Load only: CLAUDE.md + plan docs + current task
Much cleaner context (better performance)

Process:

Assess Interruption
- How long was break?
- How much context lost?
- What was I working on?
Quick Context Rebuild
- Check todo status (in progress? next up?)
- Read Quick References (not full docs)
- Review session end notes (if left)
- Check plan for current phase
Select Restart Task
- Easy warm-up task (15-30 min)
- Or continue in-progress task if context clear
- Not hardest task on list
Execute Restart
- Complete restart task
- Rebuild momentum
- Proceed to normal work
Maintain Going Forward
- Update todos regularly
- Leave session end notes
- Keep artifacts organized

Validation Checklist:

Interruption duration assessed
Context rebuilt (todos, quick refs, plans)
Restart task selected (achievable warm-up)
Momentum rebuilding (not jumping to hardest task)
Session end notes left (for future resume)
Artifacts organized (plans, todos, code)

Outputs:

Rebuilt context
Resumed momentum
Clear next steps
Progress continuing

Time Estimate: 15-45 minutes (context rebuild + warm-up)

Operation 6: Track to Completion

Purpose: Monitor progress toward objectives, maintain completion focus, and ensure finish

When to Use This Operation:

Beginning of project (set completion criteria)
Weekly progress reviews
When nearing completion (final push)
When at risk of abandonment

Completion Tracking Framework:

1. Define "Done"

At Project Start:

Definition of Done:
- [ ] All planned features implemented
- [ ] All tests passing
- [ ] Documentation complete
- [ ] Quality review passed (score ≥4.0)
- [ ] Deployed/published

Characteristics of Good "Done":

Specific and measurable
Achievable and realistic
Clearly defined (not ambiguous)
Verifiable (can check if met)

2. Track Completion Metrics

Key Metrics:

Completion Rate = Completed Tasks / Total Tasks × 100%

Example: 25 completed / 40 total = 62.5% complete

Remaining Effort = Sum of remaining task estimates

Example: 15 tasks × avg 2h = 30 hours remaining

Estimated Completion Date = Today + (Remaining Effort / Daily Capacity)

Example: 30h remaining ÷ 4h/day = 7.5 days → Complete ~Nov 15

3. The "90% Done" Trap

Problem: Last 10% often takes 50% of time

Warning Signs:

"Almost done" for multiple days
Completion rate stalled at 85-95%
Many small tasks remaining
Polish and perfection seeking

Solution:

Define minimum viable complete (not perfect)
Time-box final polish (e.g., 2 hours max)
Ship and iterate (done > perfect)
Focus on completion, not perfection

4. Final Push Strategies

When: 90%+ complete, final tasks remaining

Strategies:

Batch Final Tasks: Complete all remaining in one focused session
Deadline Setting: "Will finish by Friday" (commitment)
Eliminate Scope Creep: No new features, finish planned work
Accept Good Enough: 90% perfect is shippable, 100% is diminishing returns

Process:

Set Completion Criteria
- Define what "done" means specifically
- Create completion checklist
- Make criteria measurable
Track Progress
- Use todo-management for completion rate
- Calculate remaining effort
- Estimate completion date
- Monitor velocity
Maintain Focus
- Keep end goal visible
- Review completion criteria regularly
- Resist scope creep
- Celebrate milestones (50%, 75%, 90%)
Final Push
- When 90%+ complete, push to finish
- Batch remaining tasks
- Accept good enough
- Ship it
Validate Completion
- Check all "done" criteria met
- Run final validation
- Confirm ready to ship

Validation Checklist:

"Done" criteria defined at start
Completion rate tracked regularly
Progress visible (todos, metrics)
Remaining effort estimated
Final push executed (when 90%+)
Completion criteria met
Project actually finished (not abandoned at 95%)

Outputs:

Completion tracking metrics
Estimated completion date
Validated completion
Finished project

Time Estimate: Ongoing (throughout project) + final push (varies)

Example:

Completion Tracking: review-multi Skill
========================================

Definition of Done:
- [ ] All 13 files created
- [ ] SKILL.md complete with 5 operations
- [ ] All reference guides written
- [ ] All scripts functional
- [ ] Structure validation passes (score ≥4)
- [ ] README complete

Progress Tracking:

Week 1:
- Tasks completed: 15/31 (48%)
- Remaining effort: 9 hours estimated
- On track: Yes (projected complete in 3 days)

Week 2:
- Tasks completed: 28/31 (90%)
- Remaining effort: 2 hours
- Final push: 3 tasks remain

Final Push (Day 10):
- Remaining: Validation + testing + summary
- Time-boxed: 2 hours maximum
- Result: All completed in 1.5 hours

Final Validation:
✅ All 13 files created
✅ SKILL.md complete (1,156 lines)
✅ References complete (7 files, 3,690 lines)
✅ Scripts functional (4 files tested)
✅ Structure score: 5/5 (validated)
✅ README complete (421 lines)

Status: ✅ COMPLETE - All completion criteria met
Time: 13 hours actual (14-18h estimated)
Quality: Production ready

SHIPPED! 🎉

Best Practices

1. Detect Stalls Early

Practice: Check progress daily, intervene before critical

Rationale: Early detection = easier recovery (mild stall 1h fix, severe stall 1 day+)

Application: Daily check: "Made progress? Completed task? Blocked?"

2. Resolve Blockers Immediately

Practice: Don't let blockers accumulate, address within 4 hours

Rationale: Fresh blockers easier to resolve than old ones

Application: Task blocked >2 hours → Stop and resolve blocker

3. Maintain Quick Win Reserve

Practice: Keep list of achievable quick win tasks

Rationale: Always have option for momentum boost when energy low

Application: Identify 3-5 quick wins at planning phase, save for low-energy moments

4. Match Work to Energy

Practice: Do complex work when energy high, simple work when low

Rationale: Energy is finite resource, use strategically

Application: Morning → complex work, afternoon → implementation, evening → documentation

5. Leave Breadcrumbs

Practice: End each session with notes for next resume

Rationale: Reduces resume time from 30 min to 5-10 min

Application: Write "Next session start here" notes at end of every session

6. Focus on Completion

Practice: Finish tasks fully before starting new ones

Rationale: Partial completions drain energy, full completions energize

Application: Resist temptation to start new task before completing current

7. Celebrate Wins

Practice: Acknowledge completions, even small ones

Rationale: Psychological boost maintains motivation

Application: Mark tasks ✅, note achievement, feel the win

8. Accept Good Enough

Practice: 90% perfect is shippable, don't pursue 100%

Rationale: Last 10% often takes 50% of time, diminishing returns

Application: When 90%+ done, time-box final polish, then ship

Common Mistakes

Mistake 1: Ignoring Stall Signals

Symptom: Realize week later that no progress made

Cause: Not monitoring progress, letting drift happen

Fix: Daily progress check, intervene when stall detected

Prevention: Operation 1 (Detect Stalls) daily

Mistake 2: Fighting Blockers Alone Too Long

Symptom: Stuck on blocker for days, frustration mounting

Cause: Pride, not wanting to ask for help

Fix: 4-hour rule - if blocked >4 hours, seek help/research/escalate

Prevention: Operation 2 (Resolve Blockers) with time limit

Mistake 3: No Quick Wins Reserve

Symptom: Low energy, no achievable tasks, stall

Cause: No backup plan for low-energy moments

Fix: Identify 3-5 quick wins now for future low-energy days

Prevention: Operation 3 (Find Quick Wins) during planning

Mistake 4: Powering Through Exhaustion

Symptom: Long hours, declining quality, mistakes

Cause: Believing more hours = more progress

Fix: Stop, take break, resume when energized (quality > quantity)

Prevention: Operation 4 (Manage Energy), respect energy limits

Mistake 5: Not Leaving Resume Notes

Symptom: 30+ minutes lost every session rebuilding context

Cause: Not documenting session end state

Fix: Spend 3 minutes leaving "start here" notes

Prevention: Session end routine (Operation 5)

Mistake 6: Perfectionism Preventing Completion

Symptom: Project 95% done for weeks, never ships

Cause: Pursuing perfection, afraid to ship

Fix: Define "good enough", time-box polish, ship it

Prevention: Operation 6 (Track to Completion), accept 90% perfect

Quick Reference

The 6 Operations

Operation	Purpose	When to Use	Time	Key Action
Detect Stalls	Identify momentum loss early	Daily checks, preventive	10-15m	Check progress indicators
Resolve Blockers	Address obstacles	Task blocked >4h	30-90m	Apply resolution strategy
Find Quick Wins	Momentum boost tasks	Low energy, need win	15-60m	Complete achievable task
Manage Energy	Sustainable pace	Long sessions, fatigue	Ongoing	Match work to energy
Ensure Continuation	Resume after breaks	After interruptions	15-45m	Rebuild context, warm up
Track to Completion	Drive to finish	Throughout project	Ongoing	Monitor metrics, final push

Stall Indicators

Indicator	Threshold	Severity
No completed tasks	>24-48h	⚠️ Moderate
Task "in progress"	>4h without completion	⚠️ Moderate
Blocked tasks accumulating	>2 blocked	⚠️ Moderate
Burn rate vs completion	Falling >15% behind	❌ Severe
Feeling stuck	Persistent avoidance	⚠️ Moderate

Energy Levels & Work Matching

Energy	Work Type	Examples
High	Complex, creative, decisions	Architecture, design, planning
Medium	Implementation, standard tasks	Coding, testing, documentation
Low	Simple, mechanical, passive	Quick wins, cleanup, reading

Blocker Resolution Times

Blocker Type	Typical Resolution	Strategy
Technical	30-90 min	Research, experiment, ask
Decision	15-45 min	List options, criteria, decide
Complexity	30-60 min	Break down, start small
Dependency	Variable	Parallel work, mock, escalate
Context	15-30 min	Review artifacts, warm up

Completion Metrics

Metric	Formula	Good Target
Completion Rate	Completed / Total × 100%	Trending up
Remaining Effort	Sum of remaining estimates	Trending down
Velocity	Tasks completed / Time	Stable or increasing
Burn Rate	Time spent / Total estimated × 100%	≈ Completion rate (±10%)

Session Structure (Ideal)

Hour 1: High-energy complex work
Hour 2: Medium-energy implementation
Hour 3: Break (15-30 min)
Hour 4: Medium-energy continued work
Hour 5: Low-energy quick wins
Hour 6: Wrap-up, session notes

Sustainable: 3-6 hours focused work/day Avoid: >8 hours continuous (quality degrades)

Quick Decision Aids

Should I take a break?

Energy dropping? → Yes
Completed major task? → Yes (celebrate)
2+ hours continuous? → Yes (prevention)
Errors increasing? → Yes (fatigue signal)

Which task should I do now?

High energy? → Most complex available task
Medium energy? → Standard implementation task
Low energy? → Quick win or documentation
Blocked? → Different task or resolve blocker

Should I ship or continue polishing?

90% complete? → Ship (accept good enough)
All "done" criteria met? → Ship
Polishing >4 hours? → Ship (diminishing returns)
Otherwise → Continue to done criteria

For More Information

Stall detection: references/stall-detection-guide.md
Energy management: references/energy-management-guide.md
Completion strategies: references/completion-strategies-guide.md

momentum-keeper ensures continuous forward progress from start to completion through systematic stall prevention, blocker resolution, and strategic energy management.