Dev-Suite

A comprehensive AI-powered development toolkit that extends Claude Code with specialized agents, MCP servers, and visual orchestration.

What is Dev-Suite?
Prerequisites
Quick Start
Key Features
Installation Modes
Usage
Configuration
MCP Servers Reference
Agents Reference
Commands Reference
Upgrading
Troubleshooting
Contributing
License

What is Dev-Suite?

Dev-Suite transforms Claude Code into a full-stack development powerhouse by providing:

Specialized Agents - Domain experts for React, Angular, Vue, Svelte, Next.js, Electron, Tauri, Spring Boot, ASP.NET Core, Python, FastAPI, Rust (with arti/rustls/rusqlite/rust_decimal/proptest/rust-supply-chain ecosystem), Go, Deno, modern C++ (C++17/20/23), Windows kernel & driver development (WDF/KMDF/UMDF, HID, IDD), data engineering, RAG (retrieval-augmented generation), industrial automation (DCS/PLC), testing (Vitest/Playwright/pytest/Testcontainers/Maestro/Kotest/Turbine/Paparazzi/Roborazzi/proptest), security, DevOps, cloud (AWS/Azure/GCP), mobile (React Native/Flutter, Kotlin Multiplatform + Compose Multiplatform, native Android with Jetpack Compose + Keystore/Biometric, native iOS with SwiftUI + Keychain/Secure Enclave, Rust ↔ Kotlin/Swift via UniFFI, Java Foreign Memory API + jextract for desktop OS keyring), encrypted storage (SQLCipher, libsodium, age), build & supply chain (Gradle KMP, cargo-ndk, cargo-deny/audit/nextest, Sigstore/Cosign keyless signing, OSV-Scanner, reproducible builds), code quality (detekt, ktlint, Compose Rules), observability (Rust tracing + OpenTelemetry, self-hosted Sentry/GlitchTip), documentation (mdBook + rustdoc + Dokka + Showkase), game development (Unity 2D/3D, URP, Cinemachine, DOTS, Netcode, XR), messaging, creative frontend (Framer Motion, GSAP, Three.js, WebGL), and more
MCP Servers - Extend Claude with tools for documentation (with KB discovery via list_docs), databases, Docker, API testing, logs, performance profiling, security scanning, and more
Skills - Framework-specific knowledge bases with quick-reference guides, covering frontend, backend, databases, testing, infrastructure, messaging, industrial automation, AI/RAG integration, embeddings, vector stores, document processing, animation, 3D graphics, and more
Web Dashboard & Electron App - Visual project configuration with stack detection and component selection
Project Templates - Scaffolding for React, Next.js, Spring Boot, FastAPI, NestJS, Unity 2D, and more
Task Orchestrator - Submit complex multi-agent tasks from the GUI with real-time streaming updates
Custom Agents Builder - Create and edit custom agents directly from the dashboard
Recipes & Automations - Pre-built automation workflows for common development tasks
Hooks Management - Configure Git hooks and Claude Code hooks from the dashboard
Update System - Version visibility (installed vs. available) plus a transactional Reinstall / Sync that re-aligns a project to the current source
Analytics Dashboard - Track knowledge base usage and correlate with executed jobs
121+ Technologies - On-demand documentation via Git-based knowledge base

Key Principle: Dev-Suite is a source repository that initializes your projects. It lives alongside your projects and provides centralized resources that multiple projects can reference.

Prerequisites

Node.js v20+ - Required to build MCP servers and run the dashboard
npm - Comes with Node.js
Git - Required for cloning dev-suite and the knowledge base
Claude Code - The Anthropic CLI tool that dev-suite extends

Optional:

Docker - Required if using the docker-manager MCP server
Database - Required if using the database-query MCP server (PostgreSQL, MySQL, etc.)

Quick Start

Prefer a one-click installer? Skip the clone step and jump to Desktop App Downloads for Windows / macOS / Linux pre-built installers.

1. Clone Dev-Suite

git clone https://github.com/claude-dev-suite/claude-dev-suite.git
cd claude-dev-suite

2. Initialize Your Project

# Launch interactive web dashboard
./init-project.sh /path/to/your-project

# Windows PowerShell
.\init-project.ps1 C:\path\to\your-project

# Quick mode (auto-detect + apply best preset)
./init-project.sh /path/to/your-project --quick

The script will:

Check Node.js installation (v20+)
Build MCP servers if needed (npm install && npm run build)
Launch the web dashboard at http://localhost:3456
Guide you through a 5-step wizard to configure your project

3. Restart Claude Code

Once initialization completes, restart Claude Code to load the new MCP servers and agents.

4. Start Using Dev-Suite

After restarting Claude Code, everything works automatically:

Agents are routed based on your prompts (e.g., asking about React triggers the react-expert)
MCP tools are available as Claude Code tools (e.g., fetch_docs, execute_query)
Skills provide context-specific knowledge to agents
Slash commands are available (e.g., /docs react hooks)

