We built Pathmode because the person running the coding agent isn’t always the person who should decide how the product behaves.

“Build a duck.” ✅ Is duck ✅ Stands up ✅ No parts left over “It was supposed to be a pirate.” New ticket: make duck eligible for maritime crime. This is why we're building Pathmode. Settle the missing decision before the build. pathmode.io

“Add a cancel button” leaves a product decision unanswered: Does access end immediately, or when the paid period ends? Pathmode brings that choice back to your team, and carries the answer into the coding agent’s next session. The agent proposes. You decide.

New in Pathmode: Your coding agent has a plan. Does it reflect what you meant? We are building Pathmode so product owners can review the proposal, resolve missing decisions, and approve what gets built. The agent proposes. You decide. Findings come back to you.

Google’s new whitepaper on vibe coding makes a strong case: as AI accelerates implementation, specification, verification, and human judgment become more important. That’s the part I keep coming back to: judgment. We’re getting better at telling agents how to work. Repository instructions, tools, guardrails, tests, evals. But there’s another set of questions: Why is this the right problem to solve? Which customer evidence supports it? What tradeoff did we make? Who approved the direction? What would make us reconsider? A test can verify that a payment retry works. It can’t establish that payment retries were the reason customers abandoned checkout. You can pass every check and still build the wrong thing. The paper argues that intent is becoming the interface for software development. I agree. But intent needs to carry more than a description of the desired implementation. It needs the reasoning behind the work—and a way to change that reasoning when implementation or customer behavior reveals something new. That’s what we’re building with Pathmode: a connected record from evidence to intent, through implementation, and back to outcomes. Our starting point is simple: an intent.md alongside your code. What problem you’re solving, why it matters, what success looks like, and the boundaries an agent must respect. The bigger opportunity is keeping that intent alive: recording decisions, bringing implementation findings back into refinement, and checking whether what shipped actually helped. Faster coding makes it cheaper to build an idea. We still need to know which ideas deserve to become software. kaggle.com/whitepaper-the-ne…

Most product loops close on the wrong node. Signals from Slack, calls and analytics pile up as context. Agents turn the pile into PRDs, prototypes and PRs. Something ships. Then comes the arrow everyone draws dotted: shipped back to context. It stays dotted because the loop was never anchored to a decision. Context is what we know. It says nothing about what we decided it means, who confirmed that, or what outcome we expected. We put the decision in the middle instead. -Signals become evidence with a source and a date. -Evidence anchors the claims in an intent that lives in the repo, next to the code. -A person confirms, rejects or amends each claim, by name. -The agent builds only once the intent is ready, and the PR is checked against it. -The shipped outcome is measured against the outcome the intent promised. Then the outcome becomes evidence, and stale evidence reopens the intent. That arrow is solid. Context isn't judgment. A loop that only remembers what happened can't tell you whether it worked.

Anthropic’s AI-native SDLC playbook maps the execution loop. I wrote the companion I think product teams need: the loop that turns evidence into decisions, intent, and outcome learning. Sense → Decide → Specify → Learn pathmode.io/playbook/product…

Over the past few weeks, we rebuilt Pathmode around a repo-native center of gravity. intent.md is now the authority. Agents create, challenge, hand off and verify it where the work happens. The repo gets the decision. Pathmode keeps the evidence and judgment behind it. pathmode.io/

Ask a model if your spec is ready and it says yes, then builds its best guess. Preflight gives the other answer. Six gates, pass or fail, reason named. No model grades it, so the verdict is the same every time. Free in Claude Code. preflight.pathmode.io/?s=x

A spec that can't say why is just an opinion. Your ticket says what to build. AGENTS.md says how the repo is shaped. Neither tells your agent why an outcome exists, so "why" collapses into "because someone said so." That is how scope creeps and agents drift. I rewrote intentspec.org around that gap. IntentSpec is an open format. Markdown with YAML frontmatter: objective, outcomes, constraints, scope, edge cases, verification. The field I care about most is anchors. Each piece of evidence names the outcomes and edge cases it justifies, so the agent gets concrete criteria and the reviewer gets the why. One file, not two. New on the site: A validator in the browser. Two verdicts on one paste: whether the schema shape is valid, and whether an agent could actually build from it. Six gates, exact blockers named. No signup, nothing leaves the page. A GitHub Action, so a malformed spec never reaches main. v1.2 also fails an anchor pointing at an outcome that doesn't exist. uses: JanneL/validate-intentspec-action@v1 Both run the same published conformance corpus: intentspec.org/anchors-corpu… Two implementations of one check used to be held together by a comment asking future readers to keep them in sync. Now a test goes red instead. Works with Claude Code, Cursor, Windsurf, Copilot, Aider. One rule line points your agent at intent.md. Open format. You don't need Pathmode to use it. intentspec.org If you run the validator on a spec of your own, tell me whether the verdict matches your judgment. That's the part I still want to be wrong about.

Agents get a gate at every stage except the one that decides what they build. Plan mode reads before it edits. Hooks allow, ask, or block. Tests run before a human sees the diff. Branch protection records approval. Production deploys need named authorization. The intent that started all of it gets read once and passed along. Pathmode Preflight is the missing check. Six deterministic gates, a named verdict, and one repair question per failure. No model call, no signup, no API key. It checks the title, objective, outcomes, constraints, edge cases, and verification. The same spec gets the same verdict every time, and a failure names exactly what to fix. The text gates are calibrated against 98 labeled examples and regression-guarded in CI. The verdict stays with the work. When Pathmode writes intent.md, the frontmatter carries readiness: passed 6/6. When checks fail, it names them. The gate reports. You decide. A failing verdict never blocks the save. See it run on a failing spec and its repair: preflight.pathmode.io Run it on your own intent in Claude Code: /plugin marketplace add pathmodeio/claude-plugin /plugin install pathmode@pathmode then /preflight

In 2020 Paul Adams wrote the definitive piece on product judgment. How you build it: talk to hundreds of customers. 500 interviews at one company, 800 at another.He's still right. He's also describing a world that's gone. A 2026 NBER study: 100,000+ devs on AI coding tools. Commits +180%. Usage of everything they shipped: flat.More code, more releases, the same number of people who cared. When building gets cheap, choosing gets expensive. An agent isn't in the room. It can't read your instincts. Hand it a thin brief and it executes exactly as wrong as the brief was thin. An agent with perfect context and no judgment builds the wrong thing, fast. Context isn't judgment. For 30 years, judgment could stay in your head and leak out in standups. That was a feature. Now it's a bug. Tacit judgment doesn't delegate to a machine. So judgment stops being something you have. It's something you produce: the why (evidence), the what (an outcome), the fence (constraints).Building got cheap. Judgment is the job. Don't leave it in your head. pathmode.io/blog/product-jud…