What is this?

AI DevKit is a unified CLI that provisions AI coding tools across your projects. Instead of manually configuring Claude Code, Cursor, and OpenCode separately—copying files, setting up MCP servers, adding rules—run one command and ship faster.

bunx ai-devkit init

Select your tools, pick your MCP servers, choose skills and commands. Done.

Quick Start

Prerequisites

• Bun (v1.0+) or Node.js (v18+)

Install & Run

# Run directly (no install needed)
bunx ai-devkit

# Or install globally
bun add -g ai-devkit
adk init

Interactive Setup

The CLI guides you through:

1. Select AI tools — Claude Code, Cursor, OpenCode
2. Pick MCP servers — Context7, Exa, Supabase, Morph, AST-Grep, Perplexity, Convex
3. Choose skills — Frontend design, TDD, debugging, code search
4. Install commands — /deslop, /onboard, /security-audit, and more
5. Add rules — Convex guidelines, UV package management
6. Configure extras — Beads, Continuous Claude (CC only), Safety Net (CC only)

Features

🛠 Multi-Tool Support

| Tool | What Gets Installed | |------|---------------------| | Claude Code | .claude/ directory with commands, skills, MCP config | | Cursor | .cursor/ directory with commands, MCP config, rules | | OpenCode | AGENTS.md, commands, skills |

🔌 MCP Server Registry

Pre-configured MCP servers ready to install:

| Server | Description | |--------|-------------| | Context7 | Up-to-date documentation lookup for any library | | Exa | Web search, code context, and research tools | | Supabase | Database operations via Supabase | | Morph | Fast codebase search (20x faster than grep) | | AST-Grep | AST-based code search and refactoring | | Perplexity | AI-powered web search and reasoning | | AI Elements | Access to the AI SDK component registry | | Convex | Convex database operations |

📦 Skills Library

Skills are reusable instructions that enhance AI capabilities:

| Skill | Purpose | |-------|---------| | frontend-design | Create distinctive, production-grade UIs that avoid generic "AI slop" | | test-driven-development | Enforce red-green-refactor discipline | | debug | Investigate issues via logs, database, git history | | morph-search | Fast codebase search using WarpGrep | | ast-grep-find | Structural code search with AST patterns | | qlty-check | Code quality, linting, and formatting via qlty CLI |

⚡ Slash Commands

Commands are single-action prompts you can invoke:

| Command | What It Does | |---------|--------------| | /deslop | Remove AI-generated code smell from your branch | | /onboard | Comprehensive developer onboarding workflow | | /security-audit | Perform a security review with remediation steps | | /visualize | Generate mermaid diagrams for data lineage | | /interview | Conduct in-depth interviews about feature plans | | /add-documentation | Add comprehensive documentation for code |

📏 Rules Library

Framework-specific guidelines:

| Rule | Scope | |------|-------| | convex | Convex best practices, schema design, function patterns | | uv | Python package management with UV |

Commands

adk init

Bootstrap AI tools into the current project. This is the default command.

adk init
# or just
adk

adk update

Check for updates to installed commands and skills, then selectively apply them.

adk update

adk help

Show usage information.

adk help

Skills

Skills are markdown files that provide specialized instructions to AI assistants. They're installed to .claude/skills/ (Claude Code) or referenced in AGENTS.md (OpenCode).

Frontend Design

Creates distinctive, production-grade interfaces. Enforces:

• Bold aesthetic direction — brutally minimal, maximalist, retro-futuristic, etc.
• Distinctive typography — no generic Inter/Roboto/Arial
• Motion and micro-interactions — scroll-triggering, hover states
• Unique spatial composition — asymmetry, overlap, grid-breaking

Test-Driven Development

Enforces the TDD discipline:

NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST

• Write test → Watch it fail → Write minimal code → Refactor
• No exceptions, no rationalizations

Debug

Investigate issues without editing files:

• Check logs, database state, git history
• Spawn parallel investigation tasks
• Present structured debug reports

Code Search Skills

