SpecKit Companion: see and steer everything your AI builds, from first spec to shipped code

Build Status GitHub Release

One workspace for the whole life of a spec, not just the review. SpecKit Companion is a spec workspace inside VS Code for developers running AI agents through spec-driven development. See where every feature stands at a glance, read specs as real documents, review and correct them the way you review pull requests, watch runs move live, keep a record of what the AI actually did, and keep living specs that stay true after the code ships. Its own pipeline writes specs 60 to 68% leaner with the same correctness (the measured numbers) — and a vague requirement still dies here before it becomes 200 lines of wrong implementation.

A guided tour of the Overview: the whole run on one page, then per-phase timing, the living specs it loaded and where it worked, the expectations fence, verified checks with the commands that prove them, decisions with rejected alternatives, and the requirement to task to test coverage table

Features

Visual Spec Viewer

Specs render as rich, structured pages, not walls of markdown: requirements as labeled rows, acceptance scenarios as clean Given/When/Then sentences, tasks grouped under their phases, and mermaid diagrams inline with zoom. A quiet footer advances the spec one click at a time, and it never advances ahead of a running step. The markdown stays in your repo, never on a server.

A spec rendered as a structured page: title-leading header, requirements as labeled rows, the pipeline rail, and on-page navigation

Inline Review Comments

Comment on specific lines of a spec, exactly like a pull request review. Comments persist the moment you add them, survive closing the tab, and are committable, so a half-finished review picks up next session or on another machine. Click Refine and the pending comments are dispatched to your AI for an in-place edit of the source.

Inline review comments on a spec: two pending comments and one already applied, each pinned under the line it annotates

Watch a run in flight

A run is not a black box you check on afterwards. The pipeline rail unlocks phase by phase, one button always offers the next step, tasks tick over live while implement runs, and the actions stay locked until the step settles — then the Overview shows exactly how long each phase took.

A run moving through the pipeline: the rail unlocks phase by phase, the next-step button follows it, tasks tick over live during implement, and the run overview lands with per-phase timing

Overview: the run's story

A spec with recorded activity opens on its Overview: why the spec exists, its constraints, the decisions made (with rejected alternatives), what was verified, and a requirement-to-test traceability table. It is the dossier a future session, a reviewer, or a teammate reads instead of re-asking you.

The completed Overview dossier with its honest per-phase timing called out: run status, the expectations fence, verified checks with the commands that prove them, decisions with rejected alternatives, and the coverage table

Specs grouped by lifecycle with live status per document, resume-where-you-left-off on hover, filter and sort, multi-select bulk actions, and views for living capability specs and AI steering documents. A workspace with hundreds of finished specs opens to a short, readable list.

The Specs sidebar: specs grouped by lifecycle with per-document progress marks, filter and sort, and the living-specs and steering views beneath

Pick a pipeline once, run it end to end

Choose stock Spec Kit or the leaner SpecKit Companion workflow in a single setting, and every step of the run dispatches that choice. The Companion pipeline writes specs roughly 60 to 68% smaller, produces zero throwaway side files, and right-sizes itself: a small change skips the ceremony, a large one keeps the full specify, plan, tasks, implement flow. In our benchmark, correctness was a tie; the difference is ceremony, not outcomes. Details and the measured numbers: Workflow choice.

The benchmark in four tiles: 60 to 68% smaller specs, zero throwaway side files, ceremony right-sized to the change, and a 5.0 out of 5 correctness tie

Living specs: one per capability, wherever you keep them

Feature specs describe one change and then go quiet. Living specs are durable: one per capability (checkout, auth, billing), loaded into the AI's context when a feature touches that area, and folded back up to date when the feature ships. Keep them together in a central capabilities/ folder, or colocated, each spec right next to the feature it covers, with one reversible command to move between the two. Either way the sidebar shows per-capability test coverage and flags drift the moment the code moves on, and one sync pass updates every affected spec from your current changes. Opt-in, append-only, and never a failed run. Living specs

The Living Specs pair: the sidebar's Living Specs view with per-capability coverage counts and drift flags, beside the viewer open on the photo-storage capability with its LIVING badge, covered globs, purpose, and WHEN/THEN requirement rows

Also in the box

Bring your own SDD process. Custom phases, custom commands, custom output files; the sidebar and viewer adapt. Custom workflows
Offline-first and careful by default. Fonts and icons ship in the .vsix, destructive actions need confirmation or offer undo, and Reduce Motion is honored. Viewer reference

Make it yours: swapping the default workflow, adding your own commands, and picking your AI provider, each shown as the real settings.json entry

No lock-in, no server

Everything lives in plain files in your repo: the spec markdown plus a .spec-context.json per spec. The viewer and your terminal are two front-ends over the same files, so a step driven from either surface shows up in the other, and there is no extension-owned database to migrate away from. The extension dispatches command text to the AI you configure and reads what lands on disk; your prompts and specs never pass through anyone's server. How the pieces fit: Getting started.

Install

Install SpecKit Companion from the VS Code Marketplace.
Click the SpecKit icon in the activity bar and open a folder.
Click + in the Specs view, describe your feature, and pick the AI you already use.

That's it: the viewer, review comments, and sidebar work on their own. To also get the lean Companion pipeline, live progress capture, and the Resume button, add the companion Spec Kit extension: the sidebar offers a one-click install when it's missing.

Works with your AI

Dispatches to Claude Code, GitHub Copilot, Gemini, Codex, and more, in a terminal or in your editor's chat panel. Full compatibility matrix: Supported AI providers.

Docs

Getting started: full install story, required vs. optional pieces, platform support
Spec viewer reference: reading, reviewing, creating, safety affordances
Sidebar reference: every view, icon, and action
Configuration: all settings, custom workflows, custom commands
Supported AI providers: the compatibility matrix and dispatch styles
Living specs: durable capability specs, drift, sync, adoption
Telemetry: exactly what is and isn't collected, and both off switches
.spec-context.json schema: the on-disk state file
How it works: architecture walkthrough
Contributing · Changelog

Telemetry

The extension sends anonymous, PII-free usage telemetry (provider choice, phase dispatched, lifecycle counts; never prompt content, paths, or names). Two switches gate it, and if either is off nothing is sent: speckit.telemetry and VS Code's global telemetry level. Full disclosure: Telemetry.

Support

SpecKit Companion is free and open source. If it saves you time, you can support its development through GitHub Sponsors. You'll also find a "Sponsor" button on the Marketplace listing and a "Support this project" link in the Specs sidebar.

Acknowledgments

This project started from the amazing work at https://github.com/notdp/kiro-for-cc

License

MIT License

SpecKit Companion

Alfredo Perez