Skip to main content
Get started with Agent Teams Lite in three simple steps: install the skills, configure your AI assistant, and start building.

​
Prerequisites

You need one of these AI assistants:

Claude Code

Full sub-agent support via Task tool

OpenCode

Full sub-agent support via Task tool

Gemini CLI

Inline skill execution

Codex

Inline skill execution

VS Code Copilot

Agent mode with context files

Antigravity

Native skill support

Cursor

Inline skill execution

Other Tools

Any tool that can read Markdown
For the best sub-agent experience with fresh context windows, use Claude Code or OpenCode. Other tools work great but run skills inline.

​
Step 1: Install the Skills

1

Clone the repository

Clone Agent Teams Lite to your local machine:
git clone https://github.com/gentleman-programming/agent-teams-lite.git
cd agent-teams-lite
2

Run the installer

The installer detects your AI tool and copies skills to the right location:
./scripts/install.sh
You’ll see a menu like this:
Select your tool:
1) Claude Code
2) OpenCode
3) Cursor
4) Gemini CLI
5) Codex
6) VS Code (Copilot)
7) Antigravity
8) Other
Choose your tool and the installer will:
  • Copy the 9 sub-agent skills to your tool’s skill directory
  • Copy shared conventions (persistence-contract.md, engram-convention.md, openspec-convention.md)
  • For OpenCode: also install slash commands
3

Verify installation

Check that the skills were copied correctly:
# For Claude Code
ls ~/.claude/skills/sdd-*

# For OpenCode
ls ~/.config/opencode/skills/sdd-*

# For Cursor
ls ~/.cursor/skills/sdd-*
You should see 9 directories: sdd-init, sdd-explore, sdd-propose, sdd-spec, sdd-design, sdd-tasks, sdd-apply, sdd-verify, sdd-archive.

​
Step 2: Add the Orchestrator

The orchestrator is the main agent that coordinates sub-agents. Add it to your AI assistant’s configuration. 
# Append to your existing CLAUDE.md

## Spec-Driven Development (SDD) Orchestrator

You are an orchestrator for the SDD workflow. You delegate all phase work to sub-agents via the Task tool.

### Your Responsibilities
- Detect when SDD is needed (new feature, substantial change)
- Launch sub-agents via Task tool with skill file paths
- Show summaries to user between phases
- Ask for approval before continuing
- Track state: which artifacts exist, what's next

### Sub-Agent Pattern
When launching a sub-agent:
1. Use Task tool with subagent_type: 'general'
2. Pass skill file path: "Read and follow ~/.claude/skills/sdd-{phase}/SKILL.md"
3. Include context: change name, artifact store mode, dependencies
4. Wait for structured result envelope
5. Show executive_summary to user

### Artifact Store Mode
- Default: engram (if available)
- Fallback: none
- Only use openspec if user explicitly requests file artifacts

### Commands
- /sdd-init — Initialize SDD context
- /sdd-new <name> — Start new change (explore → propose)
- /sdd-continue — Run next dependency-ready phase
- /sdd-ff <name> — Fast-forward planning (propose → specs → design → tasks)
- /sdd-apply — Implement tasks
- /sdd-verify — Validate implementation
- /sdd-archive — Close change
See the Installation section for detailed setup instructions for your specific tool.

​
Step 3: Use It

Open your AI assistant in any project and start building!
1

Initialize SDD

Tell your AI assistant to initialize SDD context:
/sdd-init
The orchestrator will:
  • Detect your project’s tech stack
  • Identify conventions (linters, test frameworks)
  • Bootstrap the persistence backend (Engram or OpenSpec)
  • Report what it found
Example output:
## SDD Initialized

**Project**: my-app
**Stack**: React 18 + TypeScript + Tailwind CSS
**Persistence**: engram

### Context Saved
Project context persisted to Engram.
- **Engram ID**: #abc123
- **Topic key**: sdd-init/my-app

No project files created.

### Next Steps
Ready for /sdd-explore <topic> or /sdd-new <change-name>.
2

Start a new feature

Describe what you want to build:
/sdd-new add-dark-mode
The orchestrator will:
  1. Launch Explorer sub-agent to investigate the codebase
  2. Show you the exploration summary
  3. Launch Proposer sub-agent to create a proposal
  4. Show you the proposal and ask if you want to continue