Key Features

Web Dashboard & Orchestrator

The Web Dashboard (launched via init-project.sh) provides:

Visual Configuration Wizard

Auto-Detection: Scans package.json, pom.xml, build.gradle.kts, Cargo.toml, docker-compose.yml, AndroidManifest.xml, libs.versions.toml, ProjectSettings/ProjectVersion.txt, Packages/manifest.json, etc.
Stack Detection: Identifies React, Spring Boot, Android/Kotlin (Room, Compose), Unity (2D, URP, HDRP, DOTS, Netcode, XR, Addressables, Cinemachine, Input System), PostgreSQL, Git provider, and more
Agent Selection: Pre-selects agents based on detected technologies
MCP Selection: Pre-selects MCP servers with environment variable configuration
One-Click Install: Generates all config files (.mcp.json, .dev-suite.json, CLAUDE.md)

Task Orchestrator 🔥 NEW

Submit complex multi-agent tasks directly from the GUI:

Dashboard GUI → Submit Task → Claude Code (via MCP) → Execute → Stream Results → Dashboard

Features:

Real-time streaming via WebSocket (port 3457)
Interactive input support (y/n confirmations, file selections)
Job queue management with status tracking
Live output updates as agents execute
Result recap with agent outputs, files changed, test results, build status

How to use:

Open dashboard: ./init-project.sh . or via MCP tool dashboard_open
Navigate to Orchestrator tab
Enter task description (e.g., "Add user authentication with JWT")
Submit → Claude Code polls for task → Executes agents → Streams results back
View recap with links to changed files

Analytics Dashboard 📊 NEW

Track development activity and knowledge base usage:

KB Usage Statistics: Most-accessed technologies, topics, search queries
Agent Performance: Execution counts, average duration
Technology Trends: Correlate KB queries with orchestrator jobs
Timeline View: Hourly/daily usage patterns

Access at: http://localhost:3456/analytics (when dashboard is running)

Code Generator NEW

Spec-driven code generation with AI refinement:

Dashboard → Upload Spec → Deterministic Generation → AI Refinement → Accept/Reject

Supported formats: OpenAPI (JSON/YAML), AsyncAPI, TypeSpec, Protobuf, BPMN

Features:

9 target languages/frameworks: TypeScript (Express, Fastify, NestJS, Koa), Java (Spring), Python (FastAPI, Flask), Go (Gin, Echo)
Convention-aware: Reads .prettierrc, tsconfig.json, ESLint config to match project style
AI refinement: Uses specialized agents + refinement skill for naming, imports, and code quality
5-step wizard: Technology → Upload Spec → Configure → Preview → Generate
File browser: Preview generated code before accepting

How to use:

Open dashboard and navigate to Code Generator tab
Select spec technology (OpenAPI, AsyncAPI, etc.)
Upload your spec file (drag-and-drop supported)
Choose target language, framework, and output directory
Preview → Generate → Optionally refine with Claude

File Viewer

Browse and inspect your project files directly from the dashboard:

File tree navigation - Collapsible directory tree with smart filtering (skips node_modules, dist, .git, etc.)
Syntax highlighting - VS Code-quality highlighting via shiki for TypeScript, Python, Rust, Go, Java, JSON, YAML, Markdown, and 50+ languages
Read-only safety - View any file up to 500 KB without risk of accidental edits
Path breadcrumb - Always shows the full path of the open file

Access from the Files tab in the right tool window bar.

MCP Servers

Specialized MCP servers extend Claude Code with powerful tools:

Server	Tools	Description
documentation	4	Fetch docs for 121+ technologies via Git-based KB
database-query	9	SQL queries, schema inspection, migrations
docker-manager	8	Containers, images, Compose services
api-tester	6	HTTP requests, collection import, mock servers
api-explorer	7	OpenAPI schema explorer, endpoint details
log-analyzer	10	Multi-format log parsing, pattern detection
performance-profiler	13	CPU/memory profiling, bottleneck detection, HAR replay
code-quality	7	Complexity analysis, dead code, duplicates, import graph
security-scanner	6	Dependency audit, secrets scan, SAST
dashboard-bridge	9	Dashboard control, orchestrator queue
skill-loader ⭐	3	Built-in: lazy-loads dev-suite skill bodies on demand. Always installed; powers tiered `core_skills` / `extended_skills` agent schema

See MCP Servers Reference for detailed documentation.

Specialized Agents

Domain experts with deep knowledge in specific technologies:

Specialized agents organized by domain:

Core Agents

