Open source · MIT License

SpecKit without
babysitting.

Write your spec. With --auto-clarify, you may not even need to answer questions. Everything else — planning, implementation, validation, and a multi-agent review that fixes what it finds — runs automatically.

Get Started View on GitHub

Background

What is SpecKit?

GitHub SpecKit is a structured workflow for AI-assisted development. It turns a natural-language spec into a formal plan, generates tasks, validates spec quality, implements code, and runs validation — all through slash commands.

📋

Structured Phases

Specify → Clarify → Plan → Tasks → Implement. Each phase builds on the last.

🔍

Quality Gates

Checklist + analyze catch spec issues before code is written.

⚡

LazySpecKit Adds

Full automation plus a multi-agent review & refine phase. Four AI agents audit your code from different perspectives and auto-fix issues.

Step 1

Install in one command

Requires bash + curl (or wget). Works on macOS, Linux, and Windows (Git Bash).

bash -c "$(curl -fsSL https://raw.githubusercontent.com/Hacklone/lazy-spec-kit/main/install.sh)"

Installs to ~/.local/bin (or ~/bin on Windows Git Bash)

Step 2

Quick Start

Initialize your project, then use the prompt. Two steps, no config files to write.

Terminal 
# For VS Code Copilot
lazyspeckit init --here --ai copilot

# For Claude Code
lazyspeckit init --here --ai claude

Then in your AI assistant:

AI Prompt 
/LazySpecKit Add OAuth login with GitHub and Google. Store users in Postgres. Add tests.

For the fully hands-off experience — auto-answer clarification questions:

AI Prompt — auto-clarify (recommended) 
/LazySpecKit --auto-clarify Add OAuth login with GitHub and Google. Store users in Postgres. Add tests.

Skip the review phase if you want:

AI Prompt — review disabled 
/LazySpecKit --review=off Add OAuth login with GitHub and Google.

That's it. LazySpecKit takes over — implementation, validation, and (by default) a multi-agent review that fixes issues automatically. With --auto-clarify, you may not even need to answer a single question. ☕

Under the hood

How It Works

LazySpecKit orchestrates the full SpecKit lifecycle. You interact at most twice — or with --auto-clarify, potentially not at all. Everything else runs automatically.

Phase 0

Constitution if missing

Checks for an existing constitution. If none found, asks you to provide one — once.

Phase 1

Specify automatic

Runs /speckit.specify with your spec text verbatim.

Phase 2

Clarify your input

Presents clarification questions. Answer once, then sit back. With --auto-clarify, high/medium-confidence questions are answered automatically — you're only asked about genuinely ambiguous items (if any).

Phase 3

Plan automatic

Generates a structured implementation plan from the clarified spec.

Phase 4

Tasks automatic

Breaks the plan into sequential, actionable tasks.

Phase 5

Quality Gates automatic

Runs /speckit.checklist and /speckit.analyze. Auto-fixes spec issues until clean.

Phase 6

Implement automatic

Executes all tasks in a fresh implementation session. Strict, in-order.

Phase 7

Validate automatic

Detects and runs lint, typecheck, tests, and build. Reports results.

Phase 8

Review & Refine automatic

Four AI agents — architecture, code quality, spec compliance, tests — review the code from different perspectives and auto-fix Critical/High findings. Up to 3 loops until clean.

Phase 9

Final Validation automatic

Full validation suite re-runs to guarantee everything is green before completion. No broken code ships.

Killer feature

Auto-Clarify — True Hands-Off Mode

SpecKit's clarification phase normally requires your input. With --auto-clarify, the agent answers for you.

AI Prompt — full autopilot 
/LazySpecKit --auto-clarify Add a REST API with CRUD endpoints and tests.
🟢

High confidence

Clear best practice or strong repo signal. Auto-selected — no pause.

🟡

Medium confidence

Trade-offs exist but a reasonable default is available. Auto-selected — no pause.

🔴

Low confidence

Genuinely ambiguous — only these are presented to you in a structured A/B/C/D format for a quick reply.

How it works

Step 1

Structured questions

SpecKit's clarification questions are normalized into A/B/C/D options. Each gets an explicit Recommendation and Confidence level.

Step 2

Auto-select confident answers

High and Medium confidence recommendations are auto-selected. No user interaction needed.

