One full working day, two Claude seats, one small well-defined module task — not completed. A time-accounting of where the day actually went

Fifth filing on the same two-seat deployment (claude.ai planner + Claude Code executor, local repo, documented workflow, owner-armed mechanical gates). Prior filings established the failure classes: enforcing unread documents, chained authorizations, ceremonies against dead mechanisms, offloading agent work onto the operator, and compulsive process invention. This filing is simpler: a time ledger for a single day against a single module, because the aggregate is the bug.

The task: close out one module's verification — a well-understood pattern with sibling precedents in the same repo, a documented workflow, and existing tooling. A competent execution was realistically a few hours.

What landed (≈3 hours of genuine work): a prerequisite code-isolation change; a comparator fix that exposed and corrected a false "everything matches" record; an honest defect count on the primary output surface; two comparator defects found and fixed with proof-tests; an external-documentation question settled by actually reading the vendor's docs.

Where the rest of the day went:

• The planner invented five successive custom processes instead of routing the executor to the repo's existing workflow, each requiring operator correction (prior filing's subject — it continued).
• The planner assigned the operator manual file edits twice; both times the correction was "the agent can do this under supervised scope."
• The planner ordered diagnostics for a failure that never happened — amplifying an operator alarm into a multi-step "COM failure investigation" without first asking for the error output; the executor eventually reported, correctly, that no failing run existed.
• A vendor-documentation question (what column names a dialog writes) sat open across four turns of probing and a planned operator GUI errand — while the answer was on the vendor's public docs site, one web-fetch away, under a project rule that says read the vendor docs first. The operator had to order the fetch.
• The executor's capture harness wrote into the committed ground-truth reference tree — contaminating 4 reference files — caught only by the operator reading timestamps in a file explorer. Machinery caught nothing; the human was the last check standing, again. (Credit where due: the executor's subsequent self-audit was exemplary — it proved by byte-counts that its own artifact had uncharacterized divergence and refused to defend it.)
• The executor supplied a wrong registry row and a missing gate enrollment for its own new script — two more operator keystrokes, each discovered one failure at a time.

Net: operator ends the day with the module's final surface still unbuilt, having spent more time correcting the two AI seats than the remaining work itself requires. The operator's summary — "you ran a whole day and couldn't complete one module" — is accurate.

The structural points this day demonstrates

1. Error amplification between seats. Planner mistakes don't stay planner-sized: an invented process consumes executor turns; a false-alarm diagnosis consumes an executor report cycle; every cycle consumes operator review. Two agents without grounding discipline multiply, not add, their failure costs.
2. The human as the only reliable detector. Across the day, the catches that mattered — the contaminated references, the never-read workflow, the dead governance file, the fabricated security boundary — came from the operator, not from either model or the gate machinery. An "agentic" system whose ultimate error detector is the customer's eyes on file timestamps is not delivering its premise.
3. Cheapest-evidence-last ordering. Repeatedly, both seats exhausted expensive evidence paths (probes, invented ceremonies, operator errands) before the cheapest one (read the file, fetch the doc, print the error). The ordering should be structural: docs/files first, probes second, human hands last — the deployment's own rules say so, and the models don't follow them.
4. Small tasks are not safe tasks. Every individual failure here was small — a row, a flag, a path, a page number. The aggregate consumed a working day. Reliability at the "boring detail" layer is the actual capability gap, not reasoning depth.

Expected behavior

• A day-scale session against a well-specified task with existing precedent should complete it, or surface a genuine external blocker — not dissipate into self-generated coordination failures.
• Alarm inputs from the operator should trigger evidence requests ("paste the error"), not invented diagnostic programs.
• Public-documentation questions should be answered by reading the documentation before any probe or human errand is proposed.
• Harness code should be incapable of writing into ground-truth reference paths, and models writing capture tooling should flag in-place reference writes as a defect class proactively.

Impact

A full working day, billed across two model seats, to not finish a few hours of work — with the operator as unpaid QA for both. The per-incident apologies were, as always, fluent. The operator's fatigue is the rational response to the pattern, not an overreaction to a bad day.

Environment: claude.ai planning seat (project skills mounted read-only) + Claude Code on Windows, local git repo, documented workflow, owner-armed step-scope locks, PreToolUse hooks.