| theme | default |
|---|---|
| colorSchema | dark |
| title | dev-loops: Process Observability |
| info | Why coordination delay — not code generation — is the slow part, and how observable state cuts it |
| class | text-left |
| transition | slide-left |
| mdc | true |
| css | ./style.css |
dev-loops
Generating a change is the fast part now. The slow part is everything between actions — the wait for someone to pick the work up, rebuild the context, and decide what happens next. That waiting is invisible, unmeasured, and where your real lead time goes.
The delay pattern
- A five-minute question doesn't cost five minutes. It costs the switch out, the rebuild, and the recovery on both sides.
- Every interruption walks the same five steps — notice, switch, rebuild, act, recover — and each one has its own latency.
- Across a queue of work, repeated interrupts don't add up. They multiply.
What one interrupt actually triggers
flowchart LR
A[Need response] --> B[Notice]
B --> C[Switch]
C --> D[Rebuild state]
D --> E[Act]
E --> F[Recover]
Handoff cost
What the receiver pays for, every time
- Reconstruct what changed since they last looked.
- Gather enough context to act with confidence.
- Confirm who owns it now and what's blocking it.
- Absorb the round-trip if any of that is unclear.
Why it's worse with mixed actors
- Ambiguous ownership pauses a human until they ask.
- Missing context halts an AI agent — it guesses or stops.
- Every human↔AI swap is one more place the state can drop.
- More hands speed things up only when the state crosses intact.
The blind spot
- Commits record the output — they say nothing about the hours the work sat idle before someone touched it.
- Review threads bury the cost of re-reading and re-explaining inside ordinary back-and-forth.
- CI timestamps end at green. They miss the gap before a human notices and acts on the result.
- So the single biggest drag on lead time — coordination waiting — is invisible to every tool you already trust.
Observable state
The fix isn't more meetings or more status pings. It's making the state of the work explicit, so picking it up becomes continuation instead of investigation.
Keep these four current and the next actor — human or agent — starts immediately, with nothing to reconstruct.
State that turns pickup into continuation
- Who owns it now — no guessing whose move it is.
- What's blocking it — and what would unblock it.
- The latest decision — so nobody re-litigates settled ground.
- The safe next step — the one move that's known to be safe.
The measurement loop
- Capture the state, and the waits between actors stop being anecdotes — they become numbers you can point at.
- Find the transition that stalls most, change the process there, and check whether the wait actually dropped.
- Then confirm the change didn't trade speed for quality. Faster only counts if it's still correct.
A loop you can actually run
flowchart LR
A[State captured] --> B[Waits measured]
B --> C[Process changed]
C --> D[Outcomes verified]
D --> A
From idea to instrument
Owner & next step are a board
- Work moves through visible columns: waiting, in progress, done.
- The column is the current owner and the safe next step.
- A deterministic resolver picks the next action — no guessing whose move it is.
Decisions leave a trail
- Each review gate records its verdict in the open, with the findings behind it.
- The latest decision is written down, not held in someone's head.
- Pick the work up tomorrow and the reasoning is still there.
Automate only where it's safe
- The wait at CI is handled by waiting on the real result, on any provider.
- After a merge, finished workspaces are reclaimed and long-done items archived.
- Automation runs only where the state says continuing is safe.
Why it pays off
Quality
- Fewer wrong resumptions from stale context.
- Cleaner fix loops.
- Regressions are easier to trace back.
Waiting time
- Faster first action after a handoff.
- Context is already present at pickup.
- Approvals stop sitting unnoticed.
Throughput
- Higher flow efficiency.
- Fewer items stalled in the dark.
- Less coordination drag per merge.
The takeaway
- Make the state explicit, and pickup becomes continuation instead of an investigation.
- Measure the waits, and the biggest stall stops hiding behind your commit history.
- Automate only where state proves it's safe, and you remove the stall without removing the judgment.
Stop optimizing how fast you write code. Start measuring how long it waits.