Step 3

Ask only when unsure

Only Low-confidence questions (if any) are presented to you. If everything is High/Medium — you never see a single question.

Step 4

Continue automatically

Planning, implementation, validation, and review proceed without further interaction.

📝 Without auto-clarify

  • All clarification questions presented to you
  • You answer once in a structured format
  • Still just one interaction — but you need to be present

⚡ With --auto-clarify

  • Confident answers auto-selected by the agent
  • Only genuinely ambiguous items escalated to you
  • Often zero interaction — spec in, finished code out
  • The ultimate hands-off spec-driven workflow

--auto-clarify is off by default. Enable it when you want the fully autonomous experience.

Beyond SpecKit

Multi-Agent Review & Refine

SpecKit stops after implementation and validation. LazySpecKit keeps going. Four independent AI agents — each with a different perspective — review your code and fix what they find.

🏗️

Architecture Reviewer

Evaluates structural decisions, separation of concerns, dependency direction, and abstraction boundaries.

✨

Code Quality Reviewer

Checks readability, idiomatic patterns, error handling, duplication, and engineering best practices.

📋

Spec Compliance Reviewer

Verifies every requirement from the approved spec is implemented correctly and completely.

🧪

Test Reviewer

Audits test coverage, edge cases, test quality, reliability, and identifies missing scenarios.

Review, fix, verify — automatically

Step 1

Analyze

All four agents review the implemented changes from their perspective. Findings are categorized: Critical / High / Medium / Low.

Step 2

Auto-fix

LazySpecKit automatically fixes all Critical and High issues, plus low-effort Medium ones. Not just a report — actual code changes.

Step 3

Re-validate

Lint, typecheck, tests, and build re-run to confirm the fixes didn't break anything.

Step 4

Iterate

Agents review again — up to 3 loops — until no Critical or High findings remain. Then a final validation gate confirms green.

🔧 SpecKit alone

  • Spec → Plan → Tasks → Implement → Validate
  • Manual slash commands between each phase
  • No post-implementation review
  • You review the code yourself
  • Hope for the best after validation passes

⚡ LazySpecKit

  • Everything SpecKit does, fully automated
  • One command — answer questions once (or use auto-clarify), done
  • Auto-clarify: agent answers its own questions when confident
  • Four AI agents review from different perspectives
  • Issues are auto-fixed, not just reported
  • Iterative convergence: review → fix → validate loops
  • Final validation gate ensures green before completion

Review & Refine is on by default. Disable with --review=off if you just want the SpecKit automation.

Reference

CLI Commands

Everything you can do with the lazyspeckit CLI.

lazyspeckit init [specify init args...]

Initializes SpecKit and installs LazySpecKit prompts. All flags pass through to specify init.

lazyspeckit upgrade [--here | <path>]

Upgrades SpecKit CLI, project files, and LazySpecKit prompts. Auto-detects all configured AI agents. SpecKit failures are non-fatal — prompts always update.

lazyspeckit doctor [--here | <path>]

Shows diagnostics: versions, tools, SpecKit status, prompt file presence. Makes no changes.

lazyspeckit self-update

Updates the CLI binary itself and upgrades the SpecKit CLI.

lazyspeckit version

Shows local and remote CLI versions. Hints if an update is available.

Supported

AI Agents

Same prompt, different locations. Both get installed automatically.

VS Code Copilot

--ai copilot
.github/prompts/LazySpecKit.prompt.md
If /LazySpecKit doesn't appear, run Developer: Reload Window

Claude Code

--ai claude
.claude/commands/LazySpecKit.md
If /LazySpecKit doesn't appear, restart your session or reopen the repo

Configuration

Environment Variables

VariableDefaultDescription
LAZYSPECKIT_REFmainPin downloads to a branch, tag, or commit SHA
DEBUG0Set to 1 for bash trace output
NO_COLOR—Set to 1 to disable colored output
BIN_DIR~/.local/binOverride install location (install.sh only)
Pin to a specific version 
LAZYSPECKIT_REF=v0.6.1 lazyspeckit self-update

Help

Troubleshooting

lazyspeckit: command not found

Add export PATH="$HOME/.local/bin:$PATH" to your ~/.bashrc or ~/.zshrc, then restart your terminal. On Windows Git Bash, the default is ~/bin.

