Harness Notes
Lecture 07

Why agents overreach and under-finish

Agents do extra work because nearby work feels cheap. A harness has to make scope expensive until the current task is verified.

Notes from Learn Harness Engineering · Lecture 07

scope_surface.mdWIP = 1
✓User registrationactive
Email verificationparked
Error middleware cleanupparked
Test directory refactorparked
Audit log supportblocked

The failure pattern is too much active scope.

A broad prompt like “add authentication” invites the agent to touch models, routes, frontend, mail, hashing, error handling, and tests at once. The result is lots of code and little verified behavior.

One active task to completion

Start✓
  • Full reasoning depth stays on one behavior.
  • End-to-end verification is reachable.
  • The next session inherits clean evidence.
vs.

Many half-finished tasks

half-done
half-done
half-done
half-done
  • Context fragments across unrelated changes.
  • Coupling grows before anything is proven.
  • Pickup cost explodes next session.

WIP=1 is the workflow that finishes.

01

Pick exactly one task

Move one work unit from queue to active. Everything else stays parked.

02

Execute only that task

No “while I’m here” refactors, adjacent features, or speculative cleanup.

03

Run completion evidence

Done means behavior passes an executable check, not that code was written.

04

Commit and unlock next

Only passing work releases the next item in the queue.

QUEUE → ONE ACTIVE ITEM → E2E VERIFY → CHECKPOINT → NEXT

Attention is finite.

If the context capacity is C and the agent activates k tasks, each task gets only C/k reasoning budget. When that falls below the threshold needed to finish, every task becomes partially implemented.

C / k

Budget split from the lecture diagram

WIP=5 divides the same reasoning budget across five streams.

Many active tasks · shallow depth per task

WIP=1 · full depth on the active behavior

Core concepts

The lecture’s vocabulary gives you a way to detect scope failure before the codebase absorbs it.

OverreachThe agent activates more work units than it can complete in one verified session.
Under-finishActivated tasks outnumber tasks that pass end-to-end verification.
WIP limitA hard cap on in-flight work. For agents, default to WIP=1.
Completion evidenceThe executable proof needed to move a task from active to passing.
Scope surfaceA repo-visible task graph with states: not_started, active, blocked, passing.
Completion pressureHarness rules that force finishing the current task before starting another.

Overreach and under-finish reinforce each other.

OverreachToo many related ideas become active.
Diluted attentionEach task receives less reasoning budget.
Under-finishCode exists, but behavior does not pass.
Next-session dragHalf-finished complexity causes more overreach.

How to draw the boundary

Enforce one active feature.

State the rule in AGENTS.md or CLAUDE.md: one feature at a time, next feature only after verification.

Define completion evidence.

Every task needs the command, assertion, or check that proves the behavior works.

Externalize the scope surface.

Keep task state in Markdown or JSON so future sessions know what is active, blocked, and passing.

Track VCR.

Verified Completion Rate = verified tasks / activated tasks. Block new activation when VCR is below 1.0.

## Work Rules
- Work on one feature at a time
- Start the next feature only after E2E verification passes
- Do not also refactor feature B while implementing feature A

F01: User Registration
Verification: curl POST /api/register returns 201
State: active

Real-world comparison

5
features activated
unconstrained session 1
20%
E2E pass rate
unconstrained
100%
E2E pass rate
WIP=1 session 1
87.5%
completion
WIP=1 by session 4
TAKEAWAY

Do less, but finish: one active task, executable evidence, then the next task.