architect - Multi-domain system design & trade-offs across web/enterprise, low-level/systems (OS & kernels, embedded/RTOS, systems networking, storage engines, distributed consensus, virtualization, hardware-aware), AI-integrated systems (edge, serving topology, hybrid, gateways, agentic), and data-intensive platforms — discovers and loads the relevant domain skills on demand
code-reviewer - Code quality, best practices, refactoring
python-expert - Python 3.10-3.14, async patterns, package management, ruff, pydantic
typescript-expert - TypeScript 5, advanced types, strict configuration
nodejs-expert - Event loop, async patterns, streams, worker threads
accessibility-expert - WCAG 2.2 compliance, ARIA patterns, screen reader compatibility, accessibility testing
dashboard-refactor-expert - Dashboard React/TypeScript refactoring
claude-code-extension-expert - Claude Code extensions, skills, hooks, MCP plugins
documentation-expert - JSDoc, TSDoc, API documentation generation

Frontend Agents

react-expert - React 19, hooks, performance optimization
nextjs-expert - App Router, RSC, Server Actions, caching
vue-expert - Vue 3, Composition API, Pinia
svelte-expert - Svelte 5, SvelteKit, stores
angular-expert - Angular 17+, signals, standalone components, SSR
electron-expert - Cross-platform desktop apps, main/renderer process, IPC, auto-updates
tauri-expert - Tauri desktop apps with Rust backend, IPC, plugins, code signing
ux-expert - UX/UI design, visual hierarchy, design systems, interaction design, mobile UX, dark mode
creative-frontend-expert - Advanced animation (Framer Motion, GSAP), Three.js/R3F, SVG animation, Canvas/WebGL, advanced CSS effects

Backend Agents

spring-boot-expert - Spring Boot 3, JPA, Security, REST APIs
nestjs-expert - Modules, guards, pipes, Prisma integration
fastapi-expert - Python async, Pydantic, SQLAlchemy
streamlit-expert - Streamlit Python web apps, session state, caching, multipage
rust-expert - Actix-web, Axum, Rocket, Warp
go-expert - Gin, Fiber, Echo, Chi
deno-expert - Fresh, Oak, TypeScript-first runtime
dotnet-expert - ASP.NET Core 8+, Entity Framework Core, Blazor, SignalR
cpp-expert - Modern C++ (C++17/20/23), CMake, Google Test, clang-tidy, sanitizers
windows-driver-expert - Windows kernel & user-mode drivers (KMDF/UMDF), HID filters, Indirect Display Drivers, WinDbg, driver signing

Data Agents

data-engineering-expert - pandas, openpyxl, lxml, bulk data pipelines, Excel/XML/CSV, UTF-16 file formats
rag-expert - Retrieval-Augmented Generation end-to-end: chunking, embeddings, vector stores (Pinecone/Weaviate/Qdrant/pgvector/ES), hybrid search, reranking, agentic RAG (Self-RAG/CRAG), graph RAG, multimodal RAG, evaluation (RAGAS/DeepEval), guardrails, LangChain/LlamaIndex/Haystack/DSPy

Industrial Agents

dcs-analyst - ABB Freelance PRT/DMF/CSV file analysis, tag extraction, DCS reverse engineering
freelance-engineer - ABB Freelance engineering file generation, PRT/DMF bulk templating
automation-architect - DCS/PLC automation pipeline design, cross-platform strategies (ABB, Siemens, Emerson, Honeywell)
membrane-expert - Reverse Osmosis and EDI process expertise for water treatment, desalination, ultrapure water, and pharma WFI (ASTM D4516 KPI normalization, fouling/scaling diagnostics, CIP planning, SEC/LCOW economics, regulatory citations)

Database Agents

prisma-expert - Schema design, queries, migrations
sql-expert - PostgreSQL, MySQL, query optimization
mongodb-expert - Document modeling, aggregations, Spring Data MongoDB

Testing Agents

vitest-expert - Unit testing, mocking, coverage
playwright-expert - E2E testing, locators, assertions
spring-boot-integration-test-expert - @SpringBootTest, Testcontainers
python-integration-test-expert - pytest, testcontainers-python, pytest-django, FastAPI TestClient, factory_boy, Celery, Pact
smoke-test-expert - Post-implementation verification, live HTTP testing, fix orchestration
qa-expert - Test strategy, quality assurance

Infrastructure & Security

docker-expert - Containerization, Compose, best practices
devops-expert - CI/CD, GitHub Actions, deployment
security-expert - OWASP, authentication, authorization

Quality & Open Source

integration-validator-expert - API contract validation, frontend-backend alignment
open-source-expert - OSS readiness, licensing, community health, compliance

Cloud & Mobile Agents