uv or uvx not found

LazySpecKit installs uv automatically. If it fails, run curl -LsSf https://astral.sh/uv/install.sh | sh manually.

Windows: winget not found from Git Bash

Run winget install --id Astral.Uv -e in PowerShell instead, then restart Git Bash.

Something else is broken

Run lazyspeckit doctor --here for diagnostics. Add DEBUG=1 for full trace output.

Questions

FAQ

Why does upgrade run specify init --force?
That's how SpecKit refreshes its project files (slash commands, templates). LazySpecKit automatically backs up and restores your constitution and custom templates.
What does LazySpecKit back up during upgrade?
Your constitution (.specify/memory/constitution.md) and custom templates (.specify/templates/). Both are restored after specify init --force.
Can I use both Copilot and Claude in the same repo?
Yes. Both init and upgrade install prompts for all detected agents. The prompt content is identical — only the file location differs.
Does LazySpecKit modify my source code?
The CLI only manages SpecKit configuration and prompt files. The /LazySpecKit prompt generates and modifies source code during implementation — that's the whole point.
What happens if SpecKit fails during upgrade?
SpecKit failures are non-fatal during upgrade. LazySpecKit always installs the latest prompts regardless. Your customizations are backed up and restored even on failure.
What is Review & Refine? Isn't LazySpecKit just a SpecKit wrapper?
No — LazySpecKit adds a full post-implementation phase that SpecKit doesn't have. After implementation and validation, four independent AI agents (architecture, code quality, spec compliance, tests) review the code from different perspectives, automatically fix Critical and High issues, re-validate, and loop until clean. It's review and refinement, not just reporting.
Can I disable the Review & Refine phase?
Yes. Pass --review=off before your spec text: /LazySpecKit --review=off <your spec>. This skips the multi-agent review entirely and stops after implementation + validation.
What does --auto-clarify do?
It lets the agent auto-select recommended answers for clarification questions when it's confident (High or Medium). Only genuinely ambiguous (Low confidence) questions are presented to you. If all questions are High/Medium, you never interact at all — spec in, finished code out.
Is --auto-clarify safe? Will it make bad decisions?
Each recommendation includes an explicit confidence level. High-confidence answers follow clear best practices or strong repo signals. Medium answers reflect reasonable trade-offs. The agent only auto-selects when it's confident — genuinely ambiguous items are always escalated to you.
Can I combine --auto-clarify with --review=off?
Yes: /LazySpecKit --auto-clarify --review=off <spec>. This gives you the fastest possible run — auto-answered clarification, no post-implementation review. Great for prototyping or when you plan to review manually.
What does LazySpecKit respect from my repo?
LazySpecKit respects agents.md governance files. A root-level agents.md applies repo-wide; nested ones apply to their directory subtree. Rules are enforced across all phases.
How is LazySpecKit different from OpenSpec?

Both care about spec-driven development — but they solve different problems. OpenSpec focuses on structured, versioned specification workflows. LazySpecKit focuses on automated execution and convergence to green.

FeatureOpenSpecLazySpecKit
Spec management & proposal workflow✔️Inherits from SpecKit
Structured validation of specs✔️✔️ via /speckit.analyze + auto-fix
Fully automated end-to-end lifecycle—✔️
Deterministic phase gates—✔️
Auto-clarify with confidence levels—✔️
Hands-off mode (--auto-clarify)—✔️
Multi-agent autonomous review loop—✔️
Auto-fix review findings—✔️
Guaranteed final validation—✔️
OpenSpec Making specs explicit and collaborative. Structured proposal workflows, versioned spec artifacts, team-oriented change management.
LazySpecKit Taking a spec and autonomously driving it to validated, reviewed, green code — without babysitting. Automation depth and post-implementation refinement.

They are complementary philosophies. OpenSpec excels at making specifications a first-class collaborative artifact. LazySpecKit's differentiator is automation depth — from spec to reviewed, validated code with zero hand-holding.

Cleanup

Uninstall

Remove the CLI 
# macOS / Linux
rm ~/.local/bin/lazyspeckit

# Windows Git Bash
rm ~/bin/lazyspeckit
Remove prompts from a repo
rm .github/prompts/LazySpecKit.prompt.md
rm .claude/commands/LazySpecKit.md