The complete AI development workflow — architecture awareness, multi-agent review & auto-fix, and zero babysitting. Write your spec. LazySpecKit handles everything else: planning, implementation, validation, and a seven-agent review that finds AND fixes issues automatically.
Background
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.
Specify → Clarify → Plan → Tasks → Implement. Each phase builds on the last.
Checklist + analyze catch spec issues before code is written.
Full automation plus a multi-agent review & refine phase. Seven AI agents audit your code from different perspectives and auto-fix issues.
First-time setup
A constitution is a short document that tells SpecKit about your project — its tech stack, conventions, and preferences — so that every generated plan, task, and code change aligns with how your project actually works.
Languages, frameworks, databases, infrastructure — so the agent picks the right tools.
Naming conventions, file structure, patterns (e.g. “use repository pattern”, “functional components”).
Test framework, coverage expectations, package manager, linter, CI requirements.
Security policies, performance targets, accessibility, compliance, domain context.
# My Project Constitution
- TypeScript + React 19 frontend, Node.js + Express backend
- PostgreSQL with Prisma ORM
- Vitest for unit tests, Playwright for E2E
- pnpm workspaces monorepo
- All API routes require auth middleware
- Follow existing patterns in src/
The first time you run /LazySpecKit in a project without an existing constitution, it will ask you to provide one. Paste your text, and LazySpecKit passes it to SpecKit’s /speckit.constitution command. After that, it’s saved in your project and reused for every future run.
Step 1
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
Initialize your project, then use the prompt. Two steps, no config files to write.
# For VS Code Copilot lazyspeckit init --here --ai copilot # For Claude Code lazyspeckit init --here --ai claude # Also install for Cursor or OpenCode lazyspeckit init --here --ai copilot --ai cursor lazyspeckit init --here --ai all
Then in your AI assistant:
/LazySpecKit Add OAuth login with GitHub and Google. Store users in Postgres. Add tests.
For the fully hands-off experience — auto-answer clarification questions:
/LazySpecKit --auto-clarify Add OAuth login with GitHub and Google. Store users in Postgres. Add tests.
Skip the review phase if you want:
/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
LazySpecKit automates the entire spec-driven development lifecycle. You interact at most once — or with --auto-clarify, potentially not at all. Everything else runs automatically.
Checks for an existing constitution. If none found, asks you to provide one — a short description of your project’s tech stack, conventions, and preferences. Created once, reused forever.
Loads 3 compact root files from .docs/architecture/ — index, summary, principles. Agents then selectively load relevant component overviews and detail files (modules, API, UI). Scales to large monorepos. Skipped if not configured.
Runs /speckit.specify with your spec text. Matches against architecture routing table to selectively load relevant component overviews and detail files.
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).
Generates a structured implementation plan from the clarified spec.
Breaks the plan into sequential, actionable tasks.
Runs /speckit.checklist and /speckit.analyze with multi-perspective checks (architecture, security, performance, UX). Auto-fixes spec issues until clean.
Executes all tasks strictly in order.
Detects and runs lint, typecheck, tests, and build. Reports results.
Seven AI agents — architecture, code quality, security, performance, spec compliance, accessibility, tests — review the code from different perspectives and auto-fix Critical/High findings. Up to 6 loops until clean.
Updates architecture docs to reflect new components, integrations, and decisions. Keeps documentation evergreen without manual effort.
Full validation suite re-runs to guarantee everything is green before completion. No broken code ships.
Killer feature
SpecKit's clarification phase normally requires your input. With --auto-clarify, the agent answers for you.
/LazySpecKit --auto-clarify Add a REST API with CRUD endpoints and tests.
Clear best practice or strong repo signal. Auto-selected — no pause.
Trade-offs exist but a reasonable default is available. Auto-selected — no pause.
Genuinely ambiguous — only these are presented to you in a structured A/B/C/D format for a quick reply.
SpecKit's clarification questions are normalized into A/B/C/D options. Each gets an explicit Recommendation and Confidence level.
High and Medium confidence recommendations are auto-selected. No user interaction needed.
Only Low-confidence questions (if any) are presented to you. If everything is High/Medium — you never see a single question.
Planning, implementation, validation, and review proceed without further interaction.
--auto-clarify is off by default. Enable it when you want the fully autonomous experience.
Seven perspectives
Implementation is only half the job. LazySpecKit keeps going. Seven independent AI agents — each with a different perspective — review your code and fix what they find. Five are sourced from Agency and downloaded automatically.
Evaluates structural decisions, separation of concerns, dependency direction, and abstraction boundaries.
Checks readability, idiomatic patterns, error handling, duplication, and engineering best practices.
Identifies injection vulnerabilities, missing auth checks, credential leaks, and input validation gaps.
Catches N+1 queries, missing indexes, redundant computation, memory leaks, and resource waste.
Verifies every requirement from the approved spec is implemented correctly and completely.
Checks ARIA attributes, keyboard navigation, color contrast, screen reader support, and WCAG compliance.
Audits test coverage, edge cases, test quality, reliability, and identifies missing scenarios.
All seven agents review the implemented changes from their perspective. Findings are categorized: Critical / High / Medium / Low.
LazySpecKit automatically fixes all Critical and High issues, plus low-effort Medium ones. Not just a report — actual code changes.
Lint, typecheck, tests, and build re-run to confirm the fixes didn't break anything.
Agents review again — up to 6 loops — until no Critical or High findings remain. Then a final validation gate confirms green.
Review & Refine is on by default. Disable with --review=off if you want to skip post-implementation review.
Extensible
Seven default reviewer skill files are installed during lazyspeckit init — five sourced from Agency, two from LazySpecKit. Edit any default to tune its behavior, or add new .md files to create additional reviewers.
├── accessibility.md # Accessibility & inclusion (from Agency) ├── architecture.md # System design (from Agency) ├── code-quality.md # Engineering craft ├── performance.md # Runtime efficiency (from Agency) ├── security.md # Application security (from Agency) ├── spec-compliance.md # Requirements coverage (from Agency) └── test.md # QA & test quality
--- name: Accessibility Reviewer perspective: WCAG compliance and inclusive UX --- Focus on: - Semantic HTML and ARIA attributes - Keyboard navigation and focus management - Color contrast ratios (WCAG AA minimum) - Screen reader compatibility - Alt text for images and media Severity guide: - Critical: interactive element unreachable by keyboard - High: missing ARIA labels on form controls - Medium: insufficient color contrast - Low: missing skip-navigation link
Default Source
Agency is a curated collection of specialized AI agent definitions. Five of LazySpecKit’s seven reviewers are downloaded from the Agency repo by default during init and upgrade. If you have Agency installed locally, matching agents are symlinked instead.
| Agency agent | LazySpecKit reviewer |
|---|---|
testing/testing-reality-checker.md | spec-compliance.md |
engineering/engineering-security-engineer.md | security.md |
testing/testing-performance-benchmarker.md | performance.md |
testing/testing-accessibility-auditor.md | accessibility.md |
engineering/engineering-backend-architect.md | architecture.md |
# Agency reviewers are downloaded from the Agency repo by default lazyspeckit init --here --ai copilot # Custom Agency install path lazyspeckit init --here --ai copilot --agency-path ~/my-agents # Skip local Agency overlay (downloaded defaults are still used) lazyspeckit init --here --ai copilot --no-agency
# Import an agent as a reviewer lazyspeckit add-reviewer --from-agency testing/testing-accessibility-auditor.md # Import with a custom name lazyspeckit add-reviewer --from-agency testing-reality-checker --as spec-checker.md
Works on macOS, Linux, and Windows. If symlinks aren’t supported, LazySpecKit falls back to copying with a warning. Existing user-customized reviewers are never overwritten.
Reference
Everything you can do with the lazyspeckit CLI.
Initializes SpecKit and installs LazySpecKit prompts. Use --ai to select agents: copilot, claude, cursor, opencode, or all. Downloads Agency reviewers by default. If Agency is installed locally, symlinks matching agents instead. Use --no-agency to skip local overlay. Use --no-architecture to skip architecture docs setup.
Upgrades SpecKit CLI, project files, LazySpecKit prompts, and reviewer skill files. Auto-detects all configured agents (Copilot, Claude, Cursor, OpenCode) from directory structure. Downloads latest Agency reviewers. SpecKit failures are non-fatal — prompts and reviewers always update.
Shows diagnostics: versions, installed agents, SpecKit status, and prompt file presence. Makes no changes.
Updates the CLI binary itself and upgrades the SpecKit CLI.
Copies an Agency agent into .lazyspeckit/reviewers/ as a reviewer, with the no-interaction header injected automatically. Use --as to rename, --force to overwrite.
Shows local and remote CLI versions. Hints if an update is available.
Creates .docs/architecture/ with core template files (index, summary, principles), example component docs under components/, and directory structure. Never overwrites existing files.
Scans the project and reports architecture documentation status. Lists documented components, integrations, and decisions. Suggests project directories that lack documentation. Runs automatically during upgrade and doctor.
Displays architecture doc status: core files, documented components with doc counts, integrations, and architecture decision records.
Supported
All agents use the --ai flag. Use --ai all to install for every agent. upgrade auto-detects installed agents from directory structure.
/LazySpecKit doesn't appear, run Developer: Reload WindowalwaysApply: false — use as an on-demand ruleConfiguration
| Variable | Default | Description |
|---|---|---|
LAZYSPECKIT_REF | main | Pin downloads to a branch, tag, or commit SHA |
DEBUG | 0 | Set to 1 for bash trace output |
NO_COLOR | — | Set to 1 to disable colored output |
BIN_DIR | ~/.local/bin | Override install location (install.sh only) |
LAZYSPECKIT_REF=v0.8.4 lazyspeckit self-update
Help
Add export PATH="$HOME/.local/bin:$PATH" to your ~/.bashrc or ~/.zshrc, then restart your terminal. On Windows Git Bash, the default is ~/bin.
LazySpecKit installs uv automatically. If it fails, run curl -LsSf https://astral.sh/uv/install.sh | sh manually.
Run winget install --id Astral.Uv -e in PowerShell instead, then restart Git Bash.
Run lazyspeckit doctor --here for diagnostics. Add DEBUG=1 for full trace output.
Questions
specify init --force?
.specify/memory/constitution.md) and custom templates (.specify/templates/). Both are restored after specify init --force.init and upgrade install prompts for all detected agents. The prompt content is identical — only the file location differs./LazySpecKit prompt generates and modifies source code during implementation — that's the whole point.--review=off before your spec text: /LazySpecKit --review=off <your spec>. This skips the multi-agent review entirely and stops after implementation + validation.--auto-clarify do?
--auto-clarify safe? Will it make bad decisions?
--auto-clarify with --review=off?
/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.agents.md governance files and architecture documentation in .docs/architecture/. A root-level agents.md applies repo-wide; nested ones apply to their directory subtree. Rules are enforced across all phases. Architecture docs inform planning, review, and service reuse..docs/architecture/ and do I need it?
lazyspeckit init. Without it, LazySpecKit still works but treats each spec in isolation. With it, specs reuse existing components, respect boundaries, and avoid duplication. Use --no-architecture to skip it.lazyspeckit architecture:check or lazyspeckit upgrade also checks for gaps.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.
| Feature | OpenSpec | LazySpecKit |
|---|---|---|
| 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 | — | ✔️ |
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
# macOS / Linux rm ~/.local/bin/lazyspeckit # Windows Git Bash rm ~/bin/lazyspeckit
rm .github/prompts/LazySpecKit.prompt.md rm .claude/commands/LazySpecKit.md