positive examples: zero-steering COMMITTED threads

analysis of 20 best-performing threads: high-outcome (COMMITTED), zero steering interventions.

threads analyzed

patterns that eliminated steering

1. CONCRETE OPENING: file paths + diagnostic data upfront

successful threads front-load context. the agent doesn’t have to guess.

examples:

• @pkg/db/cleanup_service/service.go @pkg/db/cleanup_service/service_test.go (T-a28acd4a)
• full CI error output with stack traces (T-019b83a0)
• @app/dashboard/src/dash/routes/query/components/CanvasChartWrapper.tsx (T-019b21c8)
• complete panic trace with file/line numbers (T-019b9dcc)

why it works: agent knows exactly what to read. no exploration phase = no drift.

2. THREAD CONTINUITY: explicit handoff with read_thread

marathon sessions that span multiple threads use structured context passing.

pattern:

Continuing work from thread T-xxx. When you lack specific information you can use read_thread to get it.

examples: T-a28acd4a, T-019b83a0, T-019b21c8, T-019b6514, T-019b92ff, T-019b0dd8

why it works: agent doesn’t re-discover what previous session established. accumulated understanding persists.

3. SOCRATIC QUESTION CHAINS: interrogative prompts over directives

concise_commander’s threads especially use questions that guide without commanding:

• “Does this log line indicate and explain the scheduling deadlock?” (T-019b1db9)
• “Why is the shared query form stuff not used in both places?” (T-019b3df2)
• “Are you sure that particular error causes a split?” (T-019b1db9)
• “How can that error happen?” (T-019b1db9)

why it works: forces agent to reason through problem, not just execute. agent owns the solution.

4. PROCEDURAL CLARITY: numbered steps or explicit sequencing

examples:

1. explore the codebase to understand how we do each thing
2. search the web to find the latest information
3. create a new "lgo-z2e" host
4. help me create an ISO

(T-019b5fa3)

I want you to fetch all my comments, create a TODO list out of them, and work on each, one by one, in the order that makes the most sense

(T-501196c5)

why it works: agent can self-verify completion at each step. natural checkpoints.

5. VERIFICATION BUILT IN: tests specified upfront

examples:

• “always run bun run test to make sure you’re not breaking things” (T-b090aafd)
• “Let’s verify this bug and fix it. Make sure you add an e2e test for it” (T-019b2ea9)
• “run the tests, and debug what’s wrong methodically” (T-ba19f50b)

why it works: agent knows the success criterion. can self-correct before user needs to steer.

6. DOMAIN EXPERTISE ASSUMED: technical vocabulary without explanation

users don’t explain what msgpack is, what a worktree is, or what partial sums mean. they use domain terms directly:

• “JobManifest ResultManifest to msgpack” (T-019b6514)
• “make a new worktree based on main_app’s main” (T-019b9327)
• “partial sum mismatch” (T-019b83a0)

why it works: signals agent can operate at expert level. no dumbing down = no loss of precision.

7. EXTERNAL RESOURCES REFERENCED: papers, docs, prior work

examples:

• “Ask the Oracle to read the paper @p1162-ferragina.pdf” (T-ba19f50b)
• “there’s the reference C++ implementation at @thirdparty/PGM-index” (T-ba19f50b)
• “search the web to find the latest information on running linux on the legion go 2” (T-019b5fa3)

why it works: agent has authoritative source to check against. reduces hallucination risk.

8. TASK DELEGATION: spawn + coordinate pattern

examples:

• “spawn and coordinate agents to do it” (T-019b931d)
• “spawn and coordinate sub-agents to make sure we finish this task” (T-019b5fa3)
• “create a folder for plans and notes you want to persist across agent sessions” (T-019b5fa3)

why it works: complex work parallelized. each sub-agent has focused scope.

anti-patterns ABSENT from these threads

1. vague goals - no “make it better” or “fix this somehow”
2. context omission - no expecting agent to know what file, which error, or what prior work
3. micro-management - no step-by-step instructions for obvious sub-tasks
4. ambiguous scope - no confusion about what’s in/out of scope
5. missing verification - no threads that end without a way to confirm success

user archetypes in zero-steering threads

concise_commander (11/20 threads)

• question-heavy style forces agent reasoning
• marathon sessions with thread continuity
• technical precision without hand-holding
• debugging + optimization focus

verbose_explorer (6/20 threads)

• procedural lists with numbered steps
• delegation-heavy (spawn/coordinate)
• infrastructure + setup focus
• file references upfront

steady_navigator (2/20 threads)

• visual/iterative approach
• CI/release tooling focus
• high approval rate (4 approvals)
• exhaustive error logs provided

async_dev (1/20 threads)

• panic/error traces as primary context
• minimal guidance after diagnostic
• low-intervention debugging

synthesis: the zero-steering formula

successful COMMITTED threads share:

1. concrete context (files, errors, logs) in opening message
2. clear success criteria (tests, verification steps)
3. domain-native vocabulary (no explanation tax)
4. question-driven guidance (socratic over imperative)
5. structured handoffs for multi-thread work

when these conditions hold, the agent stays on track without course correction. the user’s role shifts from steering to approving.