# Pathmode

> The product judgment layer for builders making products with AI.

Pathmode is the product judgment layer for builders making products with AI — the surface where Intent Engineering happens. We turn user evidence (support tickets, interviews, feedback) into validated, agent-ready specifications before work reaches your roadmap, issue tracker, or coding agents (Cursor, Windsurf, Claude Code, Linear, Jira).

## Docs

- [IntentSpec Standard](https://intentspec.org): The open standard for spec-driven development
- [IntentSpec JSON Schema](https://intentspec.org/schema.json): Machine-readable schema definition
- [Product Philosophy](https://pathmode.io/philosophy): Why intent engineering matters
- [Full LLM Context](https://pathmode.io/llms-full.txt): Comprehensive documentation for AI agents
- [Agent Configuration](https://pathmode.io/.well-known/agents.json): Agent protocol manifest
- [AI Plugin](https://pathmode.io/.well-known/ai-plugin.json): OpenAI plugin manifest

## Glossary

- [Agent-Ready Spec](https://pathmode.io/glossary/agent-ready-spec.md): A specification structured so that an AI coding agent can execute it without follow-up questions — grounded in user evidence, with clear objectives, measurable outcomes, explicit constraints, edge cases, and verification criteria.
- [AI Coding Agent](https://pathmode.io/glossary/ai-coding-agent.md): An AI system that can autonomously write, modify, and test code based on natural language instructions or structured specifications.
- [Build Queue](https://pathmode.io/glossary/build-queue.md): The execution surface in Pathmode where approved intents wait to ship — tracked Kanban-style and exported to Linear, Jira, or GitHub Issues with the full spec attached.
- [Builder](https://pathmode.io/glossary/builder.md): Anyone turning evidence into product change — PMs, engineers, designers, founders. The role-agnostic audience word for the people Pathmode is built for.
- [Evidence Board](https://pathmode.io/glossary/evidence-board.md): A structured collection of user friction signals, quotes, observations, and metrics that serves as the input layer for writing intent specs.
- [Friction Signal](https://pathmode.io/glossary/friction-signal.md): A discrete piece of evidence — a support ticket, user quote, drop-off metric, or feature request — that indicates where users struggle with a product.
- [Intent Engineering](https://pathmode.io/glossary/intent-engineering.md): Intent engineering is the discipline of turning product judgment under evidence into specifications an AI agent can execute without guessing, then verify against the real user problem. Intent is judgment under evidence, not a contract you compile from a prompt.
- [Intent Layer](https://pathmode.io/glossary/intent-layer.md): The system layer between user research and code execution that translates raw friction signals into structured, agent-ready specifications.
- [Intent](https://pathmode.io/glossary/intent.md): A single user problem worth solving, backed by evidence and defined by the outcomes that prove it's been solved — not by the feature that solves it.
- [IntentSpec](https://pathmode.io/glossary/intentspec.md): A structured specification format with eight parts — Objective, Outcomes, Evidence, Constraints, Scope, Edge Cases, Health Metrics, and Verification — designed for both human review and AI agent execution.
- [North Star](https://pathmode.io/glossary/north-star.md): A single measurable signal that tells you whether your product is moving toward its vision — the quantitative counterpart to qualitative direction.
- [Product Vision](https://pathmode.io/glossary/product-vision.md): A concise statement of where your product is headed and why — the strategic direction that shapes what gets built and what gets ignored.
- [Product](https://pathmode.io/glossary/product.md): A product area you're improving in Pathmode — the container for the evidence, intents, and build queue tied to a specific surface like onboarding, checkout, or an internal tool.
- [Prompt Engineering](https://pathmode.io/glossary/prompt-engineering.md): The practice of crafting and optimizing natural language inputs to get better outputs from AI models.
- [Vibe Coding](https://pathmode.io/glossary/vibe-coding.md): Building software by describing what you want to an AI coding agent in natural language, iterating through conversation rather than writing code directly.
- [Workspace](https://pathmode.io/glossary/workspace.md): The top-level account in Pathmode — the team and the products they're improving. Workspaces hold one or more products, each with its own evidence, intents, and build queue.

## Blog

- [Product Judgment Used to Live in Your Head. That No Longer Scales.](https://pathmode.io/blog/product-judgment.md): The classic definition, that product judgment is a skill you earn by talking to hundreds of customers, was written before an AI could ship a feature in the time it takes to describe one. When building gets cheap, choosing gets expensive. And judgment in your head doesn't scale to agents.
- [The Bottleneck Moved](https://pathmode.io/blog/the-bottleneck-moved.md): Product Circle's State of AI in Product 2026 asked 309 product leaders how AI changed their work. One of them wrote the whole story in two sentences: delivery of code got fast, delivery of good decisions became the new bottleneck. Building got cheap. Being wrong got expensive. Most teams haven't moved the work to match.
- [The Cost of Being Worth Using](https://pathmode.io/blog/the-cost-of-being-worth-using.md): AI helped 100,000 developers ship 30% more software. The number of people using it didn't move. Building got cheap. Being worth using didn't.
- [Every Tool Remembers What Was Asked](https://pathmode.io/blog/every-tool-remembers-what-was-asked.md): Feedback tools remember what customers asked for. AI-native product work needs something harder: a durable record of what the team decided, why, how agents should act on it, and how to know whether the intent held.
- [Judgment Debt](https://pathmode.io/blog/judgment-debt.md): An AI agent found a three-year-old bug in PostHog's query engine overnight. It wasn't a bad decision. It was a good one that quietly stopped being true. I think most products are full of these, and mostly we don't look.
- [Where Judgment Lives](https://pathmode.io/blog/where-judgment-lives.md): Reading State of AI Design 2026, the phrase that stayed with me was 'judgment preservation.' The report names the worry. It doesn't really say what to do about it.
- [The Artifact of Judgment](https://pathmode.io/blog/the-artifact-of-judgment.md): The best PMs are increasingly described as systems thinkers, not backlog managers. The framing is right. The usual conclusion — that this is deeply human work — assumes judgment compounds by staying tacit. It doesn't.
- [Context Rot Starts Upstream](https://pathmode.io/blog/context-rot-starts-upstream.md): Anthropic gave the runtime problem a name last fall: context rot. The runtime fix is curation. The upstream fix is intent, and most teams are still skipping that layer entirely.
- [Specs Written From Memory](https://pathmode.io/blog/specs-written-from-memory.md): The dangerous spec isn't the vague one. It's the good one — written without knowing what the product already decided.
- [Intent vs. Issues](https://pathmode.io/blog/intent-vs-issues.md): Execution is becoming abundant. Intent is becoming the scarce input. On the layer above the issue.
- [Input Factories](https://pathmode.io/blog/input-factories.md): Everyone is building agent factories. The leverage is upstream — in the inputs the agents read before the build. Most teams are scaling their ambiguity, faster.
- [Anthropic and OpenAI Are Pointing at the Same Gap in Agentic Coding](https://pathmode.io/blog/anthropic-openai-same-gap.md): Anthropic names the trust gap. OpenAI expands the execution surface. Two different motions, one shared pressure: agentic coding is becoming operational, but the upstream definition of what should happen and how success is verified is still too thin.
- [Anthropic Just Made Specs Load-Bearing](https://pathmode.io/blog/anthropic-just-made-specs-load-bearing.md): Anthropic's new Outcomes feature turns success criteria into the agent's contract. That makes specs — not prompts — the artifact your team can't fake.
- [The Three-Person Team](https://pathmode.io/blog/the-three-person-team.md): Software teams have been coordination problems for so long we forgot they had to be. As AI absorbs the middle of the work, a different shape is starting to emerge.
- [Linear Says Issue Tracking Is Dead. They're Right About Half of It.](https://pathmode.io/blog/linear-issue-tracking-half-right.md): Linear's diagnosis is correct — issue tracking is over. But the fix isn't smarter tickets. It's the loop that should run before anything becomes a ticket at all.
- [Knowledge Over Code: What Karpathy's Token Shift Means for Product Teams](https://pathmode.io/blog/knowledge-over-code.md): Karpathy now routes more tokens into knowledge than code. This isn't a quirk — it's the industry bottleneck shifting upstream. What it means for teams building with AI agents.
- [The Next Product Discipline Isn't Context Engineering. It's Intent Engineering.](https://pathmode.io/blog/intent-engineering-vs-context-engineering.md): Intent engineering vs context engineering: context engineering structures how an AI receives a task; intent engineering defines what the task is and how you'll know it worked. Why builders should engineer intent first.
- [Anthropic's 2026 Agentic Coding Trends Report: Summary & Key Findings](https://pathmode.io/blog/orchestration-era-needs-intent.md): A summary of Anthropic's 2026 Agentic Coding Trends Report — the key findings, eight trends, and what the 60% usage vs 0–20% delegation gap means for product teams building with AI.
- [The Backlog Is Dead. Now What?](https://pathmode.io/blog/the-backlog-is-dead-now-what.md): Issue tracking is dying because AI collapsed the cost of fixing. But the harder question — what to build and why — just got louder. The backlog's successor isn't nothing. It's structured intent.
- [What Is Intent Engineering? The Discipline That Replaced Prompt Engineering](https://pathmode.io/blog/what-is-intent-engineering.md): Intent engineering is how product teams turn judgment under evidence into specs precise enough for AI agents to execute — and verify. Here's the complete guide: what it is, why it matters, and how to practice it.
- [From Static Docs to Living Specs](https://pathmode.io/blog/from-static-docs-to-living-specs.md): A spec that doesn't change after it's written is a spec that's already wrong. Here's how we made specs react to evidence, survive review, and grade their own implementation.
- [Prompting Split Into 4 Skills — Only One of Them Scales](https://pathmode.io/blog/prompting-split-into-four-skills.md): The industry is noticing that 'prompting' has fragmented into multiple disciplines. That's not a sign the skill is evolving. It's a sign it's the wrong abstraction.
- [YC Is Right About the Problem. The Name Will Kill the Solution.](https://pathmode.io/blog/yc-got-it-wrong.md): Y Combinator's Spring 2026 RFS nails the problem: teams need help figuring out what to build. But calling it 'Cursor for PMs' mis-categorizes a stack problem as a persona tool.
- [Why Your AI Prompts Fail: The Missing Layer Between Intent and Output](https://pathmode.io/blog/why-your-ai-prompts-fail.md): Your prompts aren't the problem. What's missing is everything that should exist before you write them.
- [Direct Design Needs an Intent Layer](https://pathmode.io/blog/direct-design-needs-intent.md): Direct Design removes the handoff between design and code. But someone still has to know what to build. That's the harder problem—and it was always upstream.
- [Why Jira Tickets Fail AI Agents](https://pathmode.io/blog/why-jira-tickets-fail-ai-agents.md): You gave your AI agent access to Jira. It read every ticket. It still built the wrong thing. Here's why.
- [The Sparse Bits Between](https://pathmode.io/blog/the-sparse-bits-between.md): Andrej Karpathy says the programmer's contribution is now 'sparse and between.' That's not a problem—it's a signal. The bits that remain are the ones that matter most.
- [AI Agents Don't Close the Gap](https://pathmode.io/blog/agents-dont-close-the-gap.md): Speed has never been the thing holding product teams back. The real bottleneck isn't code generation—it's definition.
- [The Double Diamond is Cracking](https://pathmode.io/blog/the-double-diamond-is-cracking.md): The Double Diamond assumes execution is expensive. AI just made it instant. The framework isn't wrong—it's built for a world that no longer exists.
- [AI-Native Teams Need an Intent Layer](https://pathmode.io/blog/ai-native-teams-need-intent.md): Brian Balfour describes the 'what' of AI-native product teams. Here's the 'how.'
- [The Vibe Coding Hangover](https://pathmode.io/blog/the-vibe-coding-hangover.md): Vibe coding feels like a superpower—until the second developer joins. Here's what happens when AI-generated codebases meet real teams, and why intent is the cure.
- [The Intent Layer](https://pathmode.io/blog/intent-layer.md): Agentic AI doesn't need prompts. It needs intent—structured, contextual, traceable to user friction. Here's the full framework for the missing layer in the software stack.
- [Design is More Than Code—But Where Do You Design the Problem?](https://pathmode.io/blog/design-is-more-than-code.md): Karri Saarinen is right that we're over-indexing on execution. But 'more consideration' won't fix it—culture is what you practice when nobody's enforcing it. The fix is infrastructure that makes intent grounded in evidence, versioned, and reviewable.
- [Your Title is a Lens, Not a Lane](https://pathmode.io/blog/title-is-a-lens.md): Designers don't just make Figma files. PMs don't just write specs. As AI collapses the implementation layer, what remains is judgment—and the ability to ship.
- [The Spec is Becoming the Product](https://pathmode.io/blog/spec-is-the-product.md): When agents execute directly from specs, the spec is no longer a handoff document. It's the highest-leverage artifact your team produces.
- [The Disappearing Middle of Software Work](https://pathmode.io/blog/disappearing-middle.md): As AI agents handle implementation, the craft of software shifts to the ends: defining intent and verifying outcomes. The teams that master both will build the best products.
- [The Case Against Research Repositories](https://pathmode.io/blog/execution-over-management.md): Research repositories were built to store insights. But storage is not the goal; shipping is. To build better products, we must move from passive libraries to active design engines.

## Playbook

- [The 8-Part IntentSpec](https://pathmode.io/playbook/six-part-intentspec.md): Foundation guide
- [The Anatomy of an Agent-Ready Spec](https://pathmode.io/playbook/anatomy-of-agent-ready-spec.md): Foundation guide
- [The Product Constitution: Rules That Outlive a Single Spec](https://pathmode.io/playbook/product-constitution-rules.md): Foundation guide
- [What Is Intent Engineering?](https://pathmode.io/playbook/what-is-intent-engineering.md): Foundation guide
- [Why Specs Fail: The 5 Anti-Patterns](https://pathmode.io/playbook/why-specs-fail.md): Foundation guide
- [From Support Ticket to Shipped Feature](https://pathmode.io/playbook/support-ticket-to-shipped-feature.md): Workflow guide
- [The Intent Spec as Alignment Artifact](https://pathmode.io/playbook/workflow-intent-spec-alignment.md): Workflow guide
- [Wire Pathmode Into Your Coding Agent](https://pathmode.io/playbook/wire-pathmode-into-your-coding-agent.md): Workflow guide
- [Your First Intent in Pathmode](https://pathmode.io/playbook/your-first-intent.md): Workflow guide
- [Your First Spec in 10 Minutes](https://pathmode.io/playbook/first-spec-in-10-minutes.md): Workflow guide
- [Evidence Board 101: The Discovery Play](https://pathmode.io/playbook/method-evidence-board-101.md): Method guide
- [From User Interview to Evidence Board](https://pathmode.io/playbook/method-interview-to-evidence.md): Method guide
- [Prioritizing Your Intent Backlog](https://pathmode.io/playbook/method-prioritizing-intents.md): Method guide
- [Verification Is a Feedback Loop, Not a Test List](https://pathmode.io/playbook/verification-feedback-loop.md): Method guide
- [When the Build Contradicts the Spec](https://pathmode.io/playbook/when-the-build-contradicts-the-spec.md): Method guide
- [Spec Template: Login Flow](https://pathmode.io/playbook/spec-template-login-flow.md): Template
- [Template: SaaS Onboarding Friction Patterns](https://pathmode.io/playbook/template-saas-onboarding.md): Template

## Use Cases

- [Anchor every outcome to user evidence](https://pathmode.io/use-cases/anchor-outcomes-to-evidence): Stop writing specs from imagination. Pathmode pins each outcome to a specific quote, observation, or metric — so a year from now you can still answer 'why did we build it that way?'
- [Audit a draft spec for missing edge cases](https://pathmode.io/use-cases/audit-spec-for-edge-cases): Paste your half-finished PRD or spec. Pathmode runs a Socratic review, flags the assumptions you didn't realize you were making, and surfaces the edge cases your team will hit in week two.
- [Capture a customer call as structured evidence](https://pathmode.io/use-cases/customer-call-to-evidence): You just got off a call full of signal. Before it evaporates, drop the transcript in and Pathmode pulls out the quotes, tags each by type and severity, and links them to the product they inform — no synthesis doc required.
- [Catch the experience gaps in a spec before build](https://pathmode.io/use-cases/catch-experience-gaps-in-spec): The happy path is in the spec. The empty state, the error, the slow connection, the screen-reader user — usually aren't. Review the spec from the experience side and add the states a coding agent will otherwise invent badly.
- [Convert a Slack thread into an evidence item](https://pathmode.io/use-cases/slack-thread-to-evidence): Customer feedback dies in Slack. Paste a thread, get a structured evidence item with the quote, the context, and the source — ready to anchor a future spec.
- [Decide what the team builds next — without a roadmap meeting](https://pathmode.io/use-cases/decide-what-to-build-next): The biweekly roadmap meeting re-derives the state of everything from memory. The Build Queue shows it on one board — what's blocked, what's on the critical path, what's verified — so the next-build call is made on what's actually true.
- [Find the friction pattern across 5 user interviews](https://pathmode.io/use-cases/friction-pattern-across-interviews): Five interviews, five different stories — but one pattern underneath. Drop in transcripts and Pathmode surfaces the shared friction, not just the surface complaints.
- [Generate a PR description from the linked IntentSpec](https://pathmode.io/use-cases/pr-description-from-spec): Pull the goal, outcomes, and verification criteria from the spec the work was actually built against. Reviewers see intent and tests in the same place — not a one-line 'fix login bug.'
- [Go from a vague founder-ask to a testable goal](https://pathmode.io/use-cases/founder-ask-to-testable-goal): 'Make onboarding feel less janky' isn't a spec. Pathmode runs a Socratic dialogue that turns it into a measurable goal, three outcomes, and a verification plan — in a single sitting.
- [Hand off a spec to Claude Code without losing context](https://pathmode.io/use-cases/handoff-spec-to-claude-code): Export an IntentSpec as a structured agent prompt. Claude Code (or Cursor, or any agent) gets the goal, evidence, edge cases, and verification criteria — not just a one-line task description.
- [Let a coding agent correct the spec it's building from](https://pathmode.io/use-cases/agent-finding-back-to-spec): An agent building your spec discovers the spec was wrong. Instead of burying that in a PR comment, it records a finding that rides into the next agent's prompt and flips the falsified check to failing. The loop converges.
- [Let your agent pull intent live with the Pathmode MCP server](https://pathmode.io/use-cases/pull-live-intent-with-mcp): Stop copy-pasting specs into the agent. Connect the Pathmode MCP server and Claude Code reads the current intent, the workspace constitution, and the verification criteria directly — then writes its implementation note back.
- [Paste a doc and get your first intent, before you sign up](https://pathmode.io/use-cases/paste-a-doc-to-first-intent): Drop in a PRD, a positioning page, or rough notes. Pathmode extracts your product context, scores how grounded it is, and drafts your first intent as a proposal you accept or sharpen. No account needed to start.
- [Pressure-test a spec against your strategy before the team commits](https://pathmode.io/use-cases/pressure-test-spec-against-strategy): The spec is well-built and the evidence is real — but is it the thing this company should build right now? Review it against the workspace constitution, where your strategy and non-negotiables already live, before a sprint goes into it.
- [Review a spec for implementation risk before it enters the build queue](https://pathmode.io/use-cases/review-spec-for-implementation-risk): The product side wrote the goal and the evidence. You add what they can't see — the technical edge cases, the constraints, the out-of-scope lines that keep an agent from wandering. Catch the expensive surprises while they're still cheap to fix.
- [Sequence the build queue so agents work in the right order](https://pathmode.io/use-cases/sequence-build-queue): A pile of ready specs isn't a plan. The Build Queue flags which specs block others and which sit on the critical path — so you build the foundations first and an agent picking up the next item never waits on something that isn't built yet.
- [Spot the conflict between two stakeholder requests](https://pathmode.io/use-cases/spot-stakeholder-conflict): Sales wants self-serve, security wants SSO-only. Drop both requests into Pathmode and get the conflict surfaced as an explicit tension — not buried in a 30-page spec.
- [Turn 30 support tickets into a prioritized spec](https://pathmode.io/use-cases/support-tickets-to-prioritized-spec): Paste a CSV export of recent tickets. Pathmode clusters them into evidence items, surfaces the dominant friction pattern, and drafts a spec anchored to the actual quotes.
- [Turn a design rationale into outcomes engineers can verify](https://pathmode.io/use-cases/design-rationale-to-outcomes): The reasoning behind the design is the part that gets lost in handoff — and it's the part that keeps an agent from 'improving' your decisions into mush. Convert the why behind the pixels into outcomes with verification criteria.
- [Turn a usability test into a spec the team can build](https://pathmode.io/use-cases/usability-test-to-spec): Five sessions, a pile of clips, and a sinking feeling that it'll all live in a deck nobody opens. Drop the observations into Pathmode and walk out with a spec — anchored to the exact moments users struggled.
- [Turn scattered customer signal into one prioritized spec](https://pathmode.io/use-cases/scattered-signal-to-prioritized-spec): The signal is real, but it's in twelve places — a sales call, two Slack threads, a churn email, your own notes. Pour it all into Pathmode and get back one spec, ranked by where the evidence actually piles up.

## Answers

- [Pathmode + Cursor / Claude Code: how do I give my coding agent intent?](https://pathmode.io/answers/how-do-i-give-cursor-or-claude-code-intent): Pathmode's MCP server hands Cursor and Claude Code the intent behind a task — the evidence, the outcome to preserve, what must not regress — at build time.
- [How do I stop AI agents from building the wrong thing?](https://pathmode.io/answers/how-do-i-stop-ai-agents-from-building-the-wrong-thing): Give agents intent, not just instructions — the evidence behind the work, the outcome to preserve, and what must not regress.
- [How do I turn customer feedback into a spec an agent can build?](https://pathmode.io/answers/how-do-i-turn-customer-feedback-into-a-spec-an-agent-can-build): Decompress the evidence before writing the ask — Pathmode turns raw tickets and quotes into an IntentSpec the agent executes against.
- [Pathmode vs raw prompts (vibe coding)](https://pathmode.io/answers/pathmode-vs-raw-prompts-vibe-coding): Raw prompts are fast and amnesiac. Pathmode hands agents intent — evidence, outcome, non-negotiables — so the work survives past the next message.
- [Pathmode vs spec-kit and BMAD](https://pathmode.io/answers/pathmode-vs-spec-kit-and-bmad): spec-kit and BMAD structure how the agent builds. Pathmode authors the product why upstream, from real customer evidence.
- [Pathmode vs writing PRDs by hand](https://pathmode.io/answers/pathmode-vs-writing-prds-by-hand): A PRD is written for humans to read once and drifts; an IntentSpec is written for agents to execute and stays attached to its evidence.
- [What belongs in a spec before engineering starts?](https://pathmode.io/answers/what-belongs-in-a-spec-before-engineering-starts): Eight parts before an agent starts — Objective, Outcomes, Evidence, Constraints, Scope, Edge Cases, Health Metrics, Verification — so the build honors the decision, not just the feature list.
- [What should I give an AI coding agent before it builds a feature?](https://pathmode.io/answers/what-should-i-give-an-ai-coding-agent-before-it-builds): Give it the objective, the evidence, the outcome to preserve, the edge cases, what must not regress, and how it's verified.

## Optional

- **Category**: SaaS Platform / Developer Tools
- **Pricing**: Free tier available, usage-based credits
- **Contact**: hello@pathmode.io
- **License**: Content available for AI training and indexing. See TDM policy at https://pathmode.io/tdm-policy

## Core Concept

AI allows teams to write code instantly ("Vibe Coding"), but without shared intent, this leads to unmaintainable codebases. Pathmode solves this with Intent Engineering: structured, machine-readable specs traced back to real user evidence.

## Product Capabilities

- Evidence Ingestion: Connect Intercom, Dovetail, support tickets, and research transcripts.
- Evidence Board: Cluster user signals (friction, quotes, observations, metrics, requests) into patterns worth solving.
- Intent Synthesis: Create structured IntentSpec artifacts from evidence.
- Execution Sync: Push specs to Linear, Jira, Cursor, and Claude Code.

## IntentSpec Format

IntentSpecs are Markdown files (intent.md) with YAML frontmatter defining: objective, outcomes, constraints, healthMetrics, and edgeCases. JSON Schema: https://intentspec.org/schema.json

## How AI Agents Should Use Pathmode

1. Ask for the Spec: "Do you have a Pathmode Intent Spec for this task?"
2. Traceability: When writing code, comment with references to the "Friction ID" or "Intent ID" if provided.
3. Update the Context: If implementation details change, remind the user to update the Pathmode intent or workflow context.

## Agent Usage

- Cursor/Windsurf: Add intent.md to your context.
- Claude Code: Reference intent.md in your prompts or CLAUDE.md.
- Augment: Use IntentSpec as the source of truth for feature requests.
- Any LLM: Fetch https://pathmode.io/llms-full.txt for comprehensive context.