# claude-dreamteam **You shouldn't need to learn Claude Code to use Claude Code.** One command to unlock 100% of Claude Code's power. Zero learning curve. ```bash npx claude-dreamteam init ``` --- ## The Problem Claude Code is a Ferrari with no steering wheel. The engine is incredible — but to actually use it, you need to: - Learn CLAUDE.md syntax and what to put in it - Learn agent YAML frontmatter and how to write good agent prompts - Learn skills structure and how triggering works - Learn commands and `$ARGUMENTS` - Learn memory system and the 200-line limit - Learn MCP server configuration - Learn hooks format - Figure out how all of these connect to each other That's not vibe coding. That's hours of reading documentation before writing a single line of your actual project. Most people install Claude Code, type a few prompts, and never unlock 90% of what it can do. Not because they're not smart enough — because the setup barrier is too high. --- ## Without Dream Team vs With Dream Team **Without** — you manually create each file, one by one, after reading docs: ``` You: "How do I set up agents?" Google: *reads docs for 30 minutes* You: *creates one agent file with basic frontmatter* You: "Now how do skills work?" Google: *reads more docs* ... 3 hours later, you have a half-configured environment ``` **With** — you describe your idea and everything gets built: ``` You: /dream food delivery app with React Native, Node.js, and Stripe Claude: [Level 1] Building CLAUDE.md... done CLAUDE.md (94 lines) — architecture, conventions, directory structure .gitignore — configured for Node.js [Level 2] Building MCP config... done .mcp.json — 3 servers (github, postgres, filesystem) [Level 3] Building skills and commands... done Skills: react-native-patterns, nodejs-patterns, project-conventions Commands: add, test, review, new-screen, new-endpoint [Level 4] Building memory system... done MEMORY.md (138 lines) — master index codebase-map, patterns, antipatterns — ready [Level 5] Building specialized agents... done dev-mobile.md (sonnet) — owns app/screens/, app/components/ dev-backend.md (sonnet) — owns server/routes/, server/services/ dev-tester.md (sonnet, background: true) — owns __tests__/ dev-reviewer.md (opus, read-only) — code review specialist Your Level: 5 / 10 — "Multi-Agent" [=========================.............] 5/10 Ready! Try: /add user authentication with phone number ``` **2 minutes. Zero documentation. Full environment.** --- ## Quick Start ### 1. Install (once) ```bash npx claude-dreamteam init ``` ### 2a. New project — describe your idea ```bash mkdir my-app && cd my-app claude ``` ``` /dream SaaS analytics dashboard with Next.js, Python FastAPI, PostgreSQL, Stripe billing, deployed on Vercel ``` ### 2b. Existing project — scan and set up ```bash cd my-existing-app claude ``` ``` /setup ``` The orchestrator scans your codebase, detects your tech stack from actual files, and builds the Claude Code environment around what already exists. ### 3. Start building ``` /add user authentication with Google OAuth ``` ### 4. Level up when ready ``` /level-up ``` --- ## 7 Commands — All Plain English No jargon. No dev knowledge needed. Just type what you want. ### Build & Grow | Command | What it does | |---------|-------------| | `/dream` `"your idea"` | **New project** — describe your idea, get everything built | | `/setup` | **Existing project** — scans your code, builds the environment around it | | `/level-up` | See your current level (0-10), build the next one | | `/evolve` | Auto-find and fix gaps in your agents, skills, and memory | ### Everyday Use | Command | What it does | |---------|-------------| | `/fix` `"what's broken"` | Describe the bug in plain English, get it fixed | | `/ship` | Save your work and push to GitHub (auto-generates commit message) | | `/explain` `"anything"` | Explain code, errors, or concepts like you're not a developer | | `/status` | Quick health check — what's working, what changed, what to do next | ### Real Workflow Example ``` /dream fitness tracker app with React Native and Firebase ... orchestrator builds your entire dev environment ... /add user profile page with avatar upload ... specialist agent builds the feature ... /fix the avatar doesn't show after upload ... agent finds the bug, fixes it, explains what happened ... /explain what does useEffect do in the profile component ... explains in plain English, no jargon ... /ship ... commits with message "Add user profile with avatar upload", pushes to GitHub ... /status ... shows: 12 files changed, all tests passing, suggests adding unit tests ... /level-up ... scans environment, shows Level 5, offers to build Level 6 (hooks & automation) ... ``` --- ## The 10 Levels Most Claude Code users are stuck at Level 0-1. The gap between levels isn't knowledge — it's setup. ``` Level 0 Terminal Tourist You type prompts and hope for the best Level 1 Foundation CLAUDE.md + .gitignore Level 2 Connected MCP servers (GitHub, databases, APIs) Level 3 Skilled Custom skills + slash commands Level 4 Remembering Memory system — project learns over time Level 5 Multi-Agent Specialist agents working together Level 6 Automated Hooks (auto-format on save) + permissions Level 7 Extended Advanced MCP + agents scoped to servers Level 8 Orchestrated Pipeline agents, background work, safe experiments Level 9 Workflow Multi-step commands: /deploy, /sprint, /refactor Level 10 Self-Evolving Agents that improve other agents ``` Every level creates only native Claude Code files (markdown + JSON). No bash scripts. No cron jobs. **Works on Windows, Mac, and Linux identically.** `/dream` builds you to **Level 5** by default. `/level-up` takes you higher, one step at a time. `/evolve` strengthens what you already have. --- ## What Gets Generated After running `/dream`, your project gets a complete AI development environment: ``` your-project/ CLAUDE.md Project conventions (Claude reads this first) .gitignore Configured for your stack .mcp.json MCP server connections .devteam/ blueprint.json Project analysis .claude/ settings.json Hooks & permissions (Level 6+) agents/ dev-frontend.md Frontend specialist (sonnet) dev-backend.md Backend specialist (sonnet) dev-tester.md Testing specialist (sonnet, background) dev-reviewer.md Code reviewer (opus, read-only) dev-pipeline.md Multi-agent workflows (Level 8+) dev-experiment.md Safe experiments in worktree (Level 8+) loop-controller.md Self-improvement engine (Level 10) skills/ react-patterns/SKILL.md Frontend patterns for YOUR stack fastapi-patterns/SKILL.md Backend patterns for YOUR stack project-conventions/SKILL.md Your project's rules and style commands/ add.md Add a feature by describing it test.md Run tests, explain results review.md Code review deploy.md Deployment pipeline (Level 9+) sprint.md Plan & execute work (Level 9+) memory/ MEMORY.md Master knowledge base (auto-loaded) codebase-map.md Every module indexed patterns.md Discovered patterns antipatterns.md Known pitfalls decisions.md Architecture decisions ``` Everything is tailored to YOUR project. Not templates. Not generic. **Real, specific infrastructure.** --- ## Every Claude Code Feature — Configured Automatically Dream Team doesn't reinvent anything. It configures what Claude Code already has: | Claude Code Feature | What Dream Team does with it | |---------|------------------------------| | **CLAUDE.md** | Generates project conventions, architecture, agent routing | | **Agents** | Creates specialists with full frontmatter (model, permissions, skills, MCP, hooks) | | **Skills** | Builds patterns with progressive disclosure (SKILL.md + references/), pushy descriptions for reliable triggering | | **Commands** | 7 global + project-specific commands generated from your stack | | **Memory** | Persistent knowledge base — codebase map, patterns, antipatterns, decisions | | **MCP Servers** | Auto-detects from your stack, scopes per agent via `mcpServers:` | | **Hooks** | Auto-format on file saves, agent completion notifications | | **Model routing** | `opus` for thinking, `sonnet` for building, `haiku` for simple tasks | | **Permission modes** | `acceptEdits` for builders, `plan` for reviewers — no permission spam | | **Background agents** | `background: true` on testers for concurrent work | | **Worktree isolation** | `isolation: worktree` for safe experiments that can't break your code | | **Tool scoping** | `disallowedTools: Write, Edit` on reviewers — read-only by design | | **Agent chaining** | Pipeline agents that delegate to specialists via Agent tool | **You get all of this without knowing any of it exists.** --- ## What Gets Installed The package itself is tiny. 9 files into `~/.claude/`: ``` ~/.claude/ agents/ orchestrator.md The brain — one agent that knows all 10 levels commands/ dream.md /dream — build from a project idea setup.md /setup — scan existing project, build environment level-up.md /level-up — grow to the next level evolve.md /evolve — auto-improve environment fix.md /fix — describe a bug, get it fixed ship.md /ship — commit and push changes explain.md /explain — plain English explanations status.md /status — project health check ``` No dependencies. No background processes. No config files. The orchestrator generates everything else dynamically based on your project. --- ## CLI Reference ```bash npx claude-dreamteam init # Install globally (all projects) npx claude-dreamteam init --force # Reinstall, overwrite modified files npx claude-dreamteam init-local # Install in current project only npx claude-dreamteam status # Check what's installed npx claude-dreamteam uninstall # Remove everything npx claude-dreamteam --version # Show version ``` --- ## How It Works The orchestrator is a single Claude Code agent (~1000 lines) that carries the knowledge of all 10 levels. **`/dream`** analyzes your project idea, creates a blueprint, then builds each level sequentially. It delegates to sub-agents for each level, runs quality checks, and presents everything created. **`/level-up`** scans your environment file by file, calculates your current level, shows what the next level unlocks, and builds it. **`/evolve`** runs a gap analysis across all agents, skills, commands, and memory. Scores each area 1-10. Fixes the top 5 weaknesses. Reports the improvement. --- ## FAQ **Does this work with any tech stack?** Yes. React, Vue, Angular, Svelte, Next.js, FastAPI, Django, Express, Rails, Go, Rust, Flutter, React Native, and anything else. The orchestrator analyzes whatever you describe. **Does it generate actual code for my app?** No. It generates the Claude Code *infrastructure* (agents, skills, commands, memory) that helps you build your app faster. Think of it as hiring an AI dev team, not building your app. **Can I customize what it generates?** Everything is plain markdown files. Edit any agent, skill, or command after generation. The orchestrator creates the starting point — you own it from there. **What model does it use?** The orchestrator uses Opus for deep analysis. Generated agents use smart routing: Opus for architecture and review, Sonnet for implementation, Haiku for simple tasks. You can change any agent's model. **Will it overwrite my existing files?** The CLI protects modified files. If you edited a file, `init` skips it unless you pass `--force`. The orchestrator never deletes user-created files. **Does it work on Windows?** Yes. Every level uses only native Claude Code files (markdown + JSON). No bash scripts, no cron, no OS-specific tools. Windows, Mac, Linux — identical. **How is this different from Claude Code's built-in /init?** Claude Code's `/init` generates a basic CLAUDE.md. That's Level 1. Dream Team builds Levels 1-10: agents, skills, commands, memory, MCP, hooks, pipelines, and a self-improving loop. **Is this free?** The package is free. You need a Claude Code subscription (which uses your own API credits). --- ## License MIT --- Built by [@haytamAroui](https://github.com/haytamAroui)