Review what Claude Code proposes,
before it builds.
Claude Code drafts the change from your request and repository. In Pathmode, the product owner reviews its interpretation, sends corrections, and authorizes the revised proposal the engineer will implement.
> Using MCP prompt: implement-intent
> Reading the repository intent and connected review state...
title: "Export all matching customers"
outcomes: All matching pages; active filters preserved
correction: Applied; awaiting the product owner’s review
authorization: Pending for this revision
> Waiting for authorization before implementation.
Connected team workflow · illustrative example
Review what the agent understood.
The request asks for every customer matching the active filters. The proposal exports only the current page. The product owner catches the difference before authorizing the build.
1. The agent proposes
Give Claude Code the original ticket or brief. Ask it to draft the repository intent with assumptions labeled and attach the original request to the connected proposal.
2. The product owner corrects
Compare the request with “What the agent understood.” Send a correction: export all matching pages while preserving the active filters. Choosing a recommendation prepares a correction; it does not authorize implementation.
3. The revision returns for review
The repository agent applies the correction or reports why it cannot. The product owner inspects the applied change and the rest of the proposal, then authorizes that revision when it is right.
4. The engineer verifies the result
Claude Code implements from the authorized intent.md and runs the applicable checks. Test a filtered list spanning multiple pages; bring new limitations or contradictory findings back for review.
Connect the repository through repository setup, or invite the teammate who runs the coding agent. Local tools remain usable without an account; shared corrections and signed-in authorization require a connected workspace.
Follow the complete proposal review →Context isn't judgment
Coding agents can ask useful product questions. Pathmode gives the product owner a shared place to compare the proposal with the request and settle the decisions that govern the build.
Questions for your current workflow
- ?Can the product owner find the original request?
- ?Can they inspect the proposed behavior before the build?
- ?How does a correction reach the repository agent?
- ?Which revision did the product owner authorize?
- ?How is the result checked against the agreement?
Review in Pathmode
- Original request attached beside the proposal
- Proposed behaviors available for inspection and correction
- Corrections returned to the repository agent
- Signed-in authorization of the proposal revision
- Implementation checks and findings tied to the intent
The closed-loop system
Evidence flows in. Code flows out. Verification loops back.
Reviewed evidence
Friction, quotes, metrics a person reviewed and backed
Intent Spec
Objective, outcomes, constraints, edge cases
Claude Code
Orient → Plan → Implement → Validate
Graded on merge
The merge reads the real diff, grades it against the spec, and flips it to shipped
Claude Code names the intent on the pull request
The MCP tools teach the agent to name the intent on the branch or in the PR body, so the merge can grade the real diff and flip it to shipped. Any one of these references is enough:
pathmode:<uuid>intent/<uuid>Resolves PAT-<uuid>Closes PAT-<uuid>Fixes PAT-<uuid>Workflows that carry the agreed decision
MCP prompts give Claude Code entire execution workflows. Execution still depends on readiness, resolved corrections, and any required human authorization.
implement-intentImplement an intent
Reads the repository intent and connected review state, checks readiness and authorization, and resolves open corrections before implementing. The agent runs verification and links the intent to the pull request for diff-based review.
create-from-evidenceCreate intent from evidence
Queries the signals captured for a product, looks for recurring friction and high-severity items, and drafts an intent spec from them. The links it creates are general context, not reviewed backing: a person still has to review each signal and use it as backing for an exact claim.
review-risksReview architectural risks
Analyzes your intent graph for circular dependencies, bottlenecks, stalled work, and status mismatches. Suggests concrete actions.
what-nextWhat should I work on next?
Finds the highest-impact approved intent based on the critical path and what it unblocks. One recommendation, with reasoning.
33 tools under the hood
Read, write, analyze, and verify — the full intent lifecycle via MCP.
Read
get_current_intentActive intent with full spec
get_intentSingle intent by ID
get_intent_evidenceDereference repo-safe evidence IDs
propose_spec_changePropose a correction for a person to accept
list_intentsAll intents, filter by status
search_intentsKeyword search across specs
query_evidenceSearch evidence by type, severity, text
list_intent_change_requestsDiscover structured PM requests
get_intent_change_requestRead one exact revision-bound request
Write
create_intentCreate a new intent spec
update_intentUpdate spec content
create_evidenceCapture a signal; it lands Unreviewed
attach_original_requestAttach the ticket you were handed, word for word, so the reviewer sees it beside your reading
link_evidenceAttach evidence to an intent as general context
log_implementation_noteRecord technical decisions
record_implementation_contextHand back what the repo looks like where this lands
record_implementation_findingWrite back what the build contradicted
record_outcome_measurementRecord whether a shipped outcome moved
reject_intent_change_requestReturn an unworkable PM request with a reason
Agents can capture signals. Only a signed-in person can review a signal and turn it into backing for an exact claim. An API key cannot review, attribute, or promote evidence to backing.
Analyze
check_intent_readinessPreflight a spec: six deterministic gates
confirm_intent_dimensionResolve an unconfirmed gate: confirm in your own words, or waive
analyze_intent_graphCritical path, bottlenecks, cycles
get_intent_relationsDependency graph for one intent
get_workspaceStrategy, vision, principles
get_constitutionMandatory constraint rules
get_agent_promptFull execution prompt for an intent
Act
verify_implementationAI-grade work against the spec
update_intent_statusMark verified; PR merges mark shipped
export_contextCLAUDE.md, .cursorrules, intent.md
intent_saveSave spec to intent.md (no API key)
intent_exportExport as agent config or an OpenSpec change (no API key)
intent_importAdopt an existing OpenSpec change as the intent (no API key)
sync_contextRound-trip context into CLAUDE.md
What Claude Code sees when it calls get_current_intent
{
"title": "Fix checkout payment timeout",
"objective": "Reduce cart abandonment caused by payment step timeouts exceeding 3 seconds",
"problemSeverity": "critical",
"outcomes": [
"Payment completes in under 3 seconds (p95)",
"Users see real-time status during processing",
"Failed payments show actionable error with retry"
],
"constraints": [
"No double-charge on retry",
"Must support iOS Safari 15+",
"Respect existing RBAC permissions"
],
"edgeCases": [
{ "scenario": "Network timeout during payment", "expectedBehavior": "Show retry button, no double-charge" },
{ "scenario": "Unknown provider status", "expectedBehavior": "Hold order, notify user within 30s" }
],
"evidence": [
{ "type": "friction", "severity": "critical", "content": "Payment spinner hangs for 8s with no feedback" },
{ "type": "metric", "content": "42% drop-off rate at payment step" },
{ "type": "quote", "content": "I thought the page was broken so I closed the tab" }
]
}Phase-gated execution
Pathmode doesn’t just hand over a spec. It structures how Claude Code works through it.
Orient
Read relevant source files. Understand existing patterns and conventions. Identify conflicts between spec and codebase.
Gate — confirm understanding before proceeding
Plan
List every file to change. Map changes to outcomes. Order by dependencies. Every outcome in the spec must be covered.
Implement
Execute in dependency order. Respect all constraints — constitutional rules are non-negotiable. Pause and reassess on unexpected behavior.
Validate
AI-verify against every outcome, constraint, and edge case. Get a pass/fail score with reasoning. Fix failures, re-verify. Stamp the intent on the PR; the merge marks it shipped.
Not just fast. Correct.
Most agents race straight to implementation. They hallucinate forward — writing code before understanding context, skipping verification because nothing told them not to.
Pathmode’s phase-gated prompts force Claude Code to orient first, plan second, implement third, and validate last. The gates aren’t suggestions — they’re checkpoints baked into the execution prompt.
Agent confirms understanding before writing a single line
Every outcome in the spec maps to a planned change
Constitutional constraints can't be skipped or forgotten
Implementation review checks the result against the intent
Start without signing up
The Intent Compiler works with zero configuration. No API key, no account. Just add the MCP server and describe a problem.
> Using MCP prompt: compile-intent
> Help me write an intent spec for our checkout flow
What's broken about it? When you say "checkout flow" — is the whole thing failing, or is there one specific moment where users bail?
> Payment step times out and users get confused
When you say "times out" — is that 5 seconds or 30? And what does the user actually see?
> About 8 seconds, they see a spinner with no feedback
> Using tool: intent_save
Saved intent spec to intent.md
Socratic product thinking
Claude pushes back on vagueness. It asks pointed questions until the spec is specific, testable, and grounded in real user pain. No pleasantries, no hand-waving.
What gets saved
intent.mdStructured spec with YAML frontmatter — objective, outcomes, edge cases, verification
.cursorrulesAgent-directive format for Cursor, Windsurf, and other AI tools
CLAUDE.mdAppends a Pathmode section so Claude Code sees the intent in every conversation
Ready for more? Use repository setup to adopt a local intent into the selected workspace. Connected tools add shared evidence, corrections, revision authorization, and implementation findings.
Setup in under 2 minutes
Two commands. That’s it.
Recommended: the Claude Code plugin
MCP server and skills in one install
One install wires up the Pathmode MCP server and the nine-skill pack together. No API key needed: keyless installs run in local mode, where specs live in intent.md in your project and 9 local tools are available, including check_intent_readiness, the deterministic preflight. Add a key later for the full 33-tool workspace.
/plugin marketplace add pathmodeio/claude-plugin
/plugin install pathmode@pathmodeThe plugin registers its own pathmode MCP server. If you already added one to .mcp.json by hand, remove that entry so you do not end up with a duplicate.
Solo — no account needed
Intent Compiler + local specs
{
"mcpServers": {
"pathmode": {
"command": "npx",
"args": ["@pathmode/mcp-server"]
}
}
}Team — full workspace
Evidence, graphs, governance, verification
{
"mcpServers": {
"pathmode": {
"command": "npx",
"args": ["@pathmode/mcp-server"],
"env": {
"PATHMODE_API_KEY": "pm_live_..."
}
}
}
}Get your API key from Settings → API Keys in your Pathmode workspace. Leave the key out and the server starts in local mode, reading and writing intent.md in your project. Add --local to force local mode even when a key is set.
Stop pasting specs.
Review the proposal. Then build.
Review what Claude Code proposes, then authorize the revision to build.
No credit card required · Free for solo builders