Introduction
Waypoint is a spec-driven development framework. You author a project's intent as a graph of small, schema-validated documents called artifacts, and Waypoint then mechanically and semantically proves that those artifacts are mutually coherent and that the code conforms to them. Instead of one giant prompt and a wall of generated code you have to trust on vibes, you get a dependency graph of deliverables where every node has a contract and every edge has a validator.
A declarative, provider-agnostic, schema-driven framework for defining, validating, executing, and redelivering project deliverables in a workflow DAG.
The problem it solves
AI coding tools are great at getting you started and fall short before they follow through. The first 80% — scaffolding, a working demo, a plausible-looking feature — is easy. The hard part, the part LLMs reliably drop, is keeping the whole project coherent as it evolves. Unstructured output accrues architectural debt and turns into vibe-coded spaghetti that doesn't scale, and re-prompting the entire codebase on every change burns tokens rebuilding the world.
Waypoint attacks this from a different angle. Because intent lives in a structured graph rather than in prose and generated source, Waypoint always knows the blast radius of a change: edit one artifact, and it can tell you exactly which downstream artifacts and which slices of code are now in question — and re-validate only those.
Waypoint is additive, not substitutive. You keep your existing setup — Cursor, Claude Code, Copilot — and add Waypoint on top. It doesn't proxy your LLM or host your IDE; it gives the tools you already use a checkable definition of "correct." See Integrations.
The core pieces at a glance
Artifacts
Artifacts are the structured documents that capture every project deliverable — a persona, a requirement, a bounded context, a feature, a flow. They're pure data validated against a JSON Schema: no logic, just the contract for each kind of deliverable. They start from a single human-authored idea seed and fan out from there. Read Artifacts & the DAG for the full type catalog.
The workflow DAG (metagraph)
The artifact types, the dependency edges between them, and the validation rules over those edges are declared together in a metagraph — a declarative graph embedded in the CLI. The dependency edges encode generation order (you author intent top-down, each level a function of the levels above it), and the validation rules are coherence constraints that guard each edge. One workflow describes one domain; the software workflow currently defines dozens of artifact types across five sections — Discovery, Requirements, Architecture, Interface, and Features. See The Workflow.
waypoint validate and the proof certificate
Running waypoint validate checks that every artifact passes schema validation, that every cross-reference resolves, and that the artifact set is coherent per the embedded rules. Crucially, it doesn't just return a pass/fail — it emits a proof certificate (waypoint.proof.json) that records why the verdict holds: which inputs were examined, which rules applied, and what kind of evidence each conclusion rests on. That certificate is the thing that makes a verdict trustworthy rather than opaque. See Validation.
Who it's for
Waypoint is for builders who want more than vibe coding — solo developers and teams who want their AI tokens spent on writing clean code that scales, not on mopping up spaghetti. It's especially valuable if you run AI agents for long stretches: the proof certificate gives an agent an external, machine-checkable answer key to anchor against, so it can run longer and more confidently without a human watching every step. That argument is the subject of Why Waypoint.
Next steps
- Why Waypoint — the motivation: why epistemic validation unlocks longer, more confident unsupervised agentic coding.
- Getting Started — install Waypoint, sign in, authenticate the CLI, and create your first project.
- Concepts — the mechanism in depth: artifacts and the DAG, validation, and the workflow.