Trust governance Platform team in a box Build production-ready
⚡ The four primitives · `sync` · `welcome` · `cost` · `policy.yaml` Platform tier $99/seat · Team tier $29/seat · first 5 free for 12 months

Fastpace

The platform team your AI-coding surface needs. Without the headcount.

Everything a three-person platform team would build for AI-assisted dev across Claude Code Codex Gemini CLI Open Claude — without the three people. Opinionated standards, shared context, signed audit chain, one CLI.

Cost of a senior platform engineer in 2026: ~$500K/yr loaded. Cost of fastpace Team for a 30-dev org: ~$10K/yr. Same output for the AI-coding surface. 50× the cost ratio.

Buy Team → See pricing Get started ↓
claude · in repo/ · fastpace active
$
⚡ fastpaceis guarding you. what would you like to do?
› /fp-new-feature
› /fp-ask
› /fp-review-pr
› /fp-teach
>
feature: migrate auth to OIDC
branch:  feat/oidc-migration
planningspecwrite testsimplementrun testsdocsPRpush
planning· 0%0 of 8
? approve? yesnoskip
The pain

When your team passes five people, AI tooling stops being individual.

Solo devs handle their own .claude/ and their own AI bill. At 5+ devs, the same problems become organizational. There are three honest answers — accept the drift, hire a platform engineer at ~$500K/yr loaded, or run fastpace.

1

Config drift

Every dev's .claude/ wanders independently. The skill that worked last sprint is gone from half the repos. Your hooks were never blessed by anyone, just by whoever set them up first. Reviewers can't tell which guardrails fired and which didn't.

2

Onboarding tax

Every new hire costs a senior a week. Same walkthrough, same conventions, same "here's how we do PRDs" sit-down. Two weeks of paired time per hire × four hires a year × $200/hr loaded senior cost = $32K of senior time lost annually.

3

No AI visibility

Your part-time security lead can't tell you which agents have access to which paths. Nobody knows what AI is costing the team. The CTO asks "are we using AI safely?" and the only honest answer is "I don't know."

The four primitives

What a platform team would build. What fastpace ships.

These four are the load-bearing primitives in the Team tier — the ones a real platform team would prioritize on day one if they could afford to exist at your company. Each ships now.

Team+ fastpace sync

Enforce one shared config baseline across every repo

Pulls the org-blessed .claude/ tree (hooks, skills, agents, settings) into every repo. Atomic diff + apply. Drift detector catches what wandered.

Team+ fastpace welcome

Onboard new hires in days, not weeks

Personalized 2-minute walkthrough grounded in your real codebase, agents, and conventions. Guided first PR by Friday, not week three.

Team+ cost dashboard

Track AI cost per developer, per repo, per model

Aggregates token counts from signed run manifests × model prices. CLI report, dashboard tab, weekly forecast. Surfaces the $20K surprise before it hits the bill.

Team+ fastpace.policy.yaml

Codify security policy your AppSec lead can defend

Schema: allowed_models, allowed_mcp_servers, max_prompt_tokens, blocked_paths, agent_scope_caps, fail_mode. Existing hooks read at runtime. No policy engine, no DSL — just YAML with strong defaults.

Same primitives in the launch essay · pricing →

The cost math

$1.5M of platform engineering, or $10K of fastpace.

Real platform teams cost real money. A 3-person team at market 2026 loaded cost is $1.2–1.8M/yr. fastpace Team for a 30-dev org is ~$10K/yr (with the first 5 seats free for 12 months, the first year is closer to $7K). The math compares the AI-coding surface only — deploy, CI, observability are out of scope on both sides.

3-person platform team

Senior platform engineer × 3$250K base × 3
Equity (4-yr vest, ~1× base/yr)$250K × 3
Loaded benefits / overhead (~30%)+$450K
Annual loaded~$1.5M
And you still have to recruit them. In 2026. In a market where every company is hiring platform engineers.
vs.

fastpace Team (30 devs)

30 editor seats × $29/mo annual$10,440/yr
First 5 seats free for 12 months−$1,740
Viewer seats (CISO, GRC lead)$0 (free up to ~2× editor)
Year-1 cost~$8,700
Installs in 60 seconds. fastpace init. No procurement cycle. No interview loop. Cancel any month.

