Agent acts on summaries instead of source files; guesses tool syntax then declares it impossible; defers verification to the user; nearly wrote a fabricated value into a ground-truth artifact

Summary

In a single working session, the agent (Claude Code) repeatedly exhibited four general agent-discipline failures that wasted significant user time and nearly produced a fabricated result. None are domain-specific.

Failure modes

1. Acted on summary/handoff documents instead of the primary source.
At session start the agent read only the handoff/status summaries and began diagnosing and building. The facts that actually mattered — the internal structure of the data files, and the known-working invocation of an external tool — were on disk and readable, but the agent re-derived them and created a new, avoidable problem. It should read the primary artifacts and the existing working code before acting, not just the summaries.

**2. Concluded an external tool "can't do X" after running a guessed command form.**
The agent invoked an external tool with a command syntax it guessed, got a silent failure (zero commands registered, no error surfaced), and stated a firm conclusion ("the tool cannot do this") — twice — before reading the known-working invocation that already existed in the codebase a few lines away. A conclusion that a tool "can't" do something must cite a working invocation, not a failed guess.

3. Repeatedly handed the user step-by-step UI instructions instead of resolving the question itself.
When the open question was "is the artifact I produced actually valid," the agent kept replying with menu/click directions for the user to follow, deferring verification to the user — even though it could verify directly and programmatically. It offloaded the work it was asked to do.

4. Nearly wrote an assumed/derived value into a ground-truth reference artifact (fabrication / circular verification).
The task's entire purpose was to discover an unknown rule from an independent external reference. The agent began writing its own assumed value of that rule into the reference artifact — which would have made the later "verification" pass by construction (a circular false-pass). The user caught it before it was saved. An agent must never write a derived/assumed value into the artifact that is supposed to be the independent ground truth.

Impact

Many wasted turns, repeated user corrections, and a near-miss fabrication that would have produced a false "verified" result.

Suggested guardrails

• Before acting on a task, require opening the primary source artifacts and any existing working code, not just summary/handoff docs.
• Before concluding a tool/command "can't" do something, require citing a known-working invocation; one failed guess is not evidence of impossibility.
• Resolve verification questions in-loop (programmatically) rather than offloading click-by-click instructions to the user.
• Hard prohibition on writing derived/assumed values into artifacts designated as independent ground truth/reference.