momentum-field Skill

momentum-field Skill

Trit: 0 (ERGODIC - transports excellence between validator and generator) Color: Yellow (#F5A623) Role: COORDINATOR in the excellence triad

Canonical Triad

excellence-gradient (-1) ⊗ momentum-field (0) ⊗ refuse-mediocrity (+1) = 0 ✓
     VALIDATOR              COORDINATOR              GENERATOR
   (measures delta)      (transports flow)        (raises floor)

Core Definition

Momentum = derivative of progress with respect to time

p = progress (shipped value)
v = dp/​dt    (velocity - shipping rate)
a = dv/​dt    (acceleration - velocity change)
j = da/​dt    (jerk - smoothness of acceleration)

Flow State Detection

Based on Csikszentmihalyi's flow theory, detect via interaction patterns:

@dataclass
class FlowState:
    challenge_skill_ratio: float  # Optimal: 0.9-1.1
    clear_goals: bool             # Unambiguous next action
    immediate_feedback: bool      # Know if progressing
    deep_concentration: float     # Interruption-free time (hours)
    sense_of_control: bool        # Agency over outcome
    time_distortion: bool         # Hours feel like minutes
    
def detect_flow(interactions: List[Interaction]) -> FlowState:
    """Flow = high challenge + high skill + low friction."""
    burst_lengths = [len(burst) for burst in segment_bursts(interactions)]
    avg_burst = mean(burst_lengths)
    
    return FlowState(
        challenge_skill_ratio=estimate_challenge_skill(interactions),
        clear_goals=has_explicit_objective(interactions[-1]),
        immediate_feedback=feedback_latency_ms(interactions) < 100,
        deep_concentration=max_uninterrupted_hours(interactions),
        sense_of_control=error_recovery_rate(interactions) > 0.9,
        time_distortion=avg_burst > 10  # Long coherent bursts
    )

Momentum Metrics (Kanban-Derived)

Primary Metrics

WIP Limits (Little's Law)

Lead Time = WIP / Throughput

Therefore: WIP_limit = Target_Lead_Time × Current_Throughput

Recommended WIP limits per focus area:

• Individual: 1-2 items
• Pair: 2-3 items
• Team: N+1 where N = team size

Momentum Killers

The Deadly Seven

Detection Patterns

def detect_momentum_killers(interactions: List[Interaction]) -> List[Killer]:
    killers = []
    
    # Context switching: topic changes per hour
    topic_changes = count_topic_changes(interactions, window="1h")
    if topic_changes > 3:
        killers.append(Killer.CONTEXT_SWITCH)
    
    # Unclear goals: high question/​action ratio
    q_a_ratio = questions(interactions) / actions(interactions)
    if q_a_ratio > 0.5:
        killers.append(Killer.UNCLEAR_GOALS)
    
    # Blocked: long gaps with no progress
    gaps = find_gaps(interactions, threshold="30m")
    if any(g.reason == "waiting" for g in gaps):
        killers.append(Killer.BLOCKED)
    
    return killers

Momentum Recovery Protocols

Protocol 1: Restart Ritual (Cold Start)

1. State ONE clear objective (15 words max)
2. List 3 concrete next actions
3. Set timer for 25 minutes (Pomodoro)
4. Disable all notifications
5. Start with smallest action

Protocol 2: Unblock Sprint (Blocked State)

1. Identify the blocker explicitly
2. Timebound: "If not unblocked in 30 min, escalate"
3. Parallel path: Work on something else OR
4. Reduce scope: Ship smaller version without blocked dependency
5. Document: Why blocked, when unblocked, lesson learned

Protocol 3: Velocity Injection (Stale State)

1. Ship something tiny (README fix, comment, config)
2. Commit immediately (momentum from motion)
3. Review recent wins (3 things shipped this week)
4. Pair with high-momentum collaborator
5. Change environment (different location/​music/​time)

Protocol 4: Flow State Entry

Prerequisites:
- [ ] Clear single objective
- [ ] All resources available (no waiting)
- [ ] Notifications disabled
- [ ] 90+ minute block scheduled
- [ ] Challenge matches skill level

Entry Sequence:
1. Read objective aloud
2. First action already known
3. Begin immediately (no planning in the moment)

Integration with Triad

With excellence-gradient (-1)

def gradient_to_momentum(gradient: ExcellenceGradient) -> MomentumVector:
    """Gradient provides direction, momentum provides magnitude."""
    return MomentumVector(
        direction=gradient.steepest_ascent(),
        magnitude=current_velocity(),
        acceleration=gradient.curvature()  # How fast can we turn
    )

With refuse-mediocrity (+1)

def momentum_floor(current: Momentum, floor: QualityFloor) -> Momentum:
    """Refuse mediocrity sets minimum acceptable velocity."""
    if current.velocity < floor.minimum_shipping_rate:
        trigger_recovery_protocol()
    
    return current.with_constraint(min_velocity=floor.minimum_shipping_rate)

DuckDB Tracking

CREATE TABLE momentum_samples (
    timestamp TIMESTAMPTZ,
    session_id UUID,
    velocity DOUBLE,        -- items/​hour
    acceleration DOUBLE,    -- velocity change/​hour
    jerk DOUBLE,           -- acceleration smoothness
    wip_count INT,
    flow_state BOOLEAN,
    active_killers TEXT[]  -- array of killer names
);

-- Compute rolling momentum
SELECT 
    session_id,
    AVG(velocity) OVER (ORDER BY timestamp ROWS 10 PRECEDING) as avg_velocity,
    STDDEV(velocity) OVER (ORDER BY timestamp ROWS 10 PRECEDING) as velocity_stability,
    COUNT(*) FILTER (WHERE flow_state) as flow_minutes
FROM momentum_samples
GROUP BY session_id;

Commands

# Track momentum
just momentum-sample          # Record current state
just momentum-status          # Show velocity/​acceleration
just momentum-killers         # Detect active killers

# Recovery
just momentum-restart         # Cold start protocol
just momentum-unblock ISSUE   # Unblock sprint
just momentum-inject          # Ship something tiny

# Analysis  
just momentum-report PERIOD   # Weekly/​daily report
just momentum-flow-ratio      # Flow time percentage

Csikszentmihalyi Flow Conditions

GF(3) Triads

excellence-gradient (-1) ⊗ momentum-field (0) ⊗ refuse-mediocrity (+1) = 0 ✓
cognitive-surrogate (-1) ⊗ momentum-field (0) ⊗ entropy-sequencer (+1) = 0 ✓
topos-catcolab (-1) ⊗ momentum-field (0) ⊗ open-games (+1) = 0 ✓

References

• Csikszentmihalyi, M. "Flow: The Psychology of Optimal Experience" (1990)
• Anderson, D. "Kanban: Successful Evolutionary Change" (2010)
• Newport, C. "Deep Work" (2016)
• Mark, G. et al. "The Cost of Interrupted Work" (2008) - 23 min recovery

---

Skill Name: momentum-field Type: Shipping Velocity & Flow Optimization Trit: 0 (ERGODIC - transports between validator and generator) GF(3): Conserved via triadic composition with excellence-gradient and refuse-mediocrity