Yes — fastpace doesn't replace the human judgment a real platform team brings. It replaces the output: the shared config, the onboarding script, the cost dashboard, the policy file. The judgment stays with your senior devs. That's the design.

Context depth

Better domain context → better code

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.

Code quality →
Expert High Fair Low
L1 · code only
L2 · + architecture
L3 · + PRD / ERD
L4 · + execution plan
L5 · + ADRs & learnings
code only
+ architecture
+ PRD / ERD
+ execution plan
+ ADRs & learnings
Context depth →
Tier
Context added
What the AI can reason about
L1
Code only
AI ignores business intent, conventions, and history.
L2
+ architecture & patterns
AI follows conventions, but lacks business-domain awareness.
L3
+ PRD / ERD
AI respects acceptance criteria and interface contracts. ↳ ISO/IEC 42001 §8.4 evidence on file
L4
+ execution plan
AI respects phase boundaries and dependency ordering. ↳ phase boundaries = approval checkpoints · EU AI Act Art. 14
L5
+ ADRs & learnings
Complete institutional awareness. AI avoids repeating past mistakes. ↳ ADRs = SOC 2 CC8.1 + NIST AI RMF GOVERN-3.2 evidence
Measure & improve

Track and improve repo quality

Six dimensions, one grade. Each fix maps to a skill that closes the gap.

In Claude Code
/fp-context-score alias: /fp-repo-quality

Top-3 ranked fixes, each tied to a skill. Read-only.

In your terminal
fastpace context-score alias: fastpace repo-quality

Deterministic, no LLM call. Drop into CI.

--explain --json --debug
$ fastpace repo-quality 
⚡ 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)
Shared surface

One surface for product, eng, and compliance

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.

Product
Write PRDs, not tickets
Architects
Approve ERDs and ADRs
Developers
Ship features with guardrails
Leaders
See reality, not slideware
DevOps
Codify deploys, runbooks, alerts
Security
Review every decision
Risk
Track exposure, mitigations
Compliance
Audit-ready by default
Your repo
git · audit-ready
Spec-driven development, upgraded

PRD → ERD → execution plan, in your repo

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.

Each step commits a reviewable artifact: PRD.md· ERD.md· execution-plan.json· watch-cards/· audit.log· status-reports/
Better PRDs

PRDs the AI can verify against your code

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.

interview /fp-write-prd credit-card-validation
Q. who hurts today?
user checkout shoppers typing bad credit cards
Q. what triggers the pain?
user no client-side validation; payment service rejects on submit
Q. success metric?
metric 40% fewer rejected card submissions
Q. in scope?
scope card number, expiry, CVC format checks
Q. out of scope?
scope 3DS, fraud scoring (later phase)
Q. rollout?
rollout 10% canary → 100% over 2 weeks
output fastpace/docs/prd/credit-card-validation.md
  • Problem shoppers · pain · trigger ✓
  • Goals measurable outcomes ✓
  • Non-goals explicitly excluded ✓
  • Users who benefits, who doesn't ✓
  • Success one north-star metric ✓
  • Scope in / out / later ✓
  • Open issues unanswered questions ✓
