# 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
- [Intent Engineering Framework](https://pathmode.io/intent-engineering): How evidence becomes an agent-ready product spec
- [Full LLM Context](https://pathmode.io/llms-full.txt): Comprehensive documentation for AI agents
- [Pathmode API Docs](https://pathmode.io/developers): REST API reference — authentication, scopes, rate limits, and agent integration
- [Pathmode OpenAPI Spec](https://pathmode.io/openapi.json): Machine-readable OpenAPI 3.1 spec for the Pathmode REST API
- [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 intents move from draft to verified, tracked on a status board 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): The former name for Pathmode's Evidence surface. Evidence is now an Inbox of unreviewed signals plus a searchable Browse record, and every signal carries a trust tier: backing, unreviewed, or assumption.
- [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

- [Accepted Is Not Measured](https://pathmode.io/blog/accepted-is-not-measured.md): Anthropic's AI-native SDLC course measures how quickly intents are captured and how often they are accepted. Neither establishes whether a shipped change achieved its proposed product outcome.
- [The Missing Feed](https://pathmode.io/blog/the-missing-feed.md): An agent can propose a technically sound change while a product choice remains unresolved. The missing connection is a review that carries the owner’s decision into the build.
- [The Repo Gets the Decision](https://pathmode.io/blog/the-repo-gets-the-decision.md): Why Pathmode moved its center of gravity into the repository, made intent.md authoritative, and narrowed the hosted product to what a file cannot do.
- [The First Artifact Has No Readiness Gate](https://pathmode.io/blog/the-first-artifact-has-no-gate.md): Anthropic's AI-native SDLC playbook puts explicit controls around every stage after intent.md. The first artifact gets human review, but no repeatable readiness check. I built one, calibrated it against 98 examples, and put the verdict inside the file.
- [The Missing Gate in the Software Factory](https://pathmode.io/blog/the-missing-gate-in-the-software-factory.md): A precise specification can carry an unexamined product choice into implementation. Review the proposal against the original need, resolve the consequential questions, and authorize the revised decision.
- [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 is shifting token throughput from code toward knowledge. The bottleneck is moving upstream, into the product intent AI agents need before they build.
- [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.
- [Why Intent Engineering Is Replacing Prompt Engineering](https://pathmode.io/blog/what-is-intent-engineering.md): AI coding agents made implementation cheap while exposing the limits of prompting. This essay argues for intent engineering as the discipline that carries product judgment into agentic work.
- [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): Jira coordinates human work. AI coding agents treat every omission as room to guess. The ticket can stay, but the product decision needs to live with the code.
- [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 does not need prompts. It needs intent: structured, evidence-backed, and living where agents already read. The framework for the missing layer, rewritten for the repo-native workflow.
- [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

- [A Product Intent Loop for Anthropic's AI-Native SDLC Playbook](https://pathmode.io/playbook/product-layer-ai-native-sdlc.md): Foundation guide — Anthropic's AI-native SDLC playbook accelerates execution. This companion explains the product intent loop that feeds it: Sense, Decide, Specify, and Learn.
- [The 8-Part IntentSpec](https://pathmode.io/playbook/six-part-intentspec.md): Foundation guide — The periodic table of Intent Engineering. Every executable spec is made of these 8 parts. Memorize them.
- [The Anatomy of an Agent-Ready Spec](https://pathmode.io/playbook/anatomy-of-agent-ready-spec.md): Foundation guide — Learn what makes a specification truly 'executable' by coding agents like Claude Code, Cursor, and Codex. This guide breaks down the key components.
- [The Product Constitution: Rules That Outlive a Single Spec](https://pathmode.io/playbook/product-constitution-rules.md): Foundation guide — The same constraint, retyped into thirty specs, eventually gets retyped wrong. The Constitution is where a rule lives once, with its reason, its blast radius, and its teeth, and rides along on every spec a connected agent receives.
- [What Is Intent Engineering?](https://pathmode.io/playbook/what-is-intent-engineering.md): Foundation guide — The 3-minute primer on intents, intent specs, and why 'intent engineering' is a discipline — not a buzzword.
- [Why Specs Fail: The 5 Anti-Patterns](https://pathmode.io/playbook/why-specs-fail.md): Foundation guide — Most specifications are destined for the trash can because they are written for humans to ignore, not for agents to execute. Here are the 5 traps to avoid.
- [From Support Ticket to Shipped Feature](https://pathmode.io/playbook/support-ticket-to-shipped-feature.md): Workflow guide — A worked example: one support ticket, followed through the agent's proposal, the product manager's review, the authorized build, and the merge. What each step records, and what it does not prove.
- [The Intent Spec as Alignment Artifact](https://pathmode.io/playbook/workflow-intent-spec-alignment.md): Workflow guide — Stop writing PRDs to align your team. An intent spec is shorter, testable, and moves the 'that's not what I meant' conversation to before the build, not after it.
- [Wire Pathmode Into Your Coding Agent](https://pathmode.io/playbook/wire-pathmode-into-your-coding-agent.md): Workflow guide — Set up local drafting or adopt a repository into a shared workspace. Attach the original request, apply the product manager's corrections and answers, and check revision authorization before implementation.
- [Your First Intent in Pathmode](https://pathmode.io/playbook/your-first-intent.md): Workflow guide — Bring a real request, review the coding agent's proposal, correct its interpretation, and authorize the revision your team will build.
- [Your First Spec in 10 Minutes](https://pathmode.io/playbook/first-spec-in-10-minutes.md): Workflow guide — You don't need fancy tools to start Intent Engineering. Open a text editor and write your first agent-ready spec — objective, outcomes, constraints, and the verification that proves it worked.
- [Evidence 101: The Discovery Play](https://pathmode.io/playbook/method-evidence-board-101.md): Method guide — Evidence is not a deliverable, it is a record of judgment. Learn how to capture user signals, review them one at a time, and use them as backing for exact claims in an Intent Spec.
- [From User Interview to Reviewed Evidence](https://pathmode.io/playbook/method-interview-to-evidence.md): Method guide — Your interview notes are full of signal. Learn how to turn raw conversations into structured signals you can review, and use as backing for the exact claims in a spec.
- [Prioritizing Your Intent Backlog](https://pathmode.io/playbook/method-prioritizing-intents.md): Method guide — Stop prioritizing by gut feel. Read the evidence to decide which problem to hand your agent next, and which to drop.
- [Verification Is a Feedback Loop, Not a Test List](https://pathmode.io/playbook/verification-feedback-loop.md): Method guide — The agent says "done" and the tests are green. A week later, checkout is quietly down 4%. A test list tells you the code runs. A feedback loop tells you the intent held. Here are the five checks that catch what the tests can't.
- [When the Build Contradicts the Spec](https://pathmode.io/playbook/when-the-build-contradicts-the-spec.md): Method guide — The agent built the feature and learned the spec was wrong. That correction usually dies in a PR comment, so the next agent rebuilds the same dead premise. A finding is how the build writes back, a proposal is how it names the exact fix, and a person accepting it is how the loop finally converges.
- [Spec Template: Login Flow](https://pathmode.io/playbook/spec-template-login-flow.md): Template — A ready-to-use intent.md for a standard email and password login flow. Copy it into your repository, adapt it to your stack, and preflight it before your agent builds.
- [Template: SaaS Onboarding Friction Patterns](https://pathmode.io/playbook/template-saas-onboarding.md): Template — A catalogue of the most common friction patterns in B2B SaaS onboarding, organized by stage. Use it as a checklist for what to look for in your own data.

## Use Cases

- [Anchor every outcome to user evidence](https://pathmode.io/use-cases/anchor-outcomes-to-evidence): Stop writing specs from imagination. Every claim in a Pathmode spec shows what backs it and who judged it, 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. Pathmode pulls out the quotes and tags each by type and severity, and they wait Unreviewed in the Inbox until you judge them. 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 signal with the quote, the context, and the source, sitting Unreviewed in the Evidence Inbox until you judge it.
- [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.
- [Draft your first intent in your repo, no account required](https://pathmode.io/use-cases/first-intent-in-your-repo): Install the keyless MCP server, describe what you're building, and get a preflighted intent.md in your project root. Assumptions labeled, blockers named, the Pathmode server runs locally. No account required.
- [Find the friction pattern across 5 user interviews](https://pathmode.io/use-cases/friction-pattern-across-interviews): Five interviews, five different stories, one pattern underneath. Capture the transcripts as signals, judge them one at a time, and the pattern shows up as the claim several independent sources back.
- [Generate a PR description from the linked IntentSpec](https://pathmode.io/use-cases/pr-description-from-spec): The agent that built the work already holds the spec it built against. Have it write the PR description from that spec: objective, outcomes, verification criteria, and edge cases, so reviewers see intent and tests in the same place.
- [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 the authorized proposal to your coding agent](https://pathmode.io/use-cases/handoff-spec-to-claude-code): Carry the product manager's corrections and revision authorization into Claude Code, Cursor, or Codex, then check the implementation against the agreed intent.
- [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, then proposes the exact correction for a person to accept. The loop converges, and a human closes it.
- [Let your agent pull intent live with the Pathmode MCP server](https://pathmode.io/use-cases/pull-live-intent-with-mcp): Stop pasting specs into the agent. With a connected workspace, Claude Code preflights the repo's intent.md, reads the full execution context, stops for open PM requests and for a person to authorize the exact revision, then hands the pull request back for a diff-graded verdict.
- [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.
- [Review and correct an agent's proposal before it builds](https://pathmode.io/use-cases/review-agent-proposal-before-build): A cancel-plan request never said when paid access ends, and the agent's proposal ends it immediately. Follow the requested answers, the agent's revision, and the separate authorization the next coding session builds from.
- [Run a deterministic preflight before your agent starts building](https://pathmode.io/use-cases/preflight-intent-before-agent): Six calibrated checks, no model call, no account. The preflight reads your intent.md, names the exact gates that block it, and the same spec always gets the same verdict. Repair happens one question at a time, then the agent starts.
- [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): Import a CSV export of recent tickets. Every row lands in the Evidence Inbox as an unreviewed signal, and you decide which ones become reviewed backing for an exact claim in your spec.
- [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. Capture the observations in Pathmode and walk out with a spec whose outcomes name the exact moments users struggled, and who judged that they count.
- [Turn an existing brief into a proposal you can review](https://pathmode.io/use-cases/paste-a-doc-to-first-intent): Bring the ticket, PRD excerpt, or rough notes you already have. Have your coding agent propose the change, then compare its interpretation with your original request in Pathmode.
- [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. Capture it all in Pathmode, judge it one signal at a time, and end with a spec whose claims say what backs them.
- [Verify the pull request against the spec it was built from](https://pathmode.io/use-cases/verify-pr-against-spec): Name the PR and Pathmode reads the diff from GitHub itself, grading every outcome, constraint, and edge case against what the code actually shows, with citations. A summary of your own work is weaker evidence, and the verdict says so.

## 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): Put an IntentSpec in intent.md beside the code. Pathmode's MCP server reads that repo-bound decision before Cursor or Claude Code starts building.
- [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): Put the product decision in intent.md before implementation: the objective, observable outcomes, hard constraints, edge cases, and concrete verification.
- [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): Use feedback as evidence for an agent-drafted IntentSpec, then have a human confirm the outcome and commit the authorized decision as intent.md.
- [Pathmode vs raw prompts (vibe coding)](https://pathmode.io/answers/pathmode-vs-raw-prompts-vibe-coding): Raw prompts optimize the current turn. A repo-bound IntentSpec preserves an authorized product decision across sessions, branches, agents, and review.
- [Pathmode vs spec-kit and BMAD](https://pathmode.io/answers/pathmode-vs-spec-kit-and-bmad): Spec Kit and BMAD provide broad agent workflows. Pathmode focuses on a portable product-decision artifact, deterministic readiness, and the evidence and review behind it.
- [Pathmode vs writing PRDs by hand](https://pathmode.io/answers/pathmode-vs-writing-prds-by-hand): A PRD explains a product decision to people. intent.md gives the repository a compact, versioned decision an AI coding agent can repeatedly build and verify against.
- [What belongs in a spec before engineering starts?](https://pathmode.io/answers/what-belongs-in-a-spec-before-engineering-starts): Before implementation, clear six readiness gates: a meaningful title, specific objective, testable outcomes, hard constraints, edge cases, and concrete verification.
- [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 a reviewed intent.md in the repository: objective, observable outcomes, hard constraints, edge cases, scope where needed, and concrete verification.

## Optional

- **Company**: Pathmode Oy, Finland. Founded 2026 by Janne Lammi. Not the same company as Patternry, the founder's earlier product. About: https://pathmode.io/about
- **Category**: SaaS Platform / Developer Tools
- **Pricing**: Local tools and a Free workspace are free. Pro and Team are billed per editor seat: https://pathmode.io/pricing
- **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 Capture: Import support tickets and research transcripts, paste text, or let an agent post signals through the API. Everything captured lands Unreviewed.
- Trust Tiers: Every signal (friction, quote, observation, metric, request) carries exactly one tier: backing, unreviewed, or assumption.
- Claim Backing: Inside an IntentSpec, every objective, outcome, constraint, and edge case shows Backed, Unreviewed, Assumption, or No evidence, with the reviewer and time behind each one.
- Human Review Boundary: Agents can capture signals. Only a signed-in person can review a signal and use it as backing for an exact claim.
- 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.