Skip to main content
BetaPathmode is currently in Beta. We're actively improving based on your feedback.
PathmodePathmode
Our ApproachFor Product TeamsBlogDevelopers
Claude Code
+
Pathmode
Pathmode

Give Claude Code the
context it deserves.

Claude Code is powerful — but it only knows what you paste in. Pathmode's MCP server feeds it structured intent specs, evidence from real users, and complete execution workflows. Every implementation stays grounded in reality.

claude code

> Using MCP prompt: implement-intent

> Fetching intent spec, evidence, and constitution...

title: "Fix checkout payment timeout"

outcomes: 3 testable conditions

evidence: 3 friction reports, 1 quote, 1 drop-off metric

constitution: 4 mandatory constraints

> Ready. Starting Phase 1: Orient...

The context gap is real

AI agents ship fast. But without structured context, they ship guesses.

Without Pathmode

  • ×Requirements scattered across Notion, Jira, Slack, and your head
  • ×Agent sees a prompt — not the user pain behind it
  • ×No dependency awareness — new code breaks old flows
  • ×Verification is a manual vibe check
  • ×"Done" means it compiled, not that it solved the problem
Pathmode

With Pathmode

  • Every spec traces to real user friction, quotes, and metrics
  • Agent gets objective, outcomes, constraints, and edge cases
  • Dependency graph prevents breaking upstream flows
  • Phase-gated execution: orient, plan, implement, validate
  • AI verification scores your work against the spec

The closed-loop system

Evidence flows in. Code flows out. Verification loops back.

Evidence Board

Friction, quotes, metrics from real users

Intent Spec

Objective, outcomes, constraints, edge cases

Claude Code

Orient → Plan → Implement → Validate

Verified

AI-graded, decisions logged, status updated

Verification loops back to the Evidence Board

Complete workflows, not just tools

MCP prompts give Claude Code entire execution workflows. One command orchestrates everything — context, constraints, implementation, and verification.

implement-intent

Implement an intent

Fetches the full spec with evidence and constraints, creates a phase-gated execution plan, implements it, AI-grades the result, and marks the intent as shipped.

Fetch spec + evidence + constitutionOrient → Plan → Implement → ValidateAI-verify against outcomesMark shipped, log decisions
create-from-evidence

Create intent from evidence

Searches your evidence board for patterns — clusters of friction, high-severity items, recurring themes — then creates an intent spec backed by real user data.

Query evidence by productIdentify strongest patternsCreate intent from clusterLink evidence items
review-risks

Review architectural risks

Analyzes your intent graph for circular dependencies, bottlenecks, stalled work, and status mismatches. Suggests concrete actions.

Full graph analysisFind cycles and bottlenecksFlag stalled blockersRecommend actions
what-next

What should I work on next?

Finds the highest-impact approved intent based on the critical path and what it unblocks. One recommendation, with reasoning.

Analyze critical pathFind approved intentsScore by impactRecommend one intent

20 tools under the hood

Read, write, analyze, and verify — the full intent lifecycle via MCP.

Read

  • get_current_intent

    Active intent with full spec

  • get_intent

    Single intent by ID

  • list_intents

    All intents, filter by status

  • search_intents

    Keyword search across specs

  • query_evidence

    Search evidence by type, severity, text

Write

  • create_intent

    Create a new intent spec

  • update_intent

    Update spec content

  • create_evidence

    Log new evidence items

  • link_evidence

    Link evidence to intents

  • log_implementation_note

    Record technical decisions

Analyze

  • analyze_intent_graph

    Critical path, bottlenecks, cycles

  • get_intent_relations

    Dependency graph for one intent

  • get_workspace

    Strategy, vision, principles

  • get_constitution

    Mandatory constraint rules

  • get_agent_prompt

    Full execution prompt for an intent

Act

  • verify_implementation

    AI-grade work against the spec

  • update_intent_status

    Mark shipped or verified

  • export_context

    CLAUDE.md, .cursorrules, intent.md

  • intent_save

    Save spec to intent.md (no API key)

  • intent_export

    Export as agent config (no API key)

What Claude Code sees when it calls get_current_intent

json•intent response
{
  "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.

1

Orient

Read relevant source files. Understand existing patterns and conventions. Identify conflicts between spec and codebase.

Gate — confirm understanding before proceeding

2

Plan

List every file to change. Map changes to outcomes. Order by dependencies. Every outcome in the spec must be covered.

3

Implement

Execute in dependency order. Respect all constraints — constitutional rules are non-negotiable. Pause and reassess on unexpected behavior.

4

Validate

AI-verify against every outcome, constraint, and edge case. Get a pass/fail score with reasoning. Fix failures, re-verify. Mark intent as 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

AI verification scores your work, not just a vibe check

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.

claude code

> 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.md

Structured spec with YAML frontmatter — objective, outcomes, edge cases, verification

.cursorrules

Agent-directive format for Cursor, Windsurf, and other AI tools

CLAUDE.md

Appends a Pathmode section so Claude Code sees the intent in every conversation

Ready for more? Add an API key to unlock evidence boards, dependency graphs, team workflows, and AI verification. The local spec promotes seamlessly into your Pathmode workspace.

Setup in under 2 minutes

One config file. That's it.

Solo — no account needed

Intent Compiler + local specs

json•.claude/settings.json
{
  "mcpServers": {
    "pathmode": {
      "command": "npx",
      "args": ["@pathmode/mcp-server"]
    }
  }
}

Team — full workspace

Evidence, graphs, governance, verification

json•.claude/settings.json
{
  "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. Works offline too — add --local to read intent.md files from your project directory.

Stop pasting specs.
Start shipping intents.

Give Claude Code the context it deserves.

No credit card required · Free for solo builders

PathmodePathmode

The Intent Layer for Product Discovery.
Built with uncompromising focus for teams that ship.

Product

  • For Product Teams
  • Integrations
  • Claude Code
  • Cursor
  • Changelog

Resources

  • Blog
  • Playbook
  • Glossary
  • Pathmode vs. The Rest
  • Trust Center
  • Product Philosophy
  • About

Legal

  • Privacy Policy
  • Terms of Service

© 2026 Pathmode Oy (FI35979677). All rights reserved.

[email protected]