Example flow:
AI:  Launching explorer sub-agent...
     ✓ Codebase analyzed. React + Tailwind detected.
     ✓ Current theme: hardcoded light mode in globals.css
     
     Launching proposal sub-agent...
     ✓ proposal.md created
       Intent: Add dark mode toggle with system preference detection
       Scope: Theme context, toggle component, CSS variables
     
     Want me to continue with specs and design? (or review the proposal first)
3

Continue the workflow

If you approve, continue to the next phases:
Go ahead
Or use the fast-forward command to generate specs, design, and tasks:
/sdd-ff add-dark-mode
The orchestrator will:
  1. Launch Spec Writer and Designer sub-agents in parallel
  2. Show you the specs and design
  3. Launch Task Planner sub-agent
  4. Show you the task breakdown
  5. Ask if you’re ready to implement
Example output:
AI:  ✓ specs/ui/spec.md — 3 requirements, 7 scenarios
     ✓ design.md — CSS variables approach, React Context, localStorage
     ✓ tasks.md — 3 phases, 8 tasks
     
     Ready to implement. Run /sdd-apply to start.
4

Implement the feature

When you’re ready, start implementation:
/sdd-apply
The orchestrator will:
  1. Launch Implementer sub-agent with the first batch of tasks
  2. Write code following the specs and design
  3. Mark tasks as complete
  4. Show progress and ask if you want to continue
Example flow:
AI:  Implementing Phase 1 (Foundation)...
     ✓ 1.1 Created ThemeContext
     ✓ 1.2 Added CSS custom properties
     ✓ 1.3 Added localStorage persistence
     
     3/8 tasks complete. Continue with Phase 2?
5

Verify and archive

After implementation, verify the feature works:
/sdd-verify
The Verifier sub-agent will:
  • Run your test suite (if configured)
  • Compare implementation against every spec scenario
  • Report issues at CRITICAL/WARNING/SUGGESTION levels
When everything looks good, archive the change:
/sdd-archive
The Archiver sub-agent will:
  • Merge delta specs into main specs
  • Move the change to the archive
  • Clean up temporary artifacts

​
Example: Complete Workflow

Here’s a complete example of building a CSV export feature:
1

Initialize

You: /sdd-init

AI: ## SDD Initialized
    **Project**: my-app
    **Stack**: React 18 + TypeScript
    **Persistence**: engram
2

Explore and propose

You: /sdd-new add-csv-export

AI: Launching explorer sub-agent...
    ✓ Found export service (currently JSON only)
    ✓ Recommendation: Extend ExportService with CSV format
    
    Launching proposer sub-agent...
    ✓ proposal.md created
      Intent: Add CSV export format to existing export service
      Scope: ExportService, CSV formatter, download button
      Approach: Add new format option, implement CSV serialization
3

Fast-forward to tasks

You: /sdd-ff add-csv-export

AI: ✓ specs/export/spec.md — Added CSV format requirement
    ✓ design.md — CSV serialization strategy, file naming
    ✓ tasks.md — 2 phases, 5 tasks
    
    Ready to implement.
4

Implement

You: /sdd-apply

AI: Implementing Phase 1 (CSV Formatter)...
    ✓ 1.1 Added CSVFormatter class
    ✓ 1.2 Added header generation
    ✓ 1.3 Added row serialization
    
    Implementing Phase 2 (Integration)...
    ✓ 2.1 Extended ExportService with CSV format
    ✓ 2.2 Added CSV download button
    
    All tasks complete! Run /sdd-verify to validate.
5

Verify and close

You: /sdd-verify

AI: Running tests...
    ✓ All tests passing (42/42)
    ✓ All spec scenarios verified
    No issues found.

You: /sdd-archive

AI: ✓ Delta specs merged into main specs
    ✓ Change moved to archive/2026-03-04-add-csv-export
    Change closed.

​
What’s Next?

How It Works

Understand the orchestrator + sub-agent architecture

Commands Reference

Learn all the SDD commands in detail

Workflow Guide

Master the complete SDD workflow

Persistence Modes

Choose the right artifact storage for your needs

​
Need Help?

Installation Guides

Detailed setup instructions for every supported AI tool

Build docs developers (and LLMs) love

Get started for freeTalk to us