cloud-expert - AWS, Azure, GCP, Terraform, serverless, API gateway, service mesh
mobile-expert - React Native, Flutter, Expo, push notifications, payments
kmp-expert - Kotlin Multiplatform + Compose Multiplatform across Android/iOS/Desktop/Wasm, Rust ↔ Kotlin/Swift bindings via UniFFI (incl. KMP fork), Gradle KMP, expect/actual, StateFlow + Voyager/Decompose + Koin, Bitcoin libs via UniFFI (BDK, LDK Node, LWK, CDK, Breez SDK Liquid)
android-native-expert - Native Android with Jetpack Compose, Kotlin, Material 3 / Material You, Navigation Compose 2.8 type-safe routes, Hilt DI, Android Keystore + BiometricPrompt with crypto-object binding, EncryptedSharedPreferences, WorkManager (Hilt-injected), Foreground Services with Android 14+ types, NFC (NDEF/IsoDep/HCE), Universal/App Links, FileProvider, ProGuard/R8, Network Security Config + cert pinning, SQLCipher with Keystore-derived key
ios-native-expert - Native iOS with SwiftUI 6.x + @Observable, Swift Concurrency, NavigationStack/SplitView with type-safe routes, Keychain Services with biometric SAC (.biometryCurrentSet), Secure Enclave P-256 keys, BGTaskScheduler app refresh + processing, Universal Links + custom URI schemes, App Groups, Share Extensions, Privacy Manifest (PrivacyInfo.xcprivacy), StoreKit 2, GRDB + SQLCipher, age + age-plugin-se for SEP-bound encrypted backups

Game Development Agents

unity-expert - Unity 6 (2D and 3D), C#, MonoBehaviour lifecycle, ScriptableObjects, URP/HDRP, Shader Graph, Input System, UI Toolkit, Cinemachine, Addressables, DOTS/ECS, Netcode for GameObjects, AR Foundation, XR Interaction Toolkit, Sprite Atlas v2, Tilemap, 2D Animation, 2D Lights, Pixel Perfect Camera, platformer character controllers (coyote time, jump buffer)

Engine-agnostic 2D art skills (cross-loaded onto unity-expert today, ready for future godot-expert / phaser-expert): tile design (autotiling Wang/blob, hex/iso grids, terrain blending, 9-slice), pixel art fundamentals (anti-aliasing rules, dithering patterns, outline philosophy, pixel hinting), palettes (color theory, restricted palettes from PICO-8 to AAP-64, hue shifting, palette swaps), seamless textures (offset-paint, normal map authoring, repetition reduction), animation frames (walk cycles, attack anticipation, frame counts, sub-pixel motion), tools (Aseprite, Tiled, LDtk, Tilesetter, Pixelorama, Spine, TexturePacker, Sprite Lamp), 2D lighting art (workflow for 2D Lights, normal maps, emissive layers, day/night), VFX (smoke/fire/water/electricity frame patterns, hitstop, screen shake, juice principles), environment design (parallax planning, atmospheric perspective, environmental storytelling), character design (silhouette-first, expressions in low-res, faction visual language).

Bitcoin / Lightning / L2 Agents

bitcoin-protocol-expert - Consensus, transactions, scripts (P2PK→P2TR+Tapscript), SegWit, Taproot, PSBT, descriptors, Miniscript, P2P (BIP155/152/157/158/324), package relay (BIP331), TRUC v3 (BIP431), message signing (BIP137/322), proposals (CTV/APO/OP_VAULT/CAT/drivechains), cryptography (secp256k1, Schnorr BIP340, MuSig2 BIP327, FROST, adaptor sigs, DLCs), metaprotocols (Ordinals/Inscriptions/BRC-20/Runes/Atomicals)
bitcoin-core-expert - bitcoin.conf, JSON-RPC, REST, ZMQ notifications, indexes (txindex/blockfilterindex/coinstatsindex), pruning, descriptors wallet, signet, Tor/I2P/CJDNS, Guix reproducible builds, Bitcoin Knots, integration with Electrs/Fulcrum/Esplora/mempool.space/BTCPay, self-hosted node distros (Umbrel/Start9/RaspiBlitz/MyNode/Citadel)
lightning-expert - All BOLT specs, channel state machines, HTLCs, onion routing (Sphinx), gossip, watchtowers, splicing, taproot channels, LND/CLN/LDK/Eclair/Greenlight/phoenixd, BOLT12 offers, LNURL, Lightning Address, LSP (BLIPs), WebLN, NWC (NIP-47), UMA, trampoline, MPP/AMP, Loop/Pool/Lit, submarine swaps (Boltz), security (replacement cycling, channel jamming, pinning), Taproot Assets / RGB on Lightning, consumer wallets (Phoenix, Mutiny, Breez, Zeus, Aqua, BlueWallet)
bitcoin-wallet-expert - HD wallets (BIP32/39/44/49/84/86), output descriptors, PSBT signing flows (BIP174/370/371), multisig coordination, time-locked vaults (CSV, OP_VAULT), coin selection (BnB / SRD / waste metric), fee estimation, RBF/CPFP, hardware wallet integration (Trezor, Ledger, Coldcard, BitBox02, Jade, Passport, SeedSigner, Krux, Keystone, Specter DIY, HWI), privacy (CoinJoin / PayJoin / Silent Payments BIP352 / BIP47 PayNyms), payment standards (BIP21, BIP329, BIP85, SLIP-39, SeedQR)
bitcoin-testing-expert - regtest, signet (incl. Mutinynet 30s blocks for fast LN dev), Polar (LN regtest GUI), Nigiri (full stack regtest with Esplora), Bitcoin Core's Python functional test framework, fuzzing (libFuzzer + cargo-fuzz on rust-bitcoin/bdk/secp256k1), property-based testing (proptest, hypothesis)