• morph-search: 20x faster text/regex search via WarpGrep
• ast-grep-find: Structural code search that understands syntax
• qlty-check: Universal linting, formatting, and metrics

MCP Servers

MCP (Model Context Protocol) servers extend AI capabilities. The devkit includes a curated registry in mcp/servers.json.

Configuration

Servers are installed to:

• Claude Code: .mcp.json
• Cursor: .cursor/mcp.json

Environment Variables

Some servers require API keys:

# Supabase
export SUPABASE_ACCESS_TOKEN="your-token"

# Morph (WarpGrep)
export MORPH_API_KEY="your-key"

# Perplexity
export PERPLEXITY_API_KEY="your-key"

Rules

Rules are framework-specific guidelines installed as markdown files.

Convex Rules

Comprehensive guidelines for Convex projects:

• Function syntax (new format with validators)
• HTTP endpoint registration
• Schema design patterns
• Query and mutation best practices
• Full-text search, pagination, scheduling
• TypeScript typing with Id<"table">

UV Rules

Python package management with UV:

uv add <package>     # Add dependencies
uv remove <package>  # Remove dependencies
uv sync              # Reinstall from lockfile
uv run script.py     # Run with dependencies

Safety Net (Claude Code Only)

The devkit includes Claude Code Safety Net by kenryu42 — a protection layer that blocks destructive commands before they execute. This feature is automatically installed when you select Claude Code during adk init.

Why It Exists

AI agents can accidentally run commands like:

• git reset --hard — destroys uncommitted changes
• git checkout -- file — discards changes permanently
• rm -rf ~/ — catastrophic file deletion
• git push --force — destroys remote history

What Gets Blocked

| Category | Examples | |----------|----------| | Git destructive | git reset --hard, git checkout -- files, git clean -f | | Git history | git push --force, git branch -D, git stash clear | | File deletion | rm -rf outside cwd, rm -rf /, rm -rf ~ | | Dynamic execution | xargs rm -rf, find -delete, shell wrappers |

What's Allowed

| Category | Examples | |----------|----------| | Safe git | git checkout -b, git restore --staged, git branch -d | | Safe deletion | rm -rf /tmp/*, rm -rf ./build (within cwd) | | Preview | git clean -n, --dry-run variants |

Custom Rules

Create .safety-net.json in your project:

{
  "version": 1,
  "rules": [
    {
      "name": "block-git-add-all",
      "command": "git",
      "subcommand": "add",
      "block_args": ["-A", "--all", "."],
      "reason": "Use 'git add <specific-files>' instead."
    }
  ]
}

Project Structure

ai-devkit/
├── src/
│   ├── cli.ts              # Entry point
│   ├── commands/
│   │   ├── init.ts         # Interactive setup
│   │   └── update.ts       # Update checker
│   ├── installers/
│   │   ├── claude.ts       # Claude Code installer
│   │   ├── cursor.ts       # Cursor installer
│   │   ├── opencode.ts     # OpenCode installer
│   │   ├── mcp.ts          # MCP server installer
│   │   ├── rules.ts        # Rules installer
│   │   ├── beads.ts        # Beads issue tracker
│   │   ├── safety-net.ts   # Safety Net (CC only)
│   │   └── continuous-claude.ts  # (CC only)
│   └── utils/
├── commands/               # Slash command templates
├── skills/                 # Skill definitions
├── rules/                  # Framework rules
├── mcp/
│   └── servers.json        # MCP server registry
└── claude-code-safety-net/ # Safety net plugin

Development

Setup

bun install

Run Locally

bun run dev

Type Check

bun run typecheck

Build

bun run build

Extras

Beads Integration

Beads is an issue tracker designed for AI agents. The CLI can:

• Full setup: Install CLI, initialize beads, configure hooks
• MCP only: Just add the beads MCP server

Continuous Claude

Based on Continuous Claude v2 — session continuity for Claude Code with:

• thoughts/ directory for persistent context
• Ledgers for tracking work
• Handoff notes between sessions

Contributing

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Run type checks: bun run typecheck
5. Submit a pull request

License

MIT