Let a coding agent correct the spec it's building from

Handing a spec to an agent is the start of the loop, not the end. The most useful thing an agent learns is often that the spec it was handed is wrong somewhere. This use case is how that correction gets back into the spec instead of dying in a diff.

The input

A spec in flight: an IntentSpec handed to Claude Code, Cursor, or any MCP-connected agent, and an agent that, mid-build, hits something the spec got wrong. A constraint that can't be enforced. An outcome assuming a data shape that doesn't exist. A dedupe key that turns out not to be unique.

The flow

1. The agent records a finding, not a workaround. Through the Pathmode MCP server, the agent calls record_implementation_finding with two required parts: assumption (what the spec took for granted) and finding (what building revealed). Optionally a correction and a target pointing at the check it falsifies.

2. The finding flips the falsified check. If the finding targets a verification check (target: "check:<id>"), recording it flips that check to failing in the same write. A finding and a failing check are the same event, so the status is everywhere at once.

3. It rides into the next prompt. Open findings travel with the spec on every export and MCP pull. The next agent reads "the spec assumed X; building showed Y" before it starts, so it never rebuilds the dead premise.

4. You reconcile it in the editor. Open the intent. Each finding sits at the top: reconcile (fold the correction into the spec) or dismiss (the premise stands). The agent surfaced it; you decide.

The output

A spec that converged instead of drifting:

• The contradiction is recorded, with what the spec assumed versus what the build revealed, not lost in a PR thread
• The falsified check reads "failing" everywhere the spec is read, until it's re-verified
• The next agent starts from the correction, not the stale premise
• The resolution was a human call, made in the editor, with a kept audit trail

Why this beats a PR comment

A PR comment is read once, by whoever reviews that PR, and then it's archaeology. The spec is read by every future agent and every teammate who opens the intent. Putting the correction where the next reader actually looks is the difference between a loop that converges and one that repeats itself.

Try it yourself

1. Connect the Pathmode MCP server to your agent (see the wiring playbook)
2. Hand it a real spec and let it build
3. When it hits something the spec got wrong, have it call record_implementation_finding
4. Open the intent in Pathmode and reconcile the finding into the spec

Related

• Playbook: When the Build Contradicts the Spec
• Playbook: Wire Pathmode Into Your Coding Agent
• Use case: Hand off a spec to Claude Code without losing context