L2 / metaprotocols / mining / hardware / infrastructure / library knowledge is delivered via skills loaded onto the appropriate agents (Bitcoin domain agents OR language-experts via detection). Covers: ARK/ARKADE, Spark (Lightspark), Liquid, Taproot Assets, RGB, Stacks, Rootstock, Fedimint, Cashu, Citrea, Strata, BSquared, Bitlayer, Merlin, Botanix, BOB, Hemi, MAP, Babylon, BitVM/BitVM2/BitVM3, threshold-tBTC, drivechains/spacechains; Ordinals/Inscriptions/BRC-20/Runes/Atomicals; Stratum V1/V2 + decentralized pools; major HW vendors + DIY signers; Electrs/Fulcrum/Esplora/mempool.space/BTCPay/Specter/Sparrow; libraries across Rust (rust-bitcoin, BDK, LDK, miniscript, rust-dlc), TypeScript (bitcoinjs-lib, @scure/btc-signer, mempool.js, bcoin), Python (python-bitcoinlib, embit, BDK-Python, bitcoinlib, hdwallet), Go (btcd, btcsuite, lnd, tapd), JVM (bitcoinj, bdk-jvm), .NET (NBitcoin), C (libsecp256k1, libwally, libbitcoin).

Messaging & Performance

messaging-expert - Kafka, RabbitMQ, NATS, SQS, event-driven architecture
performance-expert - Profiling, optimization, bottlenecks
log-analyst - Log analysis, debugging, observability

See Agents Reference for trigger keywords and skills.

Skills & Knowledge Base

Skills organized by category:

Frontend: React, Vue, Angular, Svelte, Next.js, Nuxt, TailwindCSS, shadcn/ui
UX/Design: Visual hierarchy, design tokens (W3C spec), interaction design, motion, loading states, mobile UX, color systems, ethical design
Animation: Framer Motion, GSAP (scroll-driven, timelines, morphing), CSS advanced effects (clip-path, masks, CSS Houdini, scroll-driven animations)
Graphics & 3D: Three.js/React Three Fiber, SVG animation, Canvas/WebGL, generative art, particle systems
Backend: Spring Boot, NestJS, Express, FastAPI, ASP.NET Core, Rust, Go, Deno frameworks
Databases: PostgreSQL, MySQL, MongoDB, Redis
ORM/ODM: Prisma, Drizzle, TypeORM, SQLAlchemy, Spring Data JPA
Testing: Vitest, Jest, Playwright, Cypress, Testcontainers (Java), testcontainers-python, pytest, pytest-django, FastAPI testing, factory_boy, Celery testing, Pact (contract testing), Messaging Testing (Kafka, RabbitMQ, multi-broker)
State Management: TanStack Query/Router, Redux Toolkit, Zustand, Pinia
API Design: REST, GraphQL, tRPC, OpenAPI
Infrastructure: Docker, Kubernetes, GitHub Actions
Security: JWT, OAuth2, NextAuth, OWASP
Best Practices: Git Workflow, Clean Code, Performance Optimization

Knowledge Base Architecture

The knowledge base provides on-demand documentation for 121+ technologies via a separate Git repository: github.com/claude-dev-suite/knowledge_base

How it works:

Agent needs docs → documentation MCP → Git sparse checkout → Cache (2h TTL) → Return to agent

An agent (or you) requests documentation via fetch_docs({ technology: "react", topic: "hooks" })
The documentation MCP server checks the local cache (.kb-cache/)
If cached and fresh (< 2 hours), it returns the cached content immediately
If not cached or stale, it performs a Git sparse checkout to fetch only the requested files from the KB repository
The content is cached locally for subsequent requests

The three-layer knowledge system:

