speclite-cli 0.0.10

SpecLite – A Pragmatic Evolution of Spec Kit for Spec-Driven Development

🌱 SpecLite

A pragmatic evolution of [GitHub Spec Kit](https://github.com/github/spec-kit) for Spec-Driven Development. Build high-quality software faster.

---

Table of Contents

• 🤔 What is Spec-Driven Development?
• 💡 Why SpecLite?
• ✨ SpecLite Improvements over Spec Kit
• ⚡ Get Started
• 🤖 Supported AI Agents
• 🔧 SpecLite CLI Reference
• 📚 Core Philosophy
• 🌟 Development Phases
• 🔧 Prerequisites
• 📚 Documentation
• 📋 Detailed Process
• 🔍 Troubleshooting
• 💬 Support
• 🙏 Acknowledgements
• 📄 License

🤔 What is Spec-Driven Development?

Spec-Driven Development flips the script on traditional software development. For decades, code has been king — specifications were just scaffolding we built and discarded once the "real work" of coding began. Spec-Driven Development changes this: specifications become executable, directly generating working implementations rather than just guiding them.

💡 Why SpecLite?

GitHub Spec Kit is a widely used toolkit for Spec-Driven Development. Some teams find it heavyweight for day-to-day work, and it doesn't clearly separate point-in-time change artifacts from long-lived "living specs" that stay updated as a project evolves.

SpecLite started as a fork of Spec Kit to address those gaps while keeping the core workflow: lighter defaults when you want simplicity, full power when you need it, plus smoother updates and support for multi-agent workflows (like using one model to review another).

✨ SpecLite Improvements over Spec Kit

Living Specs vs. Change History

Spec Kit stores specs and their associated plans/tasks/notes in a specs/ directory. But these files capture point-in-time work—they aren't intended to be long-term living documents kept up to date as the project evolves.

SpecLite separates these concerns:

Directory	Purpose
.speclite/changes/	Historical artifacts—full specs, plans, and tasks for each change (same structure as Spec Kit, renamed to reflect its purpose)
specs/	Living documentation—summary specs you maintain long-term

When you make a change, both locations update: .speclite/changes/ captures the full details, while specs/ receives only the high-level updates worth preserving. .speclite/changes/ is an archive you can keep committed or prune over time.

Additional Improvements

Improvement	Description
Review command	New /sl.review command to review current-branch changes against the spec and acceptance criteria
Multi-agent support	Configure multiple AI agents per project—useful for cross-agent reviews or when team members use different tools
Better updates	Template customizations (and constitution.md) are preserved on updates; guided merge workflow when upstream defaults change
Simplified versioning	Single version number for CLI and templates (Spec Kit has separate versions)
Bug fixes	Various fixes to Spec Kit issues (change number duplication, template newlines, etc.)

What Stays the Same

If you're familiar with Spec Kit, you'll feel right at home:

• Same core workflow — specify, plan, tasks, implement, and other commands work the same way (just with /sl. prefix instead of /speckit.)
• Same default templates — The spec, plan, and task templates (and prompt instructions) are largely unchanged, so you get the same structured output out of the box (with better support for per-project customization).

⚡ Get Started

1. Install SpecLite in your project

Use the SpecLite CLI to add SpecLite to your project.

SpecLite (like Spec Kit) uses uv to easily run Python tools. If you don’t already have uv installed, follow the official installation instructions: https://docs.astral.sh/uv/getting-started/installation/

# Run from your project's root directory
uvx speclite-cli install

# Check installed tools
uvx speclite-cli check

During installation, SpecLite:

• Prompts you to select the AI agent(s) you want to use (or pass --ai to specify them up front).
• Adds a .speclite/ directory to your project and generates agent-specific files as needed, including custom prompts/commands in locations like .claude/commands/ and .github/prompts/.

Later, to update SpecLite to the latest version in your project, just re-run uvx speclite-cli install.

2. Establish project principles

Launch your AI assistant in the project directory. The /sl.* commands are available in the assistant.

Use the /sl.constitution command to create your project's governing principles and development guidelines that will guide all subsequent development.

/sl.constitution Create principles focused on code quality, testing standards, user experience consistency, and performance requirements

3. Create the spec

Use the /sl.specify command to describe what you want to build. Focus on the what and why, not the tech stack.

/sl.specify Build an application that can help me organize my photos in separate photo albums. Albums are grouped by date and can be re-organized by dragging and dropping on the main page. Albums are never in other nested albums. Within each album, photos are previewed in a tile-like interface.

4. Create a technical implementation plan

Use the /sl.plan command to provide your tech stack and architecture choices.

/sl.plan The application uses Vite with minimal number of libraries. Use vanilla HTML, CSS, and JavaScript as much as possible. Images are not uploaded anywhere and metadata is stored in a local SQLite database.

5. Break down into tasks

Use /sl.tasks to create an actionable task list from your implementation plan.

/sl.tasks

6. Execute implementation

Use /sl.implement to execute all tasks and build your feature according to the plan.

/sl.implement

For detailed step-by-step instructions, see our comprehensive guide.

🤖 Supported AI Agents

Agent	Support	Notes
Claude Code	✅
Codex CLI	✅
Cursor	✅
Gemini CLI	✅
GitHub Copilot	✅

SpecLite currently supports a focused set of AI agents, fewer than Spec Kit, to keep testing simple. If the agent you want to use isn't listed, open an issue requesting it be added.

🔧 SpecLite CLI Reference

The speclite-cli command supports the following options:

Commands

Command	Description
install	Install or update SpecLite in the current project
check	Check for installed tools (git, claude, gemini, code/code-insiders, cursor-agent, codex)

speclite-cli install Arguments & Options

Argument/Option	Type	Description
--ai	Option	AI assistant(s) to use (comma-separated): claude, gemini, copilot, cursor-agent, or codex
--script	Option	Script variant to use: sh (bash/zsh) or ps (PowerShell)
--ignore-agent-tools	Flag	Skip checks for AI agent tools like Claude Code
--debug	Flag	Enable detailed debug output for troubleshooting

Examples

# Basic installation (interactive AI selection)
uvx speclite-cli install

# Install with specific AI assistant(s)
uvx speclite-cli install --ai claude
uvx speclite-cli install --ai claude,codex

# Install with Cursor support
uvx speclite-cli install --ai cursor-agent

# Install with Codex support
uvx speclite-cli install --ai codex

# Install with PowerShell scripts (Windows/cross-platform)
uvx speclite-cli install --ai copilot --script ps

# Enable debug output for troubleshooting
uvx speclite-cli install --ai claude --debug

# Check system requirements
uvx speclite-cli check

Available Slash Commands

After running uvx speclite-cli install, your AI coding agent will have access to these slash commands for structured development:

Core Commands

Essential commands for the Spec-Driven Development workflow:

Command	Description
/sl.constitution	Create or update project governing principles and development guidelines
/sl.specify	Define what you want to build (requirements and user stories)
/sl.plan	Create technical implementation plans with your chosen tech stack
/sl.tasks	Generate actionable task lists for implementation
/sl.implement	Execute all tasks to build the feature according to the plan

Optional Commands

Additional commands for enhanced quality and validation:

Command	Description
/sl.clarify	Clarify underspecified areas (recommended before /sl.plan)
/sl.analyze	Cross-artifact consistency & coverage analysis (run after /sl.tasks, before /sl.implement)
/sl.checklist	Generate custom quality checklists that validate requirements completeness, clarity, and consistency (like "unit tests for English")
/sl.review	Review implementation changes in the current branch against the feature spec and acceptance criteria

Environment Variables

Variable	Description
SPECLITE_FEATURE	Override feature detection for non-Git repositories. Set to the feature directory name (e.g., 001-photo-albums) to work on a specific feature when not using Git branches. **Must be set in the context of the agent you're working with prior to using /sl.plan or follow-up commands.

📚 Core Philosophy

Spec-Driven Development is a structured process that emphasizes:

• Intent-driven development where specifications define the "what" before the "how"
• Rich specification creation using guardrails and organizational principles
• Multi-step refinement rather than one-shot code generation from prompts
• Heavy reliance on advanced AI model capabilities for specification interpretation

🌟 Development Phases

Phase	Focus	Key Activities
0-to-1 Development ("Greenfield")	Generate from scratch	Start with high-level requirements Generate specifications Plan implementation steps Build production-ready applications
Creative Exploration	Parallel implementations	Explore diverse solutions Support multiple technology stacks & architectures Experiment with UX patterns
Iterative Enhancement ("Brownfield")	Brownfield modernization	Add features iteratively Modernize legacy systems Adapt processes

🔧 Prerequisites

• Linux/macOS/Windows
• Supported AI coding agent.
• uv for package management
• Python 3.11+
• Git

If you encounter issues with an agent, please open an issue so we can refine the integration.

📚 Documentation

This README is the primary documentation entry point. The links below take you to the supporting guides in docs/.

• Documentation Home - Entry point for the docs collection
• Installation - Prerequisites and setup
• Quickstart - Fast path to your first SpecLite project
• Upgrade Guide - Updating the CLI and templates
• Contributing - Contributing and working on the CLI
• Spec-Driven Development Methodology - Deep dive into the full process

---

📋 Detailed Process

Click to expand the detailed step-by-step walkthrough

You can use the SpecLite CLI to install or update SpecLite in an existing project. Run from inside your project directory:

uvx speclite-cli install

You will be prompted to select the AI agent(s) you are using. You can also proactively specify them directly in the terminal (comma-separated):

uvx speclite-cli install --ai claude
uvx speclite-cli install --ai gemini
uvx speclite-cli install --ai copilot
uvx speclite-cli install --ai claude,codex

The CLI will check if you have the required CLIs for your selected agents (Claude Code, Gemini CLI, Cursor CLI, or Codex CLI). If you do not, or you prefer to get the templates without checking for the right tools, use --ignore-agent-tools with your command:

uvx speclite-cli install --ai claude --ignore-agent-tools

STEP 1: Establish project principles

Go to the project folder and run your AI agent.

You will know that things are configured correctly if you see the /sl.constitution, /sl.specify, /sl.plan, /sl.tasks, and /sl.implement commands available.

The first step should be establishing your project's governing principles using the /sl.constitution command. This helps ensure consistent decision-making throughout all subsequent development phases:

/sl.constitution Create principles focused on code quality, testing standards, user experience consistency, and performance requirements. Include governance for how these principles should guide technical decisions and implementation choices.

This step creates or updates the .speclite/memory/constitution.md file with your project's foundational guidelines that the AI agent will reference during specification, planning, and implementation phases.

STEP 2: Create project specifications

With your project principles established, you can now create the functional specifications. Use the /sl.specify command and then provide the concrete requirements for the project you want to develop.

[!IMPORTANT] Be as explicit as possible about what you are trying to build and why. Do not focus on the tech stack at this point.

An example prompt:

Develop Taskify, a team productivity platform. It should allow users to create projects, add team members,
assign tasks, comment and move tasks between boards in Kanban style. In this initial phase for this feature,
let's call it "Create Taskify," let's have multiple users but the users will be declared ahead of time, predefined.
I want five users in two different categories, one product manager and four engineers. Let's create three
different sample projects. Let's have the standard Kanban columns for the status of each task, such as "To Do,"
"In Progress," "In Review," and "Done." There will be no login for this application as this is just the very
first testing thing to ensure that our basic features are set up. For each task in the UI for a task card,
you should be able to change the current status of the task between the different columns in the Kanban work board.
You should be able to leave an unlimited number of comments for a particular card. You should be able to, from that task
card, assign one of the valid users. When you first launch Taskify, it's going to give you a list of the five users to pick
from. There will be no password required. When you click on a user, you go into the main view, which displays the list of
projects. When you click on a project, you open the Kanban board for that project. You're going to see the columns.
You'll be able to drag and drop cards back and forth between different columns. You will see any cards that are
assigned to you, the currently logged in user, in a different color from all the other ones, so you can quickly
see yours. You can edit any comments that you make, but you can't edit comments that other people made. You can
delete any comments that you made, but you can't delete comments anybody else made.

After this prompt is entered, you should see Claude Code kick off the planning and spec drafting process. Claude Code will also trigger some of the built-in scripts to set up the repository.

Once this step is completed, you should have a new branch created (e.g., 001-create-taskify), as well as a new specification in the .speclite/changes/001-create-taskify directory. The top-level specs/ directory is reserved for living specs you keep up to date over time.

The produced specification should contain a set of user stories and functional requirements, as defined in the template.

At this stage, your project folder contents should resemble the following:

└── .speclite
    ├── memory
    │  └── constitution.md
    ├── scripts
    │  ├── check-prerequisites.sh
    │  ├── common.sh
    │  ├── create-new-feature.sh
    │  ├── setup-plan.sh
    │  └── update-claude-md.sh
    ├── changes
    │  └── 001-create-taskify
    │      └── spec.md
    └── templates
        ├── plan-template.md
        ├── spec-template.md
        └── tasks-template.md

STEP 3: Functional specification clarification (required before planning)

With the baseline specification created, you can go ahead and clarify any of the requirements that were not captured properly within the first shot attempt.

You should run the structured clarification workflow before creating a technical plan to reduce rework downstream.

Preferred order:

1. Use /sl.clarify (structured) – sequential, coverage-based questioning that records answers in a Clarifications section.
2. Optionally follow up with ad-hoc free-form refinement if something still feels vague.

If you intentionally want to skip clarification (e.g., spike or exploratory prototype), explicitly state that so the agent doesn't block on missing clarifications.

Example free-form refinement prompt (after /sl.clarify if still needed):

For each sample project or project that you create there should be a variable number of tasks between 5 and 15
tasks for each one randomly distributed into different states of completion. Make sure that there's at least
one task in each stage of completion.

You should also ask Claude Code to validate the Review & Acceptance Checklist, checking off the things that are validated/pass the requirements, and leave the ones that are not unchecked. The following prompt can be used:

Read the review and acceptance checklist, and check off each item in the checklist if the feature spec meets the criteria. Leave it empty if it does not.

It's important to use the interaction with Claude Code as an opportunity to clarify and ask questions around the specification - do not treat its first attempt as final.

STEP 4: Generate a plan

You can now be specific about the tech stack and other technical requirements. You can use the /sl.plan command that is built into the project template with a prompt like this:

We are going to generate this using .NET Aspire, using Postgres as the database. The frontend should use
Blazor server with drag-and-drop task boards, real-time updates. There should be a REST API created with a projects API,
tasks API, and a notifications API.

The output of this step will include a number of implementation detail documents, with your directory tree resembling this:

.
├── CLAUDE.md
├── .speclite
│  ├── changes
│  │  └── 001-create-taskify
│  │     ├── contracts
│  │     │  ├── api-spec.json
│  │     │  └── signalr-spec.md
│  │     ├── data-model.md
│  │     ├── plan.md
│  │     ├── quickstart.md
│  │     ├── research.md
│  │     └── spec.md
│  ├── memory
│  │  └── constitution.md
│  ├── scripts
│  │  ├── check-prerequisites.sh
│  │  ├── common.sh
│  │  ├── create-new-feature.sh
│  │  ├── setup-plan.sh
│  │  └── update-claude-md.sh
│  └── templates
│     ├── CLAUDE-template.md
│     ├── plan-template.md
│     ├── spec-template.md
│     └── tasks-template.md

Check the research.md document to ensure that the right tech stack is used, based on your instructions. You can ask Claude Code to refine it if any of the components stand out, or even have it check the locally-installed version of the platform/framework you want to use (e.g., .NET).

Additionally, you might want to ask Claude Code to research details about the chosen tech stack if it's something that is rapidly changing (e.g., .NET Aspire, JS frameworks), with a prompt like this:

I want you to go through the implementation plan and implementation details, looking for areas that could
benefit from additional research as .NET Aspire is a rapidly changing library. For those areas that you identify that
require further research, I want you to update the research document with additional details about the specific
versions that we are going to be using in this Taskify application and spawn parallel research tasks to clarify
any details using research from the web.

During this process, you might find that Claude Code gets stuck researching the wrong thing - you can help nudge it in the right direction with a prompt like this:

I think we need to break this down into a series of steps. First, identify a list of tasks
that you would need to do during implementation that you're not sure of or would benefit
from further research. Write down a list of those tasks. And then for each one of these tasks,
I want you to spin up a separate research task so that the net results is we are researching
all of those very specific tasks in parallel. What I saw you doing was it looks like you were
researching .NET Aspire in general and I don't think that's gonna do much for us in this case.
That's way too untargeted research. The research needs to help you solve a specific targeted question.

[!NOTE] Claude Code might be over-eager and add components that you did not ask for. Ask it to clarify the rationale and the source of the change.

STEP 5: Have Claude Code validate the plan

With the plan in place, you should have Claude Code run through it to make sure that there are no missing pieces. You can use a prompt like this:

Now I want you to go and audit the implementation plan and the implementation detail files.
Read through it with an eye on determining whether or not there is a sequence of tasks that you need
to be doing that are obvious from reading this. Because I don't know if there's enough here. For example,
when I look at the core implementation, it would be useful to reference the appropriate places in the implementation
details where it can find the information as it walks through each step in the core implementation or in the refinement.

This helps refine the implementation plan and helps you avoid potential blind spots that Claude Code missed in its planning cycle. Once the initial refinement pass is complete, ask Claude Code to go through the checklist once more before you can get to the implementation.

You can also ask Claude Code (if you have the GitHub CLI installed) to go ahead and create a pull request from your current branch to main with a detailed description, to make sure that the effort is properly tracked.

[!NOTE] Before you have the agent implement it, it's also worth prompting Claude Code to cross-check the details to see if there are any over-engineered pieces (remember - it can be over-eager). If over-engineered components or decisions exist, you can ask Claude Code to resolve them. Ensure that Claude Code follows the constitution as the foundational piece that it must adhere to when establishing the plan.

STEP 6: Generate task breakdown with /sl.tasks

With the implementation plan validated, you can now break down the plan into specific, actionable tasks that can be executed in the correct order. Use the /sl.tasks command to automatically generate a detailed task breakdown from your implementation plan:

/sl.tasks

This step creates a tasks.md file in your feature specification directory that contains:

• Task breakdown organized by user story - Each user story becomes a separate implementation phase with its own set of tasks
• Dependency management - Tasks are ordered to respect dependencies between components (e.g., models before services, services before endpoints)
• Parallel execution markers - Tasks that can run in parallel are marked with [P] to optimize development workflow
• File path specifications - Each task includes the exact file paths where implementation should occur
• Test-driven development structure - If tests are requested, test tasks are included and ordered to be written before implementation
• Checkpoint validation - Each user story phase includes checkpoints to validate independent functionality

The generated tasks.md provides a clear roadmap for the /sl.implement command, ensuring systematic implementation that maintains code quality and allows for incremental delivery of user stories.

STEP 7: Implementation

Once ready, use the /sl.implement command to execute your implementation plan:

/sl.implement

The /sl.implement command will:

• Validate that all prerequisites are in place (constitution, spec, plan, and tasks)
• Parse the task breakdown from tasks.md
• Execute tasks in the correct order, respecting dependencies and parallel execution markers
• Follow the TDD approach defined in your task plan
• Provide progress updates and handle errors appropriately

[!IMPORTANT] The AI agent will execute local CLI commands (such as dotnet, npm, etc.) - make sure you have the required tools installed on your machine.

Once the implementation is complete, test the application and resolve any runtime errors that may not be visible in CLI logs (e.g., browser console errors). You can copy and paste such errors back to your AI agent for resolution.

STEP 8: Review implementation

For the best feedback, switch to a different AI agent for review than you used for implementation (an independent verification). Then run the /sl.review command to verify that the implementation is correct and matches the specification:

/sl.review

This creates a review.md file with a checklist of issues discovered, each with a unique ID. Then switch back to the implementor agent and prompt it to fix the issues you want to address, checking them off as you go.

---

🔍 Troubleshooting

Git Credential Manager on Linux

If you're having issues with Git authentication on Linux, you can install Git Credential Manager:

#!/usr/bin/env bash
set -e
echo "Downloading Git Credential Manager v2.6.1..."
wget https://github.com/git-ecosystem/git-credential-manager/releases/download/v2.6.1/gcm-linux_amd64.2.6.1.deb
echo "Installing Git Credential Manager..."
sudo dpkg -i gcm-linux_amd64.2.6.1.deb
echo "Configuring Git to use GCM..."
git config --global credential.helper manager
echo "Cleaning up..."
rm gcm-linux_amd64.2.6.1.deb

💬 Support

For support, please open a GitHub issue. We welcome bug reports, feature requests, and questions about using Spec-Driven Development.

🙏 Acknowledgements

This project is a fork of GitHub Spec Kit, which was in turn heavily influenced by and based on the work and research of John Lam.

📄 License

This project is licensed under the terms of the MIT open source license. Please refer to the LICENSE file for the full terms.