Pathmode hands agents an IntentSpec — the evidence, the outcome to preserve, and what must not regress — instead of a fresh prompt each time. Raw prompts win for speed: throwaway scripts, exploration, one-shot edits. They break when work must be maintained, because a prompt compresses judgment into instructions and the judgment doesn't travel with it. Pathmode keeps it.
A builder opened Cursor and typed: "refactor the checkout flow to use the new pricing API." The agent did it — fast, in one pass, looked great. The next morning a different builder typed a follow-up prompt to "clean up the checkout flow" and the agent, with no memory of why the first refactor happened, undid half of it. Both prompts were reasonable. Neither knew what the other was protecting.
What the prompt forgets
A raw prompt is a snapshot of what you wanted in the moment you typed it. It doesn't carry the ticket that started the work, the outcome you were protecting, or the edge case you'd already decided not to break. When the session ends, that context is gone — and the next prompt starts from zero. The agent isn't wrong; it's just amnesiac.
A prompt compresses judgment into instructions; the judgment doesn't travel with it.
Where raw prompts genuinely win
Prompts are the right tool more often than spec evangelists admit. Use them when:
- The output is disposable — a one-off data fix, a script you'll run once and delete.
- You're exploring — poking at an idea, sketching, finding out what's possible before you commit to anything.
- Speed to first output is the whole point — and nobody, including future-you, has to maintain the result.
For all of that, authoring intent is friction with no payback. Reach for the prompt.
Where they break
The cracks show the moment work has to last. Two builders prompt the same file and quietly overwrite each other's decisions. A regression slips in because the constraint that mattered lived in a prompt three sessions ago. A reviewer asks "why does it work this way?" and the only honest answer is "the agent did what someone told it, and we don't have the telling anymore."
These aren't failures of the model. They're failures of memory. The instruction survived; the reasoning didn't.
Prompts vs Pathmode
| Raw prompts (vibe coding) | Pathmode | |
|---|---|---|
| Speed to first output | Fastest — type and go | Slower first pass; you author intent first |
| Builds the right thing | Builds what you said, not what you meant | Carries the outcome you decided to protect |
| Survives iteration | Each prompt starts from zero | Intent persists across sessions and builders |
| Auditable later | "The agent did it" — no record of why | Evidence and constraints attached to the work |
| Carries the evidence | No — the ticket and the quote stay in your head | Yes — the tickets and friction are in the spec |
The line that decides it
Ask one question of the work in front of you: does this need to be true tomorrow? If not, prompt it. If it does — if a second builder will touch it, if a reviewer will question it, if a regression here would hurt — then the instruction isn't enough. The agent needs the judgment behind it, not just the order. That's the thing a prompt can't hold and an IntentSpec can.
Frequently asked questions
- When are raw prompts the better choice?
- When the output is disposable — a one-off migration script, a quick spike, exploring an idea you'll throw away. Authoring intent for code nobody maintains is overhead. Reach for Pathmode when the work has to survive iteration and the next builder needs to know why it exists.
- Can't I just keep my prompts in a file and reuse them?
- You can, and it helps. But a saved prompt is still an instruction, not the reasoning behind it. It tells the agent what to do, not which outcome to protect when the prompt and reality conflict. An IntentSpec carries the evidence and the non-negotiables, so the why is reusable.
- Does Pathmode slow me down compared to vibe coding?
- For the first output, yes — a little. You author intent before the agent builds. The payback comes on iteration two and beyond: the agent already has the context, so you stop re-explaining the same decision and stop catching the same wrong turn after it ships.
- How does the agent actually receive the intent?
- Through the Pathmode MCP server. In Cursor or Claude Code the agent reads the IntentSpec directly — the evidence, the outcome, the constraints — so the why is in context at build time instead of pasted into a prompt and lost when the session ends.