An agent will happily build from a spec that can't be verified, has no constraints, and states its outcome as a vibe. You find out three hours of compute later. The preflight is the gate before that: a deterministic readiness check that scores the spec against six calibrated gates and names the exact blockers, before a line of code changes. No model call, no account, no API key. The same spec always gets the same verdict.
The input
An intent.md in your repo. Rough is fine; the point of the preflight is to tell you precisely where it's rough. If you don't have one yet, the compile conversation drafts it first.
The flow
1. Install once, keyless. In Claude Code: /plugin marketplace add pathmodeio/claude-plugin, then /plugin install pathmode@pathmode, then /preflight. In any other MCP client, npx @pathmode/mcp-server with no key runs in local mode and exposes check_intent_readiness. The local Pathmode server makes no network requests; your coding agent may send context to its own model provider. There is also a browser version: paste a spec at preflight.pathmode.io.
2. The gate runs six checks. Title, objective, outcomes, constraints, edge cases, verification. Each is a pure function calibrated against a labeled corpus of real specs, not a model's opinion. That's what makes the verdict worth gating on: it's reproducible, and you can enforce it in CI.
3. A failing verdict names the blockers. Not "this spec could be stronger" but "outcomes are not observable, verification has no fastest check." Each blocker is a specific field with a specific defect.
4. Repair one question at a time. This is where the conversation earns its place: for each named blocker, the agent asks one targeted question, folds your answer into the spec, and re-runs the gate. Every save stamps the current verdict into the file's frontmatter, so the spec carries its own readiness state.
5. Review before handing off. A passing verdict checks the spec’s readiness, not whether the product decision is right. Resolve open choices explicitly. For connected team work, obtain authorization for the current revision before implementation; a passing preflight does not grant it.
The output
- A verdict you can gate on: deterministic, named blockers, same input same output
- A repaired
intent.mdin your repo, round-trippable, with the verdict in its frontmatter - An agent run that starts grounded, because the gaps were closed before the build, not discovered during it
Why this beats asking the model "is this spec ready?"
A model's answer changes run to run, flatters what you wrote, and can't be enforced anywhere. The preflight is the opposite kind of thing: calibrated pure functions with a stable contract. You can disagree with a gate, but you can't get a different answer by asking again nicely. That's what lets a team (or a CI job) treat readiness as a real gate instead of a mood.
Try it yourself
/plugin marketplace add pathmodeio/claude-pluginthen/plugin install pathmode@pathmodein Claude Code- Run
/preflighton the repo'sintent.md(or paste one at preflight.pathmode.io) - Answer the repair questions until the verdict flips
- Review the decisions and, for connected work, authorize the revision before handing it to the agent
Related
Check your spec before the next build.
Run the six readiness checks and see which gaps still need a decision.
Run a preflight