ADAPT Method

ADAPT: Agent Development & Personalization Toolkit

Create specialized Claude agents for your projects in 5 minutes

What is ADAPT?

ADAPT is a lean toolkit that helps developers create specialized AI agents for Claude Code, Cursor, or Windsurf. Instead of repeating instructions in every session, create reusable agents with custom context and behaviors.

The Problem

• Developers repeat the same instructions to Claude in each session
• Context overflow from copying docs repeatedly
• No consistency between sessions
• Hard to specialize Claude for specific tasks

The Solution

• Create specialized agents on demand
• Load context automatically from .docs/
• Consistent behavior every time
• Share agents across your team

Quick Start

Install in Your IDE

ADAPT works with Claude Code, Cursor, and Windsurf:

Claude Code (Recommended)

# Auto-detects Claude Code
npx adapt-method install

Cursor

# Specify Cursor IDE
npx adapt-method install --ide cursor

Windsurf

# Specify Windsurf IDE
npx adapt-method install --ide windsurf

This creates:

• .claude/commands/smith.md - Agent-Smith (creates other agents) *
• .claude/commands/architect.md - The Architect (creates documentation) *
• .docs/tech-stack.md - Default documentation (loaded by all agents)
• .agent-smith/config.yaml - Configuration

* For Cursor, agents go in .cursor/commands/. For Windsurf, agents go in .windsurf/commands/

Update Existing Installation

Already have ADAPT installed? Update to the latest version:

npx adapt-method update

Note: Agents you created need to be manually recreated to get new features. The update command will show you how.

Create Your First Agent

1. Open your project in Claude Code
2. Type /smith
3. Follow the interactive interview (5 questions)
4. Your agent is ready to use!

# Example: Create a database optimizer agent
/smith

# Answer questions:
ID: db-optimizer
Purpose: Optimize SQL queries and database schema
Commands: [auto-suggested based on purpose]
Docs: tech-stack.md, db-schema.md
Behavior: Concise, Confirm first

# Use your new agent
/db-optimizer

📚 Documentation

For Developers

• Quick Reference - Command cheat sheet and common workflows
• Training Guide - Complete guide to train your team
• Visual Flow Diagrams - Mermaid diagrams explaining ADAPT usage
• Getting Started - Step-by-step beginner guide

For Managers

Want to introduce ADAPT to your team?

1. Read the Training Guide to understand adoption strategy
2. Review Visual Diagrams to see the complete workflow
3. Share Quick Reference with your developers

Expected Results:

• ✅ 10x productivity in specialized tasks
• ✅ Consistent code patterns across team
• ✅ 50% faster onboarding of new developers
• ✅ 30% reduction in code review comments

Features

Two Core Agents

Agent-Smith - The meta-agent that creates other agents

• Interactive 5-question interview
• Auto-suggests commands based on purpose
• Validates documentation requirements
• Generates complete agent YAML
• Integrates with Architect for missing docs

The Architect - Documentation builder

• Auto-scans your project tech stack
• Creates structured documentation from templates
• Extracts info from existing files (Prisma, configs)
• Generates AI-optimized docs for agents

Key Capabilities

• Auto-detection - Scans project to detect framework, database, testing tools
• Template-based - 5 essential doc templates included
• Context-aware - Maximum 5 docs per agent (anti-overflow)
• Validation - Ensures docs exist and schema is valid
• Versionable - Migration system for schema upgrades
• IDE-agnostic - Works with Claude Code, Cursor, Windsurf

CLI Commands

ADAPT provides 7 powerful commands:

Installation & Setup

# Install ADAPT in current project
npx adapt-method install

# Install with specific IDE
npx adapt-method install --ide claude-code

# Force overwrite existing files
npx adapt-method install --force

Agent & Doc Creation

# Create a new specialized agent (interactive)
npx adapt-method create-agent

# Create documentation (interactive)
npx adapt-method create-doc

# Scan project tech stack
npx adapt-method scan

# Scan and output as JSON
npx adapt-method scan --json

Management

# Check versions and migration status
npx adapt-method check

# List all created agents
npx adapt-method list

# List with details
npx adapt-method list --verbose

# Migrate agents to latest schema
npx adapt-method migrate

# Dry run migration
npx adapt-method migrate --dry-run

Example Workflows

Complete setup from scratch:

# 1. Install ADAPT
npx adapt-method install

# 2. Scan your project
npx adapt-method scan

# 3. Create documentation
npx adapt-method create-doc
# → Select: db-schema (auto-extracts from Prisma)

# 4. Create your first agent
npx adapt-method create-agent
# → ID: db-optimizer
# → Purpose: Optimize database queries
# → Commands: [auto-suggested]
# → Docs: tech-stack.md, db-schema.md

# 5. Use your agent in Claude Code
# /db-optimizer optimize-query

Architecture

File Structure (Post-Install)

your-project/
├── .claude/
│   └── commands/
│       ├── smith.md              # Agent-Smith
│       ├── architect.md          # The Architect
│       └── agents/               # Your created agents
│           ├── db-optimizer.md
│           └── frontend-expert.md
│
├── .docs/                        # Context repository
│   ├── tech-stack.md             # Default (always loaded)
│   ├── db-schema.md              # Created by Architect
│   ├── api-contracts.md
│   └── component-library.md
│
├── .agent-smith/
│   ├── config.yaml               # Configuration
│   ├── templates/                # Local templates (optional)
│   └── backups/                  # Auto-backups
│
├── src/                          # Your actual project
└── package.json