┌─────────────────────────────────────────────┐
│  Layer 1: Skills (.claude/skills/)          │  Always loaded in agent context
│  Quick-reference guides, patterns, rules    │  Instant access, no network needed
├─────────────────────────────────────────────┤
│  Layer 2: Quick-Refs (skills/*/quick-ref/)  │  Detailed guides per topic
│  Each references KB docs for deep dives     │  Loaded on demand by agent
├─────────────────────────────────────────────┤
│  Layer 3: Knowledge Base (Git repo)         │  Full documentation
│  121+ technologies, fetched via MCP server  │  On-demand, cached 2 hours
└─────────────────────────────────────────────┘

Layer 1 (Skills): Concise rules and patterns loaded directly into the agent context. No network required.
Layer 2 (Quick-Refs): More detailed guides within skill folders. Each quick-ref links to KB docs for full documentation.
Layer 3 (Knowledge Base): Complete documentation stored in a separate Git repository, fetched on-demand by the documentation MCP server with local caching.

Configuration:

# Optional: use a custom KB repository (defaults to official repo)
KB_REPO_URL=https://github.com/claude-dev-suite/knowledge_base.git

# Optional: cache TTL in seconds (default: 7200 = 2 hours)
KB_CACHE_TTL=7200

Adding documentation to the KB:

Clone the KB repository: git clone https://github.com/claude-dev-suite/knowledge_base.git
Add markdown files under knowledge/{technology}/{topic}.md
Update the relevant category file in mcp-servers/documentation/src/docs-index/ (e.g., testing.ts, backend.ts) to register the new technology — docs-index.ts is a re-export aggregator, do not edit it directly
Commit and push - the documentation MCP server will fetch new docs automatically on next request

Project Templates

Ready-to-use scaffolding templates for quick project setup:

Template	Description
api-nodejs	Node.js API starter
express-api	Express.js REST API
frontend-react	React frontend with Vite
react-tanstack	React with TanStack Query + Router
nextjs-standalone	Next.js App Router standalone
fullstack-nextjs-nestjs	Next.js + NestJS monorepo
springboot-api	Spring Boot 3 REST API
springboot-react-fullstack	Spring Boot + React fullstack
python-fastapi	FastAPI Python backend
vue-nuxt	Vue.js with Nuxt 3
unity-2d-game	Unity 6 2D game scaffold (URP 2D, Cinemachine, Input System, sample PlayerController2D with coyote time + jump buffer)

Templates are used during the initialization wizard (Step 0) and provide pre-configured project structure, dependencies, and dev-suite integration.

Custom Agents Builder

Create and manage custom agents directly from the dashboard:

Visual Editor - Write agent markdown with YAML frontmatter
Skill Association - Link agents to specific skills and MCP servers
Instant Deployment - Agents are saved to .claude/agents/ and immediately available
Edit & Delete - Manage existing custom agents from the dashboard

Recipes & Automations

Pre-built automation workflows for common development tasks:

Browse and apply built-in automation recipes
Recipes combine agent actions, hooks, and tool configurations
Apply recipes to quickly set up common patterns (testing pipelines, linting, code review flows)

Hooks Management

Configure Git hooks and Claude Code hooks from the dashboard:

Git Hooks - Pre-commit, pre-push, commit-msg hooks
Claude Code Hooks - Event-based automation (on file write, on tool call)
Visual Configuration - Edit hooks through the dashboard UI
Template Support - Pre-configured hook templates for common workflows

Update System

Keep dev-suite components up to date through the dashboard Updates tab:

Version Visibility - See the dev-suite version installed in your project alongside the version available from source, with an at-a-glance Up to date / Update available status
New Component Discovery - Proactively notifies when new agents or MCP servers are added to dev-suite after your installation, with one-click install
Reinstall / Sync - A single, transactional erase-and-replace that re-aligns a project to the current source: managed components are re-installed and orphaned ones removed, while your custom agents/skills, CLAUDE.md notes, and settings.json keys are preserved
Per-file opt-out - Locally modified managed files are previewed with an Overwrite / Keep choice
Safe by default - A backup is taken before any change and any failure rolls back automatically

Electron Desktop App

The dashboard is available as a native desktop application:

Cross-platform support (Windows, macOS, Linux)
Fast startup with optimized splash screen
Auto-updater for seamless version updates
Native system tray integration
Same features as the web dashboard

See Desktop App Downloads below for pre-built installers.

Desktop App Downloads

Pre-built installers for every tagged release are published on the GitHub Releases page.

Important prerequisite — install Node.js first. The desktop app launches its own dashboard but does not ship a system-wide Node.js runtime. Claude Code starts MCP servers via the .mcp.json it reads on each project, and those server processes require node to be available on the user's PATH. Without Node.js v20+ installed system-wide, MCP servers will fail silently. The app shows a warning dialog on first launch if Node is missing — install it from nodejs.org and restart the app.

Platform	Architecture	Asset	Notes
Windows	x64	`Dev-Suite-Dashboard-Setup-x.y.z.exe`	NSIS installer
macOS	Apple Silicon	`Dev-Suite-Dashboard-x.y.z-arm64.dmg`	M1 / M2 / M3 / M4
macOS	Intel	`Dev-Suite-Dashboard-x.y.z-x64.dmg`	2019 and earlier
Linux	x64	`Dev-Suite-Dashboard-x.y.z.AppImage`	Portable, all distros (incl. Fedora / RHEL)
Linux	x64	`dev-suite-dashboard_x.y.z_amd64.deb`	Debian / Ubuntu / Mint

Installers are currently unsigned. The OS will show a warning on first launch — see the per-platform instructions below.

Windows

Download Dev-Suite-Dashboard-Setup-x.y.z.exe.
Double-click to run. SmartScreen will show "Windows protected your PC" because the binary isn't signed yet.
Click More info → Run anyway.
The installer will set up the app and add a Start menu shortcut.

macOS

Download the DMG matching your CPU: arm64 for Apple Silicon, x64 for Intel.
- Not sure? Click → About This Mac. "Chip: Apple…" = arm64.
Open the DMG and drag Dev-Suite Dashboard into Applications.
First launch is blocked by Gatekeeper because the app isn't notarized. Choose one:
- Recommended: Right-click the app in Applications → Open → confirm Open in the dialog. macOS will remember the choice.
- CLI alternative: strip the quarantine flag:
```
xattr -d com.apple.quarantine "/Applications/Dev-Suite Dashboard.app"
```

Linux — AppImage (portable, all distros)

chmod +x Dev-Suite-Dashboard-*.AppImage
./Dev-Suite-Dashboard-*.AppImage

If the AppImage refuses to run on a system without FUSE 2 (Ubuntu 22.04+, Fedora 38+), install it with sudo apt install libfuse2 or extract and run instead:

./Dev-Suite-Dashboard-*.AppImage --appimage-extract-and-run

Linux — Debian / Ubuntu / Mint (`.deb`)

sudo dpkg -i dev-suite-dashboard_*_amd64.deb
sudo apt-get install -f   # only if dpkg reports missing dependencies

Linux — Fedora / RHEL / openSUSE

No native .rpm is published yet — use the AppImage above. It runs on all RPM-based distros without installation.

Auto-updates

The desktop app checks GitHub Releases at startup and every 4 hours. When a new version is published, you'll get an in-app notification and an Install on quit option. Auto-updates work the same on all three platforms.

Installation Modes

Interactive Mode (Default)

./init-project.sh /path/to/project

Launches web dashboard at http://localhost:3456 with 5-step wizard:

Detection - Auto-detect stack, databases, Git provider
Agents - Select specialized experts (pre-selected based on stack)
MCP Servers - Select tools (pre-selected based on stack)
Environment - Configure database URLs, API tokens
Install - Generate config files and copy components

Quick Mode

./init-project.sh /path/to/project --quick

Auto-detects stack and applies best-matching preset with minimal prompts.

Non-Interactive Mode

./init-project.sh /path/to/project --non-interactive --project-type fullstack

Uses detected values or defaults, no user input required.

Usage

Daily Development with Agents

After initialization, agents work automatically in Claude Code. When you ask questions or give tasks, Claude Code routes them to the appropriate agent based on keywords:

You: "Add a login form with validation"
→ Claude Code activates react-expert (detects React/frontend keywords)
→ Agent uses react skills + documentation MCP for best practices

You: "Why is this SQL query slow?"
→ Claude Code activates sql-expert (detects SQL/query keywords)
→ Agent uses database-query MCP to run EXPLAIN and analyze

You: "Review this PR for security issues"
→ Claude Code activates code-reviewer + security-expert
→ Agents use code-quality and security-scanner MCP tools

Using MCP Tools Directly

MCP tools are available as Claude Code tools. You can ask Claude to use them:

"Fetch the React hooks documentation"
→ fetch_docs({ technology: "react", topic: "hooks" })

"List all Docker containers"
→ docker_ps({ all: true })

"Scan this project for vulnerabilities"
→ scan_all({ path: "." })

Using the Dashboard

The dashboard can be reopened at any time for project management:

# Reopen dashboard for current project
./init-project.sh .

# Or via Claude Code MCP tool
# Ask Claude: "Open the dashboard"
→ dashboard_open()

Dashboard tabs:

Wizard - Re-run the initialization wizard or use templates
Manage - Add/remove agents, MCP servers, hooks, custom agents, recipes (with proactive new-component notifications)
Orchestrator - Submit multi-agent tasks with real-time progress
Analytics - View knowledge base usage statistics
Git - Visual git operations (branches, commits, diffs, GitHub CLI auth detection with automatic login prompts)
Updates - Check for and apply dev-suite updates

Using the Orchestrator

For complex tasks that require multiple agents:

Open the dashboard (./init-project.sh .)
Go to the Orchestrator tab
Describe your task (e.g., "Refactor the auth module and add tests")
Submit the job
Claude Code picks up the task, executes agents, and streams results back
View the recap with changed files, test results, and build status

Using Templates

To scaffold a new project from a template:

Open the dashboard
In the wizard, select "Start from Template" mode
Choose a template (e.g., fullstack-nextjs-nestjs)
Configure project-specific options
The template generates the project structure with dev-suite pre-configured

Configuration

Generated Files

After initialization, your project will contain:

your-project/
├── .mcp.json                    # MCP server configuration
├── .dev-suite.json              # Stack and component configuration
├── CLAUDE.md                    # Agent routing rules (auto-generated)
├── .claude/
│   ├── agents/                  # Selected specialized agents
│   ├── skills/                  # Related skills
│   └── commands/                # Slash commands (/init-project, /docs, etc.)
└── .mcp-servers/                # Installed MCP servers (built from dev-suite)
    ├── documentation/
    ├── database-query/
    └── ...

`.dev-suite.json` Example

{
  "version": "1.0.0",
  "project": {
    "name": "my-app",
    "type": "fullstack",
    "isMonorepo": false
  },
  "mcpServers": [
    "documentation",
    "database-query",
    "docker-manager",
    "api-tester",
    "dashboard-bridge"
  ],
  "stacks": {
    "frontend": {
      "framework": "react",
      "metaFramework": "nextjs",
      "styling": "tailwindcss",
      "stateManagement": "zustand+tanstack-query"
    },
    "backend": {
      "runtime": "nodejs",
      "framework": "nestjs",
      "apiStyle": "rest"
    },
    "database": {
      "type": "postgresql",
      "orm": "prisma"
    },
    "testing": {
      "unit": "vitest",
      "e2e": "playwright"
    }
  },
  "git": {
    "provider": "github",
    "repository": "https://github.com/owner/my-app",
    "tokenEnvVar": "GITHUB_TOKEN"
  },
  "agents": {
    "enabled": [
      "architect",
      "code-reviewer",
      "react-expert",
      "nextjs-expert",
      "nestjs-expert",
      "prisma-expert",
      "vitest-expert",
      "playwright-expert",
      "docker-expert"
    ]
  }
}

Environment Variables

Create a .env file in your project root:

# Database
DATABASE_URL=postgresql://user:pass@localhost:5432/dbname

# Optional: Dashboard ports
DASHBOARD_PORT=3456
ORCHESTRATOR_WS_PORT=3457

# Optional: Documentation KB (defaults to official repo)
KB_REPO_URL=https://github.com/claude-dev-suite/knowledge_base.git
KB_CACHE_TTL=7200

Security Note: Never commit .env files. API tokens are only referenced by variable name in .dev-suite.json.

MCP Servers Reference

Documentation Server

Fetch on-demand documentation for 121+ technologies via Git-based knowledge base.

Tools:

fetch_docs({ technology, topic, source?, refresh? }) - Get documentation for a topic
search_docs({ query, technologies? }) - Search across all docs
list_topics({ technology }) - List available topics for a technology
list_versions({ technology }) - List supported versions

Example:

fetch_docs({ technology: "spring-boot", topic: "security" })

Database Query Server

Execute safe SQL queries and manage database schemas.

Tools:

execute_query({ sql, params?, limit?, offset? }) - Execute SELECT queries
list_tables() - List all tables with row counts
describe_table({ table }) - Get table schema details
get_schema({ table?, compact? }) - Get full database schema
explain_query({ sql, params?, verbose? }) - Analyze query performance
compare_schemas({ targetDatabaseUrl, tables? }) - Compare schemas
find_slow_queries({ table? }) - Identify potential performance issues
generate_migration({ targetDatabaseUrl, migrationName? }) - Generate migration script
backup_restore({ operation, backupPath?, format?, tables? }) - Backup/restore database

Requires: DATABASE_URL environment variable

Docker Manager Server

Manage Docker containers, images, and Compose services.

Tools:

docker_ps({ all? }) - List running containers
docker_container({ container, action, tail? }) - Manage container (start/stop/logs/inspect)
docker_compose({ action, service?, build?, detach? }) - Manage Compose services

Claude Dev Suite

README

Dev-Suite

Table of Contents

What is Dev-Suite?

Prerequisites

Quick Start

1. Clone Dev-Suite

2. Initialize Your Project

3. Restart Claude Code

4. Start Using Dev-Suite

Key Features

Web Dashboard & Orchestrator

Visual Configuration Wizard

Task Orchestrator 🔥 NEW

Analytics Dashboard 📊 NEW

Code Generator NEW

File Viewer

MCP Servers

Specialized Agents

Core Agents

Frontend Agents

Backend Agents

Data Agents

Industrial Agents

Database Agents

Testing Agents

Infrastructure & Security

Quality & Open Source

Cloud & Mobile Agents

Game Development Agents

Bitcoin / Lightning / L2 Agents

Messaging & Performance

Skills & Knowledge Base

Knowledge Base Architecture

Project Templates

Custom Agents Builder

Recipes & Automations

Hooks Management

Update System

Electron Desktop App

Desktop App Downloads

Windows

macOS

Linux — AppImage (portable, all distros)

Linux — Debian / Ubuntu / Mint (.deb)

Linux — Fedora / RHEL / openSUSE

Auto-updates

Installation Modes

Interactive Mode (Default)

Quick Mode

Non-Interactive Mode

Usage

Daily Development with Agents

Using MCP Tools Directly

Using the Dashboard

Using the Orchestrator

Using Templates

Configuration

Generated Files

.dev-suite.json Example

Environment Variables

MCP Servers Reference

Documentation Server

Database Query Server

Docker Manager Server

Comments (0)

Linux — Debian / Ubuntu / Mint (`.deb`)

`.dev-suite.json` Example