A Claude Code skill that generates a complete, self-managing AI workspace configuration for any project — covering the full lifecycle from business analysis to deployment.
You say: "Configure my workspace for TypeScript + Next.js + PostgreSQL"
The skill generates 80+ files that turn Claude into a self-managing development team with built-in business analysis, database design, and development best practices:
- 17 agents — From CEO and COO to Systems Analyst, DBA, Architect, Backend, Frontend, QA, DevOps, and the full business team
- 14 skills — Including business-analysis templates (use cases, ERD, user stories, BPMN flows)
- 6 rules — Coding (SOLID + refactoring.guru), Testing, Design, Collaboration, Graph Thinking, Self-Management
- 8 diagrams — Mermaid graphs that replace text explanations (5× token savings)
- 12 slash commands — Including
/create-docsto scaffold project documentation - 5 memory files — Persistent state across sessions (Claude never forgets where it left off)
- Stack templates — TypeScript, React, Python (or generate any stack with
/setup-stack) - docs/ folder — Auto-generated business analysis documentation for every project
- settings.json — Permissions (git/gh auto-allow), spinner tips, attribution, autocompact
- statusline-command.sh — Colored status bar: model, tokens, git info, context usage %
This is the complete lifecycle every project follows — from first idea to shipped code:
┌─────────────────────────────────────────────────────────────────────┐
│ PROJECT LIFECYCLE │
├─────────────────────────────────────────────────────────────────────┤
│ PHASE 0: SETUP │
│ "Configure my workspace for [stack]" │
│ → Generates claude-config/ with all agents, rules, skills │
│ → /setup-stack [technologies] — sets stacks/active.md │
├─────────────────────────────────────────────────────────────────────┤
│ PHASE 1: BUSINESS ANALYSIS ← NEW in v1.2.0 │
│ /create-docs [project-name] — scaffolds docs/ folder │
│ /activate systems-analyst — use cases, user stories, flows │
│ /activate dba — ERD, schema, data dictionary │
│ /activate architect — system design, C4 diagrams, ADRs │
│ /activate product-manager — prioritize into sprint backlog │
│ │
│ Output: docs/ with requirements, use cases, ERD, architecture │
├─────────────────────────────────────────────────────────────────────┤
│ PHASE 2: PLANNING │
│ /plan [feature] — structured plan for single task │
│ /plan-sprint — sprint plan with gantt + agents │
│ /create-spec [name] — feature spec + flow diagram │
├─────────────────────────────────────────────────────────────────────┤
│ PHASE 3: DEVELOPMENT │
│ /start — read STATE.md, know where you are │
│ /activate backend-dev — APIs, DB, queues, AI pipelines │
│ /activate frontend-dev — UI, components, forms, routing │
│ /implement [spec-name] — implement from spec with graphs │
│ /build-graph — map codebase as mermaid diagrams │
├─────────────────────────────────────────────────────────────────────┤
│ PHASE 4: QUALITY │
│ /review [file] — code review vs coding.md │
│ /review-impact [file] — review + blast radius from graphs │
│ /blast-radius [target] — trace what a change impacts │
│ /activate qa-engineer — test plan, execution, sign-off │
├─────────────────────────────────────────────────────────────────────┤
│ PHASE 5: SHIP │
│ /activate devops — CI/CD, deploy, monitoring │
│ /end — save state for next session │
└─────────────────────────────────────────────────────────────────────┘
Every project now starts with a proper analysis phase before any code is written.
docs/
├── 01-requirements/
│ └── REQUIREMENTS.md ← Functional + non-functional requirements
├── 02-analysis/
│ ├── USE_CASES.md ← Actor map, use case diagram, use case specs
│ └── USER_STORIES.md ← All user stories with acceptance criteria
├── 03-database/
│ ├── ERD.md ← Mermaid erDiagram + relationship rules
│ ├── SCHEMA.md ← Full SQL DDL: tables, views, RLS, constraints
│ └── DATA_DICTIONARY.md ← Every field: type, nullable, business meaning
├── 04-architecture/
│ └── SYSTEM_CONTEXT.md ← C4 diagrams (context, container, component)
├── 05-flows/
│ └── SEQUENCE_DIAGRAMS.md ← Step-by-step interaction diagrams
└── 06-team/
└── TEAM_ROLES.md ← Roles, responsibilities, RACI matrix
| Agent | Role | When to invoke |
|---|---|---|
| 13 — Systems Analyst | Use cases, user stories, process flows, sequence diagrams | Before any feature development |
| 14 — DBA | ERD, SQL schema, data dictionary, integrity rules | After entities defined by use cases |
Preloaded into agents 13 and 14. Contains templates for every BA artifact:
- Actor map, use case diagram, use case specification
- User story format with Given/When/Then acceptance criteria
- BPMN-style process flow (Mermaid flowchart)
- Sequence diagram (Mermaid sequenceDiagram)
- ERD (Mermaid erDiagram), data dictionary row format
- Requirements document structure (FR, NFR, Constraints, Out of Scope)
- Team RACI matrix template, docs/ folder structure
/create-docs [project-name]
Scaffolds the complete docs/ folder in under 2 minutes. Asks 5 questions, generates 9 files with Mermaid diagram stubs, and outputs the next steps sequence.
Claude auto-plans before executing, auto-saves state between sessions, auto-compacts context before overflow, and auto-diagnoses when it loses track. The user only needs to say /start and /end.
Commands are user entry points. Agents run autonomously with preloaded skills (domain knowledge injected at startup). Dev agents auto-accept edits (permissionMode: acceptEdits), have execution limits (maxTurns), and preload quality skills.
Dev agents contain zero framework-specific code. They read stacks/active.md for patterns. Change your entire stack by running /setup-stack [new tech] — all agents adapt automatically.
Claude maintains your codebase as 3 mermaid diagrams (structure, dependencies, test coverage). No MCP server, no Python, no external tools. Claude reads a 300-token diagram instead of scanning 200 files.
.claudeignoreblocks irrelevant files from context- Diagrams replace text explanations (300 tokens vs 1500)
memory/STATE.mdprevents re-discovering context each sessionmodel: haikuon lightweight commands saves tokens/costCLAUDE_AUTOCOMPACT_PCT_OVERRIDE: 80compacts earlier
# Download ai-workspace-builder.skill from Releases
claude skill install ai-workspace-builder.skillgit clone https://github.com/YOUR_USERNAME/ai-workspace-builder.git
mkdir -p ~/.claude/skills/ai-workspace-builder
cp -r ai-workspace-builder/ai-workspace-builder/* ~/.claude/skills/ai-workspace-builder/Open any project in Claude Code:
cd ~/my-project
claudeThen say any of these:
"Configure my workspace for TypeScript + Fastify + Prisma + PostgreSQL"
"Set up my AI team"
"Create my config"
"Prepare my AI for this project"
"I want automatic planning and self-management"
The skill activates, asks about your project (stack, users, main features, entities), and generates the full configuration including docs/ scaffolding.
# Session start
/start # Claude reads memory, knows where it is
# Business analysis (do this first, before any code)
/create-docs my-saas-app # Scaffold docs/ with all BA templates
/activate systems-analyst # Write use cases, user stories, process flows
/activate dba # Design ERD, schema, data dictionary
/activate architect # Design system architecture, C4 diagrams
# Planning
/plan-sprint # Sprint plan with gantt + agent assignments
/create-spec user-auth # Create a feature specification
# Development
/activate backend-dev # Implement APIs from spec
/implement user-auth # Implement from spec using graphs
/build-graph # Map codebase as mermaid diagrams
/blast-radius src/auth.ts # See what a change would impact
# Quality
/review-impact src/auth.ts # Code review + blast radius
/activate qa-engineer # Test plan and sign-off
# Ship & close
/activate devops # Deploy pipeline
/end # Save state for next sessionyour-project/
└── claude-config/
├── CLAUDE.md ← Master brain (auto-loaded, <important> tags, 11 rules)
├── .claudeignore ← Files Claude skips
├── settings.json ← Permissions, statusLine, spinnerTips, attribution
├── statusline-command.sh ← Colored status bar (model, tokens, git, context %)
├── agents/ (17) ← Full frontmatter: maxTurns, color, memory, skills
│ ├── 00-orchestrator.md ← Coordinates all agents
│ ├── 01-architect.md ← System design, API contracts
│ ├── 02-backend-dev.md ← APIs, DB, queues
│ ├── 03-frontend-dev.md ← UI, components, routing
│ ├── 04-qa-engineer.md ← Tests, security, sign-off
│ ├── 05-devops.md ← CI/CD, deploy, monitoring
│ ├── 06-product-manager.md ← PRDs, scope, pricing
│ ├── 07-project-manager.md ← Sprints, timelines, blockers
│ ├── 08-ux-designer.md ← Wireframes, design system
│ ├── 09-growth-marketer.md ← Launch, SEO, channels
│ ├── 10-content-strategist.md ← Copy, prompts, brand voice
│ ├── 11-business-analyst.md ← Unit economics, KPIs
│ ├── 12-dx-engineer.md ← CX/DX/UX/UI, onboarding
│ ├── 13-systems-analyst.md ← Use cases, user stories, process flows ← NEW
│ ├── 14-dba.md ← ERD, schema, data dictionary ← NEW
│ ├── 15-ceo.md ← Vision, strategy, OKRs, PMF, investor narrative
│ └── 16-coo.md ← Operations, processes, scaling, risk management
├── rules/ (6) ← Non-negotiable quality standards
├── skills/ (14) ← Directory format: skills/<name>/SKILL.md
│ └── business-analysis/ ← BA templates preloaded into agents 13+14 ← NEW
├── stacks/ ← Stack-specific patterns (swap per project)
├── memory/ (5) ← Persistent state across sessions
├── diagrams/ (8+3) ← Visual context + code graphs
├── commands/ (13) ← Slash commands
│ └── create-docs.md ← Scaffolds docs/ at project start ← NEW
├── prompts/CATALOG.md ← Copy-paste prompt templates
├── specs/TEMPLATE.md ← Feature spec template
└── docs/ ← Generated per project by /create-docs ← NEW
├── 01-requirements/
├── 02-analysis/
├── 03-database/
├── 04-architecture/
├── 05-flows/
└── 06-team/
Every command has a defined internal execution path. This map shows how commands chain together in the project lifecycle, and what each one does internally.
graph TD
A["/start — read STATE.md"] --> B{Task type?}
B --> |"New project"| C["/create-docs — scaffold docs/"]
C --> C1["systems-analyst + dba IN PARALLEL"]
C1 --> D["/setup-stack — generate stacks/active.md"]
D --> E["/plan-sprint — sprint plan"]
B --> |"Continue sprint"| E
E --> E1["product-manager + project-manager IN PARALLEL"]
E1 --> E2["orchestrator → SPRINT.md + story.md per task"]
E2 --> F["/create-spec — write feature spec"]
F --> F1["architect validates pattern + file list"]
F1 --> F2["writes specs/name-spec.md + diagram"]
F2 --> G["/implement — build from spec"]
G --> G1["architect + backend-dev + frontend-dev IN PARALLEL"]
G1 --> G2["qa-engineer sequential — quality gate"]
G2 --> H["/build-graph — map codebase"]
H --> H1["writes code-graph + code-deps + code-tests mermaid"]
H1 --> I{Review needed?}
I --> |"Single file"| J["/review — code audit"]
J --> J1["qa-engineer: PASS/FAIL table vs coding.md"]
I --> |"Full impact"| K["/review-impact — blast radius + review"]
K --> K1["architect blast-radius + qa-engineer IN PARALLEL"]
J1 --> L["/blast-radius — trace dependencies"]
K1 --> L
L --> L1["reads 3 graph diagrams → direct/indirect impact"]
L1 --> M["/activate [agent] — switch role"]
M --> M1["devops / qa-engineer / ux-designer / etc."]
M1 --> N["/end — save state"]
N --> N1["updates STATE.md + CHANGELOG.md + DECISIONS.md"]
style A fill:#4A90D9,color:#fff
style N fill:#27AE60,color:#fff
style G1 fill:#F39C12,color:#fff
style E1 fill:#F39C12,color:#fff
style C1 fill:#F39C12,color:#fff
style K1 fill:#F39C12,color:#fff
| Command | Input | Agents Invoked | Output |
|---|---|---|---|
/start |
— | none (Haiku model) | 5-line status from STATE.md |
/end |
— | none (Haiku model) | Updated STATE.md + CHANGELOG.md |
/activate [agent] |
agent name | loads role into session | Active agent context |
/setup-stack [desc] |
tech description | none | stacks/active.md with real patterns |
/create-docs [name] |
project name | systems-analyst + dba parallel | docs/ with 9 BA files |
/create-spec [name] |
spec name | architect sequential | specs/name-spec.md + diagram |
/plan-sprint |
— | product-mgr + project-mgr parallel → orchestrator | SPRINT.md + story.md per task |
/implement [spec] |
spec name | architect + backend + frontend parallel → qa seq | Working code + updated graphs |
/review [file] |
file path | qa-engineer | PASS/FAIL table vs coding.md |
/review-impact [file] |
file path | architect + qa-engineer parallel | Blast radius + quality report |
/build-graph |
— | none | 3 mermaid diagrams of codebase |
/blast-radius [target] |
function/file | none | Impact trace: direct → indirect → tests |
Starting a new project:
/start → /create-docs my-app → /setup-stack → /plan-sprint
Building a feature:
/create-spec user-auth → /implement user-auth → /build-graph → /review-impact src/auth.ts
Reviewing a risky change:
/blast-radius src/auth.ts → /review-impact src/auth.ts → /activate qa-engineer
Closing a session:
/build-graph → /end
| What Claude does automatically | When |
|---|---|
Reads memory/STATE.md |
Start of every conversation |
| Plans before executing | Every non-trivial task |
| Reads diagrams before source files | Before touching existing code |
| Verifies its work (tests, typecheck) | After implementing changes (Rule 11) |
| Compacts context proactively | When context reaches ~50% |
| Saves state to memory files | When work completes |
| Re-reads memory if it loses track | When it detects it's repeating itself |
- Added Command Flow Map section with mermaid lifecycle diagram
- Added Command Reference table with internal execution paths
- Added Command Pairing Examples for common workflows
- Fixed: slash command count 13 → 12 (
plan.mdwas removed in v1.3.0) - Fixed: version badge now reflects current release
/plan-sprintnow producesmemory/sprints/sprint-{N}/{TID}-{slug}/story.mdper task- Every
story.mdincludes a## Token Budgetline agents read before executing - Effort in sprint task tables:
S/M/Lonly (never days — days belong in Gantt only) S/M/Lrules: S → max 3–6 files, skip brainstorm; M → one planning step; L → full PLAN→BRAINSTORM→EXECUTE- Added
seq.mermaidper flow-based task (auth, CRUD, API, CI pipelines, multi-step sequences) - Updated
SKILL.mdchecklist: 3 new items enforcing Token Budget standard
- Commands now invoke agents via the
Agenttool withsubagent_type+run_in_background /implement→ architect + backend-dev + frontend-dev in parallel → qa-engineer sequential/plan-sprint→ product-manager + project-manager in parallel → orchestrator/review-impact→ architect (blast-radius) + qa-engineer in parallel/create-docs→ systems-analyst + dba in parallel after scaffold- Added
PreToolUsehook: tracks active file in real time → shown in statusline - Upgraded
statusline-command.sh: agent name, turn counter, active file, cost formatting,│separator - Removed
plan.mdcommand (never existed as a file — use/plan-sprint) - Updated
activate.mdwith all 17 agents
- Added
agents/13-systems-analyst.md— use cases, user stories, process flows, sequence diagrams - Added
agents/14-dba.md— ERD, SQL schema, data dictionary, data integrity rules - Added
skills/business-analysis/SKILL.md— 12-section template library for all BA artifacts - Added
commands/create-docs.md— scaffolds complete docs/ folder at project start - Added
references/business-analysis.md— full methodology guide for the workspace builder - Updated
SKILL.md— business analysis phase now mandatory in workspace generation - Updated
references/structure.md— reflects new agents, skill, and command
- Added conventional commits, naming conventions, terminal commands, domain glossary
- Added parallel worktrees documentation for isolated multi-agent work
- Fixed statusline dependencies (jq, chmod +x, correct JSON fields)
- 13 agents, 11 skills, 12 commands, 6 rules, 8 diagrams, 5 memory files
- refactoring.guru — Design patterns & code smells
- aitmpl.com — 1000+ Claude Code templates
- Claude Platform Docs — Best practices & prompting
- code-review-graph — Graph-based code review concept
- claude-code-best-practice — Community best practices
- BABOK v3 — Business Analysis Body of Knowledge (methodology for business analysis layer)
MIT License — see LICENSE for details.
Your support helps maintain and improve this skill with new research and better examples.