✓ wrote credit-card-validation.md · status draft
Why "grounded"? The interview is just the input. The PRD is reconciled against your repo before it lands.
cross-ref Compared answers to src/checkout/*.ts — flagged 2 capabilities already implemented.
glossary Used canonical term "checkout" (from glossary.md) instead of "purchase flow" from your input.
decisions Detected conflict with ADR-0003 (no PII in client logs) — surfaced for review.
patterns Suggested following the existing retry-with-backoff pattern from patterns.md.
25+ slash commands · 15 new CLI commands in v0.35.0

Skills — daily-reach commands across five categories.

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.

Spec discipline

  • /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.

Code quality

  • /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.
  • /fp-test-gen Generates tests against your existing test patterns.

Backlog sync

  • /fp-pull-issue Pulls a Jira / Linear issue into AI context.
  • /fp-link-commit Annotates a commit with its source ticket ID + AI summary.
  • /fp-pr-summary Generates PR description from the run manifests + ticket context.

Team operations (Wave 2, Platform+)

  • fastpace standup Weekly digest from manifests + git. Slack-postable. Team-tier.
  • fastpace dora DORA-AI metrics sliced AI-vs-human.
  • fastpace ask Cross-repo Q&A over the org-synced context set.
  • /fp-ask Same, but Claude-Code-in-the-loop.
  • fastpace refactor Cross-repo refactor planning + execution.
  • fastpace learnings-sync Push/pull team-aggregated learnings.

Incident response (Wave 3, Platform+)

  • fastpace incident replay <range> Chronological replay of AI sessions in a commit window.
  • fastpace postmortem draft Markdown postmortem from commits + manifests + hook-blocks.
  • fastpace drift check Measures .claude/ drift vs the org baseline.
  • fastpace prompts list / use Shared prompt library (7 bundled + local additions).
  • fastpace mcp registry Org-blessed MCP server catalog (10 starters).

See the full skills reference →

7 specialists

Agents — bundled, scoped, with daily jobs.

Each agent ships with explicit scope (allowed tools, paths, command patterns) and a daily job. cross-repo-refactor is Platform-tier only — it's the agent a real platform team would invest a quarter to build.

/onboarder

Spins up new repos and engineers fast.

Daily use: New hire? /onboarder gives them a personalized walkthrough pulling from your real ADRs and patterns.
/architect

Drafts ERDs and execution plans from PRDs.

Daily use: Use it before any feature kickoff. /fp-prd-to-erd then /fp-erd-to-execplan.
/code-reviewer

Reviews PRs against your patterns + ADRs.

Daily use: Wire into PR-review hook. Comments inline. Saves senior-dev cycles.
/security-reviewer

Catches security issues before they ship.

Daily use: Pre-merge gate. Flags hardcoded secrets, broken IAM, sketchy regex.
/evidence-curator

Surfaces the receipts when reviewers ask.

Daily use: "Show me what produced this code" becomes one command.
/context-curator

Keeps L1–L5 context fresh.

Daily use: Weekly chore — runs in CI, reports what needs updating in fastpace/context/.
/cross-repo-refactor

Plans + executes org-wide migrations.

Daily use: Rename a concept across 12 repos, with consistent test updates. Platform-tier only.

See the full agents reference →

Platform tier · $99/seat

The differentiators a platform team would build — if it had time.

Team gives you the four primitives. Platform adds the differentiators — the surface that turns "we picked fastpace" into "we couldn't have built this ourselves." Each ships in v0.35.0 as a working MVP; the algorithms get sharper as real usage accumulates.

Cross-repo refactor agent

Rename a concept across 12 repos with consistent migrations. The cross-repo problem no IDE can solve.

DORA-AI metrics

Deploy frequency, lead time, change failure rate, MTTR — sliced AI-assisted vs human-only. The metric your VP Eng brings to the board.

fastpace ask (cross-repo Q&A)

"How does our billing flow work?" answered across all 12 repos at once. The wow moment most platform teams never deliver.

Team-aggregated learnings

When one dev extracts a learning, the whole team's AI context absorbs it. Individual experience → org compounding.

MCP server registry

Org-blessed catalog of MCP servers. fastpace mcp registry install <id>. Two-tier load: bundled + per-repo overrides.

Incident replay

fastpace incident replay <range> reconstructs every AI session that touched the affected code. Nobody else has the manifest chain to do this.

Postmortem generator

Auto-drafted markdown postmortems from commits + manifests + audit-log hook-block patterns. Saves a senior 2-4 hours per incident.

Drift detector

Surfaces every repo whose .claude/ has wandered from the org baseline. Counterpart to fastpace sync.

Prompt library

Shared prompt library — bundled blessed prompts + .fastpace/prompts/ for local additions. The org's "here's the right way to ask" surface.

Real backlog ↔ AI context

Integrations — bidirectional with the tools you already pay for.

Real backlog flows into agent context; AI commits flow back to the issue. Compliance push to Drata / Vanta lands AI/ML control evidence without your part-time security lead writing a single Confluence page.

Jira Atlassian Cloud + Server

Stories pulled into AI context. Generated code linked back via commit trailers + auto-comments on the issue.

Linear GraphQL native

Issue → context flow + AI commit ↔ issue linking. /fp-write-prd creates Linear issues directly (Platform+).

Slack Webhooks

fastpace integrate slack --webhook <url>. fastpace standup --slack posts your Monday digest to #fastpace-ships.

Confluence Atlassian docs

Pages cached as L2 context — architecture diagrams, glossaries, runbooks. Updated on-demand.

Google Docs Drive + Docs API

PRDs and design docs already in Docs become L3 context without copy-paste.

GitHub PRs + Actions

Provenance trailers on every commit. PR descriptions generated from manifests + tickets.

Drata / Vanta Compliance push

Auto-evidenced AI/ML controls. NIST AI RMF GOVERN-1.1 / MEASURE-2.7 / MANAGE-4.1 land as Drata evidence items.

GitLab / Bitbucket Self-hosted source

Same provenance + audit chain model. Self-hosted GitLab supported.

See setup details for each →

No migration · stack on top

Layer onto your existing AI agent. We don't replace; we coordinate.

fastpace doesn't replace Cursor, Copilot, Claude Code, Cline, or Codex CLI. It wraps them with the platform-team surface — the config, the audit chain, the org dashboard — so your team feels coordinated, not coordinated-by-Slack.

Cursor $20/dev/mo

Cursor types fast. fastpace makes the typing fit your codebase. $20 + $29 = $49/dev for code reviewers approve first time.

GitHub Copilot Business $19/dev/mo

Copilot has no domain context, no spec workflow, no Jira sync. fastpace adds all three.

Claude Code usage-based

Native pairing. Skills, agents, hooks all install via fastpace init directly into .claude/.

Cline / Continue free

Drop-in. Cheapest path to spec-driven AI coding — free runtime + $29/dev for the coordination layer.

Codex CLI usage-based

Hooks + provenance trailers. Run manifests captured per call.

Bedrock / Azure / Vertex cloud rates

Runtime-agnostic. Same governance, any model provider. Multi-cloud shops get one governance surface.

Per-stack setup walkthrough →

Adopt at your pace

At your pace

Test-drive on day one. Turn on phases as the team gets comfortable — and watch the audit signal compound alongside.

Day 1

Crawl

Test-drive, explore, learn.

  • Sandbox with
  • Ask around with
  • Open
audit milestone Audit log starts logging from minute one. announces this install.
Week 1

Walk

Plan and review with fastpace.

  • ERDs via
  • PR review via
  • Capture with
audit milestone First ADR committed. First prompt-redaction event captured. ISO/IEC 42001 §7.5 evidence on file.
Week 2+

Run

Full lifecycle, audited.

  • Ship with
  • Plan via
  • Reports via
audit milestone First evidence snapshot exported via . NHI registry exported. NIST AI RMF MEASURE-3.1 satisfied.
Provenance · the platform-team kicker

Every AI call leaves a signed trail your CISO can defend.

The platform team you didn't hire would have written runbooks about "how we govern AI in dev." fastpace ships the runbook as code — and every AI-merged commit traces back to a signed manifest. Reviewers, auditors, and your future self all get the same forensic trail.

Vendor-agnostic by design

No vendor lock-in — context stays in git

Free of vendor dependence Committed to git. Works with any LLM runtime.

Your team's brain, in git

Business rules, ADRs, patterns, lessons — all plain markdown. Any AI runtime rehydrates instantly.

Swap models, keep context
Claude today, Codex tomorrow — same repo, same brain.
Onboard in one git clone
A new engineer inherits the institutional knowledge.
Remembered, not rediscovered
Review findings and reversals persist across sessions.
ADRs, not folklore
Decisions land with rationale, tradeoffs, and what was rejected. SOC 2 CC8.1 + NIST AI RMF GOVERN-3.2 evidence on file by default.
Business rules, not just code
Every session knows the why, not just the how.

Click any file on the right to preview what the AI sees.

fastpace / context /
  • Entry points, module boundaries, data flow.
  • Languages, frameworks, runtimes, pinned versions.
  • Naming, commits, test file locations, coding style.
  • Domain terms a cold reader would not know.
  • Recurring code idioms worth reusing — retry, pagination, auth.
  • ADR-lite: what was decided, why, what was rejected.
  • Hard-won knowledge from incidents and reviews.
architecture.md
Rendered markdown preview — this is what the AI reads
Capture knowledge manually with /fp-remember, or let it grow organically as you use fastpace.
Underlying primitives

What's actually wired into your repo

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.

Agents

Specialist agents

Each agent runs in a fresh context with a tight scope and minimal tool access.

planner

Turns a goal into a numbered plan.

reviewer

Reviews diffs vs. architecture and decisions.

prd-guru

Interviews you and drafts a PRD.

erd-guru

Translates PRDs into ERDs.

execution-planner

Waves → epics → stories.

doc-writer

Updates docs without noise.

Local dashboard

100% local dashboard — click around or take the tour

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.

http://localhost:7777
Dashboard / In-flight features
⌘K

In-flight features

Every feature started with /fp-new-feature persists to fastpace/watch-cards/.

Credit card validation
feat/credit-card-validation → main
● medium risk updated 2h ago
✓ planning ✓ spec ✓ write tests ◐ implement run tests docs PR push
implement · 62% 3 of 8 phases
Migrate auth to OIDC
feat/oidc-migration → main
● high risk updated yesterday
✓ planning ◐ spec write tests implement run tests docs PR push
spec · 28% 1 of 8 phases
Rate-limit public endpoints
feat/rate-limits → main
● low risk updated 4h ago
✓ planning ✓ spec ✓ write tests ✓ implement ✓ run tests ✓ docs ◐ PR push
PR · 54% 6 of 8 phases
Tour as:
1 of 8

The local UI

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.

Org dashboard

Self-hosted fleet aggregator — your VPC, your data plane

@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.

fleet · acme-corp
⚡ https://fastpace.acme-corp.com:4444 self-hosted
org · overview
14 installs · last shard 38s

Fleet overview

Aggregated from signed shards. Each install pushes via F3.11 every 5 min; the dashboard polls + recomputes on ingest.

repos
14
teams
7
developers
62
chains ok
14/14
org maturity
68
framework readiness
82%
Top 5 repos by maturity
billing-apipayments81
checkout-svcpayments72
acme-webgrowth64
notificationsplatform55
internal-toolsinfra42
Recent ingests
checkout-svc · 12 audit entries · maturity Δ +138s
billing-api · 7 audit entries · maturity steady2m
acme-web · 21 audit entries · 1 new exception5m
notifications · circuit breaker tripped on doc-writer14m

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.

7 panels · ~60 seconds
AI-Native Maturity

A single number for whether your team is getting AI-native right.

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).

Test-drive — no commitment

Try fastpace in a sandbox first

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.

First, install globally
🧪
recommended first try

Test-drive in a sandbox repo

5 min
  1. Spin up a fresh sandbox directory — nothing in your real repos is touched:
  2. Scaffold fastpace and let it seed a sample feature:
    --sample writes a tiny demo PRD, ERD, and watch card so the dashboard isn't empty on first launch.
  3. Launch Claude Code (or Codex / Gemini CLI) inside the sandbox and try a command:
  4. Once you've felt the flow, blow it away — no traces left:
  5. Done!
    Liked it? Move on to Brownfield or Greenfield below to point fastpace at your real repo.
When you're ready for the real thing
🌳
existing repo

Brownfield

  1. Clone your repo, enter it, and scaffold fastpace:
  2. Launch Claude Code, then run:
  3. Done!
    Ask questions with or build with
🌱
new repo

Greenfield

  1. Create your project directory, enter it, and scaffold fastpace:
  2. Add your code repos as submodules:
  3. Launch Claude and run:
  4. Done!
    Start with while fastpace watches over you.

fastpace runs outside the Claude sandbox and writes fastpace/ and fastpace.config.yaml into your repo.

then fills in the domain knowledge inside Claude.

🧹
when the evaluation ends

Uninstall cleanly

your files survive

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.

Scope default = user-global only (gentle). Add scopes for more cleanup.
composed command
fastpace uninstall
removes user-manifest files; preserves your own .claude/ files, fastpace/, settings.json, and ~/.fastpace
+
Remove the CLI itself drops the global npm package after the cleanup above
Power-user flags + recovery
  • --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.

Keep it up to date

Stop building internal AI tooling. Start using it.

Free for solo devs. Team is $29/seat/mo (first 5 seats free for 12 months). Platform is $99/seat/mo. Same install. fastpace activate unlocks the tier.

See pricing View on GitHub