Agent Schema

Each agent is a markdown file with embedded YAML:

schema_version: 1
generated_by: [email protected]
generated_at: 2025-01-21T10:00:00Z

agent:
  name: Daniel
  id: db-optimizer
  title: Database Optimization Specialist
  icon: 🗄️
  whenToUse: Use for SQL query optimization and schema design

persona:
  role: Database Performance Expert
  style: Concise, analytical
  identity: Specialist in PostgreSQL and Prisma optimization
  focus: Query performance, indexing strategy, schema design

commands:
  - optimize-query: Analyze and optimize SQL queries
  - review-schema: Review database schema design
  - suggest-indexes: Suggest strategic indexes

dependencies:
  data:
    - .docs/tech-stack.md
    - .docs/db-schema.md

Use Cases

Database Optimization

/smith
ID: db-optimizer
Purpose: Optimize PostgreSQL queries and Prisma schema
Docs: tech-stack.md, db-schema.md

# Then use:
/db-optimizer optimize-query

Frontend Development

/smith
ID: frontend-expert
Purpose: Create React components following design system
Docs: tech-stack.md, component-library.md, styling-guide.md

# Then use:
/frontend-expert create-component

API Development

/smith
ID: api-builder
Purpose: Create RESTful API endpoints with proper validation
Docs: tech-stack.md, api-contracts.md, db-schema.md

# Then use:
/api-builder create-endpoint

Testing

/smith
ID: test-specialist
Purpose: Generate comprehensive test suites with Vitest
Docs: tech-stack.md, test-strategy.md, component-library.md

# Then use:
/test-specialist write-test

Documentation Templates

The Architect includes 5 essential templates:

1. tech-stack.md (mandatory) - Framework, language, database, testing
2. db-schema.md - Database structure (auto-extracted from Prisma)
3. api-contracts.md - API endpoints (auto-extracted from routes)
4. component-library.md - Reusable components (auto-scanned)
5. test-strategy.md - Testing approach (auto-detected from configs)

Create custom documentation:

/architect
→ Custom doc: "Prisma migration best practices"
→ Architect asks contextual questions
→ Generates .docs/migration-practices.md

Philosophy

Design Principles

1. Lean over Complete - Minimum necessary, maximum impact
2. User Control - Developer always in control, zero imposition
3. Adapt, Don't Force - Adapts to existing workflow
4. Context Conscious - Maximum 5 docs per agent (anti-overflow)
5. Quick to Value - Functional agent in < 5 minutes

vs B-MAD Method

| B-MAD | ADAPT | |-------|-------| | Complete methodology (10 agents) | Lean toolkit (2 agents) | | Rigid workflow | Flexible, user-controlled | | Structured teams | Autonomous developers | | Steep learning curve | Gentle quickstart |

ADAPT is inspired by B-MAD but designed for solo developers and small teams who want the power of specialized agents without the overhead.

Requirements

• Node.js >= 18
• One of: Claude Code, Cursor, or Windsurf
• Git (recommended for version control)

Development

Setup

# Clone repo
git clone https://github.com/adapt-method/adapt-method.git
cd adapt-method

# Install dependencies
npm install

# Run tests
npm test

# Run locally
node bin/cli.js install

Project Structure

adapt-method/
├── bin/cli.js                    # CLI entry point
├── lib/
│   ├── installer.js              # Installation logic
│   ├── generators/
│   │   ├── agent-generator.js    # Smith engine
│   │   └── doc-generator.js      # Architect engine
│   └── utils/
│       ├── project-scanner.js    # Auto-detect tech stack
│       └── validator.js          # Schema validation
├── templates/
│   ├── agents/
│   │   ├── smith.md              # Agent-Smith template
│   │   └── architect.md          # Architect template
│   ├── agent-templates/          # Generated agent templates
│   └── doc-templates/            # Doc templates
└── tests/

Roadmap

v1.0.0 (Current)

• [x] CLI with install command
• [x] Agent-Smith (agent creation)
• [x] The Architect (doc creation)
• [x] Auto-detection of tech stack
• [x] 5 essential doc templates
• [x] Schema validation

v1.1.0 (Planned)

• [ ] Agent marketplace (share agents)
• [ ] VS Code extension
• [ ] More doc templates (10 total)
• [ ] Interactive web UI for agent creation
• [ ] Team collaboration features

v2.0.0 (Future)

• [ ] Multi-agent workflows
• [ ] Agent performance analytics
• [ ] Context optimization suggestions
• [ ] Integration with other AI tools

Contributing

Contributions welcome! Please read CONTRIBUTING.md first.

Areas for Contribution

• New doc templates
• Additional auto-detection logic
• IDE integrations (VS Code, etc)
• Documentation improvements
• Bug fixes

License

MIT License - see LICENSE for details.

Support

• Documentation: docs/
• Issues: GitHub Issues
• Discussions: GitHub Discussions

Acknowledgments

Inspired by B-MAD Method by Cole Medin.

Built with:

• Commander.js - CLI framework
• Inquirer.js - Interactive prompts
• Handlebars - Template engine
• Chalk - Terminal styling

Made with ❤️ by the ADAPT Team

Start creating specialized agents today: npx adapt-method install