Ship faster. With governance.
Deliver production-worthy code with Claude Code Codex Gemini CLI Open Claude
With domain context, spec discipline, Jira/Linear integration and more. Every AI call leaves a signed receipt reviewers and auditors can trace.
$29/seat · first 5 seats free for 12 months · works with any AI agent
The agent doesn't know your bounded contexts, your ADRs, your conventions, or your terminology. So it produces code that compiles but doesn't fit. You spend the saved time rewriting.
"Build the X feature" is the prompt. The agent guesses at requirements. Three days later you discover the missing edge case nobody wrote down.
The agent has no idea this work corresponds to JIRA-4128. So traceability dies. Reviewers can't tell why the change was made. PRs lack context.
Every artifact you add to the repo gives the AI runtime better understanding. Code quality compounds as context layers up — and it all lives in git. Each tier produces stronger audit evidence too: by L5, every decision has a reviewable rationale on file.
Six dimensions, one grade. Each fix maps to a skill that closes the gap.
/fp-context-score alias: /fp-repo-quality Top-3 ranked fixes, each tied to a skill. Read-only.
fastpace context-score alias: fastpace repo-quality Deterministic, no LLM call. Drop into CI.
--explain --json --debug ⚡ fastpace repo quality · grade B (74) ✓ doc inventory 88 A (7/9 files present, glossary thin) ✓ why-density 71 B (18% of comments explain why; target 25%) ! decision links 42 D (0.4 refs/kLOC — sparse) ✓ docstring richness 79 B (61/77 exports rich) ! vocabulary 55 C (11/20 top terms in glossary) ✓ freshness 92 A weighted total: 74 / 100 · grade B top-3 fixes (impact / effort) 1 ▸ +6 pts · /fp-teach glossary — define 9 missing top-terms (~20 min) 2 ▸ +5 pts · /fp-write-adr — capture 3 large untracked calls (~45 min) 3 ▸ +3 pts · docstring sweep — src/billing/ · 9 of 11 exports bare (~30 min)
No more shuffling artifacts between Confluence, Jira, Slack, slide decks, GRC tools, and audit binders. Every team — from product to compliance — works against the same git-backed source of truth. Committable, reviewable, audit-ready.
/fp-write-prd fastpace ui /fp-prd-to-erd /fp-write-adr /fp-new-feature /fp-review-pr /fp-remember /fp-status-report fastpace ui /fp-write-adr /fp-extract-learnings /fp-review-pr /fp-write-adr fastpace why /fp-write-adr /fp-extract-learnings audit.log /fp-search fastpace why fastpace snapshot Spec-driven dev usually stops at the spec. fastpace doesn't. PRDs become engineering designs (ERDs); ERDs become execution plans of waves, epics, and stories — grounded in your architecture, decisions, and patterns. Every artifact is a reviewable file in your repo, not a ticket in a separate tool. Tab through the steps.
Architectural pattern The lifecycle implements Plan-Then-Execute — tool calls are planned (PRD → ERD → execution-plan) before any agent is exposed to untrusted content during implementation. Specialist subagents (planner, reviewer, erd-guru) operate as Dual-LLM-shaped: a privileged coordinator orchestrates scoped specialists in fresh contexts.
PRD.md· ERD.md· execution-plan.json· watch-cards/· audit.log· status-reports/
Most PRDs get written in a vacuum — assumptions about what exists, vague success metrics,
no awareness of conflicting prior decisions. /fp-write-prd
runs a structured interview, then cross-references every
answer against the repo before writing the artifact.
/fp-write-prd credit-card-validation fastpace/docs/prd/credit-card-validation.md credit-card-validation.md · status draft /fp-prd-to-erd reads the PRD and your fastpace/context/.
The ERD that comes out already knows your decisions, your patterns, your domain terms.
decisions.md architecture.md POST /api/cart/submit · Express middleware chain.patterns.md withRetry(fn, { tries: 3, base: 200 })glossary.md POST /api/cart/submit pre-validates with validateCard(pan, month, year, cvc).
from architecture.md withRetry(fn, { tries: 3, base: 200 }).
from patterns.md cc_client_validation. Default off./fp-prd-to-erd credit-card-validationfastpace/docs/erd/credit-card-validation.md · 4 context files consulted /fp-erd-to-execplan breaks an ERD into waves, epics, and stories — but
sized by your architecture, patterns, learnings, and prior plans. Not generic estimates.
POST /api/cart/submit with validateCard(…)architecture.md @core/http for retries.patterns.md learnings.md exec-plans/prior.json /fp-erd-to-execplan credit-card-validationfastpace/exec-plans/credit-card-validation.json · opens in fastpace ui to assign names & track progressDomain context and spec is the new code Lock in the what and the why before any code gets written.
1 ⚡ planning problem: pasting card numbers is error-prone user: logged-in shoppers at checkout goal: reject invalid cards before submit ✓ approve planning? yes
2 ⚡ spec drafting fastpace/docs/erd/cc-validation.md… • contract: validateCard(pan, month, year, cvc) • data model: no schema change • security: no PAN logged; CVC never stored • acceptance: luhn pass, expiry future, cvc 3-4 digits ✓ approve spec? yes
3 ⚡ write tests
writing 14 failing tests in tests/cards.test.ts… ◐ phase 4 · implementing 0%
↳ state saved · watch-cards/credit-card-validation.json watch-cards/ — resume any time Start working on a feature. Close your laptop. Come back tomorrow. State is saved after every phase — branch name, base branch, risk class, completed phases — so any AI or any engineer can reconstruct the full context in flight.
fastpace/watch-cards/<feature>.jsonfastpace reads your PRDs, ERDs, execution plans, git history, and in-flight features — then generates a structured report for leadership in seconds. Pick a period, an audience, the sections you want, and hit one button.
Configure the period and audience, pick what to include, then generate.
docs/status-reports/
Reports save as committable markdown in fastpace/docs/status-reports/ —
the team gets a permanent version-controlled record.
Skills are slash commands your AI agent runs against your repo.
Not generic prompts — they're scoped to a job, read your domain
context, and produce structured output. Drop your own in
.claude/skills/ and they show up immediately.
/fp-discover Bootstrap domain context for a new repo. 5–10 minutes; outputs L1–L2. /fp-write-prd Interactive PRD authoring. Agent drafts; you redline. /fp-prd-to-erd Reads the PRD, produces entities, relationships, decisions, edge cases. /fp-erd-to-execplan Sizes the work as waves → epics → stories with hour estimates. /fp-write-adr Captures an architectural decision with the context that produced it. Adds to L5. /fp-context-score Grade your repo's domain context (0–100) across coverage, freshness, vocabulary, decisions, patterns, learnings. /fp-review Run code-reviewer agent against the current diff. Catches "contradicts ADR-007" issues. /fp-refactor Suggests refactors aligned to your patterns + ADRs. Doesn't propose generic improvements. /fp-test-gen Generates tests against your existing test patterns. Respects your conventions. /fp-pull-issue Pulls a Jira / Linear issue into AI context. Body, comments, linked PRs. /fp-link-commit Annotates a commit with its source ticket ID + AI summary. Comments back on the issue. /fp-pr-summary Generates the PR description from the run manifests + ticket context. No more "wip" PRs. /fp-status One-liner status: AI commits today, reliability, context score, in-flight stories. /fp-explain Why was this AI line of code generated? Walks back through the manifest + prompt hash. /fp-bisect When AI-generated code broke something, find which run manifest produced the regression. /fp-learnings Captures a lesson learned. Adds to fastpace/context/learnings.md (L5). /fp-context-refresh Walks fastpace/context/ for stale references, missing patterns, terminology drift. /fp-doctor Diagnoses your install: identity, manifest, hooks, audit chain. /fp-verify Walks the audit chain; reports tamper status. Exit 0 = pass. Most "AI for code" tools have a single chat agent. fastpace ships seven specialists, each with explicit scope (allowed tools, paths, command patterns) and a daily job to do.
/onboarder /architect /code-reviewer /security-reviewer /evidence-curator /context-curator /debugger Real backlog flows into agent context; AI commits flow back to the issue. Traceability survives the loop.
Stories pulled into AI context. Generated code linked back via commit trailers + auto-comments on the issue.
Issue → context flow + AI commit ↔ issue linking. Status transitions configurable per team.
Pages cached as L2 context — architecture diagrams, glossaries, runbooks. Updated on-demand.
PRDs and design docs already in Docs become L3 context without copy-paste.
Provenance trailers on every commit. PR descriptions generated from manifests + tickets. Audit-gate workflow shipped.
Same model as GitHub. Self-hosted GitLab supported.
PR + pipeline context. Reuses the Atlassian OAuth surface.
F3.10 events on AI activity, audit-chain breaks, fleet maturity drops, evidence-request transitions.
fastpace doesn't replace Cursor, Copilot, Claude Code, or Cline. It makes them better. Same agent, dramatically better output. Honest cost-stack math:
Cursor types fast. fastpace makes the typing fit your codebase. $20 + $29 = $49/dev for code reviewers approve first time.
Copilot has no domain context, no spec workflow, no Jira sync. fastpace adds all three.
Native pairing. Skills, agents, hooks all install via fastpace init directly into .claude/.
Drop-in. Cheapest path to spec-driven AI coding — free runtime + $29/dev for the coordination layer.
Hooks + provenance trailers. Run manifests captured per call.
Runtime-agnostic. Same governance, any model provider. Multi-cloud shops get one governance surface.
Test-drive on day one. Turn on phases as the team gets comfortable — and watch the audit signal compound alongside.
Test-drive, explore, learn.
Plan and review with fastpace.
Full lifecycle, audited.
The trust edition leads with this; the build edition uses the same trail for day-to-day reviewer leverage. Any reviewer can trace any line of merged code back to the AI call that produced it. Bisect any incident; explain any change in code review.
fastpace/manifests/.fastpace/audit.log. Tampering breaks the chain. fastpace verify validates.Free of vendor dependence Committed to git. Works with any LLM runtime.
Business rules, ADRs, patterns, lessons — all plain markdown. Any AI runtime rehydrates instantly.
git cloneClick any file on the right to preview what the AI sees.
/fp-remember, or let it grow
organically as you use fastpace.
Skills sit on top of three primitives that ship with fastpace: agents (subagents that handle specialist work), hooks (local interceptors on every tool call), and guardrails (project-wide policies). Tab through to see each.
Each agent runs in a fresh context with a tight scope and minimal tool access.
plannerTurns a goal into a numbered plan.
reviewerReviews diffs vs. architecture and decisions.
prd-guruInterviews you and drafts a PRD.
erd-guruTranslates PRDs into ERDs.
execution-plannerWaves → epics → stories.
doc-writerUpdates docs without noise.
Pre-use hooks block the call before it runs. Post-use hooks observe and log. Each hook is also tagged by intent — audit & safety or velocity — so the compliance story stays legible.
secret-scanner audit & safety Blocks writes containing AWS keys, tokens, private keys, or Stripe secrets.
push-guard audit & safety Refuses force-push to protected branches. Refuses auto-push when disabled.
dangerous-command-guard audit & safety Blocks rm -rf /, git reset --hard, curl | sh, and a dozen other footguns.
commit-validator velocity Enforces conventional commit format (configurable).
branch-guard audit & safety Prevents commits directly to main/master or other protected branches.
dependency-alert audit & safety Alerts on new npm deps outside your approved scopes. Block or warn.
audit-logger audit & safety Appends every tool use to fastpace/audit.log — hash-chained for tamper evidence.
Configured in fastpace.config.yaml. Safe defaults out of the box.
fastpace will never silently weaken a guardrail — every change is approved by you and logged to fastpace/audit.log.
Each repo gets its own 100% local UI.
Run fastpace ui inside any repo — a Node HTTP server boots on
localhost and opens a dashboard scoped to that project. Browse
the audit log, ADR ledger, decisions, and exception queue without leaving
the local UI. Zero cloud. Zero telemetry. Your code never leaves the machine.
Every feature started with /fp-new-feature persists to fastpace/watch-cards/.
Today — checkout-svc · L4
credit-card-validation — it's on phase implement.git commit2msrc/config.ts14mF4.12 — auto-updates as your team works. Local reads real-time; fleet pushes every 5 min via F3.11 audit replication.
Project metadata and guardrails · fastpace/fastpace.config.yaml
Pre-use hooks block; post-use hooks observe and log.
Who signs off on each phase of /fp-new-feature.
The team brain — plain markdown, committed to git.
Checkout service — layered REST with api/cart owning submit. Postgres 15 · Redis for sessions.
POST /api/cart/submit · POST /api/cart/validate
Six-dimension domain-context score. Locally computed.
/fp-teach glossarydefine 9 missing top-terms/fp-write-adrcapture 3 large untracked callsProduct requirements. Author with /fp-write-prd.
Engineering designs. Generate with /fp-prd-to-erd.
Architectural decisions · append-only history.
4×4 structure, grounded in artifacts.
Waves → epics → stories · critical path computed.
Sync execution plans to Jira or Linear. Secrets stay in fastpace/.integrations.local.json (gitignored).
ENG-100 Sync → Feeds /fp-status-report.
Computed from this repo's git history. No cloud calls.
Every entry lives in fastpace/context/learnings.md.
feat/rate-limitsWhat's installed, what's expected.
.claude/skills/.claude/agents/settings.jsonfastpace update to refreshF0.1 — Ed25519. Generated locally. Private key at ~/.fastpace/identity/private.pem with mode 0o600.
Tamper-evident by construction. fastpace verify walks the chain in seconds.
$ fastpace verify [ok] chain integrity: 1247 entries signatures verified 1247 unsigned entries 0 last entry seq 1246 ts 2026-04-30T14:21:08Z tool · phase Read · PostToolUse summary {"file_path":"src/auth/session.ts","agent":"reviewer"} entry hash a14b2c8f3d9e7c2a1b4f...
F1.1 — one signed receipt per AI tool call. Hashes only — never plaintext.
F2.1 — measure when AI is wrong. Every human edit to AI-authored code is a correction event.
F2.4 — CycloneDX-AI flavored. Goes into a regulated software supply chain alongside SBOMs.
F2.3 — every AI commit carries Fp-* trailers binding it to a manifest, agent, prompt hash. Five-layer verify in seconds.
$ fastpace verify-provenance HEAD [ok] commit a8f3c2b9 feat(billing): add idempotency keys [ok] trailers Fp-Run-Manifest, AI-Model, AI-Agent, AI-Prompt-Hash [ok] manifest 2026-04-30T14-21-08Z-a3b8c1.json [ok] signature verified against install fingerprint [ok] audit-link manifest_id present in audit chain at seq 1198 [ok] explanation retrieval context + approval chain present 5/5 layers verified.
F1.13 — fleet view across every repo on the org dashboard. Pulls signed audit summaries every 5 min via F3.11 replication; signature-verified at ingest using the F1.14 SAML envelope.
F1.13 — @fastpace-ai/org-dashboard standalone binary. Self-hosted aggregator: ingests signed audit shards from every install, verifies them against the org SAML envelope, computes per-repo / per-team / per-org rollups. No cloud.
$ fastpace-org-dashboard --port 8443 --store ./fp-org-store [ok] ingest endpoint POST /api/org/ingest [ok] rollup endpoint GET /api/org/rollup [ok] maturity endpoint GET /api/org/maturity [ok] baselines endpoint GET /api/org/baselines [ok] SAML envelope verified · 14 installs · 7 teams [ok] last ingest 2026-05-01T17:08:42Z · checkout-svc · 12 entries [ok] serving on https://0.0.0.0:8443
{
"ok": true,
"repo_count": 14,
"maturity": {
"aggregate": 68,
"reporting_repos": 14,
"total_repos": 14,
"status": "measured",
"sub_scores": [
{ "fId": "F4.1", "label": "Project Setup", "pct": 84, "reporting_repos": 14 },
{ "fId": "F4.2", "label": "Spec-Driven Development", "pct": 71, "reporting_repos": 14 },
{ "fId": "F4.3", "label": "Context Management", "pct": 62, "reporting_repos": 14 },
{ "fId": "F4.5", "label": "Harness Engineering", "pct": 76, "reporting_repos": 14 }
]
}
} F2.5 — separate Astro site at trust.fastpace.net built from your signed audit summaries. CISOs self-serve; you stay out of the email loop. Per-customer publication is consent-gated.
fastpace/ bundled into a tarball, delivered via signed URL. Re-uses F1.14 RBAC.This view is part of the live fastpace ui. Click around the sidebar to see the views included in this demo, or run fastpace ui in your own repo to see live data.
…
Every fastpace install ships a local dashboard that runs entirely on your employees' machine — no SaaS in the data path. Pick a persona above to walk only the views that matter to your role.
@fastpace-ai/org-dashboard is a thin Node HTTP server that
ingests signed audit summaries from every fastpace install, verifies
them against your SAML envelope, and rolls them up by repo / team /
org. Deploy it inside your VPC; fastpace.net never sees the data.
Aggregated from signed shards. Each install pushes via F3.11 every 5 min; the dashboard polls + recomputes on ingest.
checkout-svc · 12 audit entries · maturity Δ +138sbilling-api · 7 audit entries · maturity steady2macme-web · 21 audit entries · 1 new exception5mnotifications · circuit breaker tripped on doc-writer14mSortable. Click a repo to drill into its per-shard history, exception queue, and audit-chain offset. (Not interactive in demo.)
| Repo | Team | Maturity | Reliability | AI commits 30d | Last shard |
|---|---|---|---|---|---|
billing-api | payments | 81 | 94 | 312 | 1m |
checkout-svc | payments | 72 | 91 | 284 | 38s |
acme-web | growth | 64 | 87 | 421 | 5m |
notifications | platform | 55 | 72 | 198 | 14m |
internal-tools | infra | 42 | — | 54 | 2h |
| + 9 more · scroll or paginate in live UI | |||||
Team rollups average per-repo maturity weighted by AI activity. Provisioned via SCIM from your IdP.
| Team | Repos | Devs | Maturity | Reliability | Trend (30d) |
|---|---|---|---|---|---|
| payments | 2 | 11 | 76 | 92 | ↑ +4 |
| growth | 3 | 9 | 63 | 87 | ↑ +2 |
| platform | 4 | 14 | 58 | 74 | → 0 |
| infra | 2 | 6 | 44 | — | ↓ -3 |
| data | 1 | 8 | 61 | 89 | ↑ +5 |
| mobile | 1 | 7 | 71 | 90 | ↑ +1 |
| internal | 1 | 7 | 38 | — | ↓ -1 |
Every shard arrives signed. Verify failure → reject without ingest. Last 24h:
[2026-05-01T17:08:42Z] ingest checkout-svc sig ok entries=12 Δ-maturity=+1 [2026-05-01T17:06:11Z] ingest billing-api sig ok entries=7 Δ-maturity= 0 [2026-05-01T17:03:55Z] ingest acme-web sig ok entries=21 Δ-maturity=-1 [2026-05-01T16:54:30Z] ingest notifications sig ok entries=4 Δ-maturity= 0 [2026-05-01T16:54:30Z] alert notifications circuit_breaker tripped (doc-writer +37%) [2026-05-01T16:48:12Z] reject rogue-clone sig MISMATCH envelope=unknown_install [2026-05-01T16:42:06Z] ingest data-pipeline sig ok entries=15 Δ-maturity=+2 [2026-05-01T16:33:51Z] ingest mobile-ios sig ok entries=9 Δ-maturity=+1 [2026-05-01T16:21:18Z] ingest internal-tools sig ok entries=2 Δ-maturity=-1 …
F1.3 — per-agent behavioral baseline averaged across the fleet, weighted by sample size. Repos with too few samples fall back to fleet baseline.
| Agent | Avg edits / session | Avg duration (s) | Avg tokens | Samples |
|---|---|---|---|---|
planner | 0 (read-only) | 184 | 89,400 | 3,124 |
reviewer | 3.2 | 222 | 74,800 | 2,891 |
prd-guru | 1.1 | 318 | 52,300 | 1,408 |
erd-guru | 2.7 | 402 | 68,100 | 1,202 |
execution-planner | 1.8 | 271 | 71,400 | 1,184 |
doc-writer | 4.4 | 156 | 32,800 | 1,932 |
onboarder | 0.6 | 112 | 21,500 | 614 |
Read-only HTTP surface for the dashboard. Same shape as the local UI's /api/*; consumers just point at the org port instead of :7777.
| Method | Path | Returns | Auth |
|---|---|---|---|
POST | /api/org/ingest | ack of received shard | signed envelope |
GET | /api/org/rollup | fleet rollup + per-repo | SAML session |
GET | /api/org/maturity | F4.12 aggregate + sub-scores | SAML session |
GET | /api/org/installs | roster of every reporting install | SAML session |
GET | /api/org/baselines | per-agent fleet baselines | SAML session |
GET | /api/org/summary | single-repo build (dev) | local only |
POST | /api/auth/saml | verify envelope, return role | none |
Plug your IdP's public key in via env. Auto-provisioning via SCIM 2.0; role grants enforced at every endpoint.
Run it locally now: npm install -g @fastpace-ai/org-dashboard
then PORT=4444 fastpace-org. Same surface as this mockup,
reading from a sample store. Production deploys live in your VPC —
we never see the data plane.
Nine industry-standard competencies — Project Setup, Spec-Driven Development, Context Management, Testing, Harness, Architectural Guardrails, Review Maturity, AI SDLC, Prompt Engineering — rolled into one 0–100 score. Auto-updated as your team works: local reads are real-time, fleet rollups push every 5 min, webhooks fire instantly.
The audit plane is the metrics plane. Same primitives that prove
compliance to a CISO produce the velocity metric a CTO puts on a board
slide. fastpace maturity from the CLI, Maturity view
at the top of the local UI sidebar, fleet rollup on the org dashboard, opt-in
publication on trust.fastpace.net.
All 9 sub-scores measured in v0.30 — F4.4 test parity, F4.6 ADR drift,
F4.7 review maturity, F4.8 DORA-by-attribution, and F4.9 prompt effectiveness
shipped this sprint (see packages/fp/assets/docs/ai-native-maturity.md
for the rubric).
Before pointing it at your real repo, take fastpace for a spin in a throwaway directory. Five minutes, nothing touched outside the sandbox — just enough to feel the flow and decide if it's for you. The hash-chained audit log is on from minute one, even in the sandbox.
--sample writes a tiny demo PRD, ERD, and watch card so the dashboard isn't empty on first launch.
Every file fastpace touches gets recorded in a signed install-manifest. Uninstall reads that manifest and removes only what fastpace itself placed — your own hooks, agents, skills, and settings entries are provably untouched. Pick the scopes you want included; the command composes live below.
fastpace uninstall --all — shorthand for --repo --settings --fastpace-dir--everything / --nuke — shorthand for --all --user-identity (full back-out, double-confirm)--keep-modified — never delete files whose content diverges from what fastpace installed (default under --force)--force-delete-modified — delete modified files anyway (use sparingly)--skip-manifest-verify — proceed even if the manifest signature is invalid (recovery for tampering / corruption). Combine with --dry-run first to inspect. Heads up on --user-identity: this destroys the
F0.1 Ed25519 keypair. Past audit logs signed by that key remain verifiable
only against the archived public key. Run
fastpace identity show --json > identity.json first if you
want a copy for later forensic verification.
Nothing about fastpace phones home. Removing the CLI removes the binary; no server-side state to clean up. The licensing service auto-prunes inactive install_ids after 90 days, on our side — no action needed from you.
Free for solo devs. $29/seat/mo for teams (first 5 seats free for 12 months). Works with the AI agent you already pay for.
