# Start > Incorporación inicial guiada: pregunta en qué punto estás y te dirige al flujo de trabajo correcto, sin asumir nada. Fuente: https://skillsagentes.com/skills/donchitos/claude-code-game-studios/start Markdown: https://skillsagentes.com/skills/donchitos/claude-code-game-studios/start.md Repositorio: https://github.com/Donchitos/Claude-Code-Game-Studios Autor: Donchitos Licencia: MIT Actualizado: hace 3 meses Coste de contexto: 25 tok instalada, 3.4k tok al activarse, 3.4k tok con todos los archivos del bundle Bundle: 1 archivo, 13 KB Permisos que pide: read, glob, grep, write, askuserquestion ## Instalación Un skill son archivos markdown: los mismos archivos valen para cualquier agente y lo único que cambia es el directorio de destino, es decir la bandera `--agent`. Añade `-g` para instalarlo en todos los proyectos de la máquina. ```bash # Claude Code npx -y skills add Donchitos/Claude-Code-Game-Studios --skill start --agent claude-code # Cursor npx -y skills add Donchitos/Claude-Code-Game-Studios --skill start --agent cursor # Codex npx -y skills add Donchitos/Claude-Code-Game-Studios --skill start --agent codex # Gemini CLI npx -y skills add Donchitos/Claude-Code-Game-Studios --skill start --agent gemini # Windsurf npx -y skills add Donchitos/Claude-Code-Game-Studios --skill start --agent windsurf # Cline npx -y skills add Donchitos/Claude-Code-Game-Studios --skill start --agent cline ``` ## Qué hace - Detecta el estado del proyecto (motor, GDD, código, prototipos) sin mostrarlo aún - Pregunta al usuario en qué punto está con su idea de juego usando AskUserQuestion - Enruta hacia el flujo de trabajo adecuado según la respuesta (A-D) - Configura el modo de revisión y escribe production/review-mode.txt y production/stage.txt - Confirma el primer paso y entrega el control al siguiente skill sin ejecutarlo automáticamente ## Cuándo usarla - Es la primera vez que usas el sistema y no sabes por dónde empezar - No tienes claro si tienes una idea de juego, motor o experiencia previa - Quieres que se te guíe hacia el flujo correcto según tu progreso actual ## Qué la activa - "/start" - "No sé por dónde empezar con mi juego" - "Ayúdame a orientarme en este proyecto de juego" ## Antes de instalar - writes to your files ## Archivos - SKILL.md — 13 KB ## SKILL.md Reproducido tal cual desde Donchitos/Claude-Code-Game-Studios bajo MIT. Esta sección es el documento original y está en inglés. # Guided Onboarding This skill writes one file: `production/review-mode.txt` (review mode config set in Phase 3b). This skill is the entry point for new users. It does NOT assume you have a game idea, an engine preference, or any prior experience. It asks first, then routes you to the right workflow. --- ## Phase 1: Detect Project State Before asking anything, silently gather context so you can tailor your guidance. Do NOT show these results unprompted — they inform your recommendations, not the conversation opener. Check: - **Engine configured?** Read `.claude/docs/technical-preferences.md`. If the Engine field contains `[TO BE CONFIGURED]`, the engine is not set. - **Game concept exists?** Check for `design/gdd/game-concept.md`. - **Source code exists?** Glob for source files in `src/` (`*.gd`, `*.cs`, `*.cpp`, `*.h`, `*.rs`, `*.py`, `*.js`, `*.ts`). - **Prototypes exist?** Check for subdirectories in `prototypes/`. - **Design docs exist?** Count markdown files in `design/gdd/`. - **Production artifacts?** Check for files in `production/sprints/` or `production/milestones/`. Store these findings internally to validate the user's self-assessment and tailor recommendations. --- ## Phase 2: Ask Where the User Is This is the first thing the user sees. Use `AskUserQuestion` with these exact options so the user can click rather than type: - **Prompt**: "Welcome to Claude Code Game Studios! Before I suggest anything, I'd like to understand where you're starting from. Where are you at with your game idea right now?" - **Options**: - `A) No idea yet` — I don't have a game concept at all. I want to explore and figure out what to make. - `B) Vague idea` — I have a rough theme, feeling, or genre in mind (e.g., "something with space" or "a cozy farming game") but nothing concrete. - `C) Clear concept` — I know the core idea — genre, basic mechanics, maybe a pitch sentence — but haven't formalized it into documents yet. - `D) Existing work` — I already have design docs, prototypes, code, or significant planning done. I want to organize or continue the work. Wait for the user's selection. Do not proceed until they respond. --- ## Phase 3: Route Based on Answer #### If A: No idea yet The user needs creative exploration before anything else. 1. Acknowledge that starting from zero is completely fine 2. Briefly explain what `/brainstorm` does (guided ideation using professional frameworks — MDA, player psychology, verb-first design). Mention that it has two modes: `/brainstorm open` for fully open exploration, or `/brainstorm [hint]` if they have even a vague theme (e.g., "space", "cozy", "horror"). 3. Recommend running `/brainstorm open` as the next step, but invite them to use a hint if something comes to mind 4. Show the recommended path: **Concept phase:** - `/brainstorm open` — discover your game concept - `/setup-engine` — configure the engine (brainstorm will recommend one) - `/prototype` — throwaway concept build: validate the core idea is fun before designing (1–3 days) - `/art-bible` — define visual identity (uses the Visual Identity Anchor brainstorm produces) - `/map-systems` — decompose the concept into systems - `/design-system` — author a GDD for each MVP system - `/review-all-gdds` — cross-system consistency check - `/gate-check` — validate readiness before architecture work **Architecture phase:** - `/create-architecture` — produce the master architecture blueprint and Required ADR list - `/architecture-decision (×N)` — record key technical decisions, following the Required ADR list - `/create-control-manifest` — compile decisions into an actionable rules sheet - `/architecture-review` — validate architecture coverage **Pre-Production phase:** - `/ux-design` — author UX specs for key screens (main menu, HUD, core interactions) - `/vertical-slice` — production-quality end-to-end build to validate the full game loop - `/playtest-report (×1+)` — document each vertical slice playtest session - `/create-epics` — map systems to epics - `/create-stories` — break epics into implementable stories - `/sprint-plan` — plan the first sprint **Production phase:** → pick up stories with `/dev-story` #### If B: Vague idea 1. Ask them to share their vague idea — even a few words is enough 2. Validate the idea as a starting point (don't judge or redirect) 3. Recommend running `/brainstorm [their hint]` to develop it 4. Show the recommended path: **Concept phase:** - `/brainstorm [hint]` — develop the idea into a full concept - `/setup-engine` — configure the engine - `/prototype` — throwaway concept build: validate the core idea is fun before designing (1–3 days) - `/art-bible` — define visual identity (uses the Visual Identity Anchor brainstorm produces) - `/map-systems` — decompose the concept into systems - `/design-system` — author a GDD for each MVP system - `/review-all-gdds` — cross-system consistency check - `/gate-check` — validate readiness before architecture work **Architecture phase:** - `/create-architecture` — produce the master architecture blueprint and Required ADR list - `/architecture-decision (×N)` — record key technical decisions, following the Required ADR list - `/create-control-manifest` — compile decisions into an actionable rules sheet - `/architecture-review` — validate architecture coverage **Pre-Production phase:** - `/ux-design` — author UX specs for key screens (main menu, HUD, core interactions) - `/vertical-slice` — production-quality end-to-end build to validate the full game loop - `/playtest-report (×1+)` — document each vertical slice playtest session - `/create-epics` — map systems to epics - `/create-stories` — break epics into implementable stories - `/sprint-plan` — plan the first sprint **Production phase:** → pick up stories with `/dev-story` #### If C: Clear concept 1. Ask them to describe their concept in one sentence — genre and core mechanic. Use plain text, not AskUserQuestion (it's an open response). 2. Acknowledge the concept, then use `AskUserQuestion` to offer two paths: - **Prompt**: "How would you like to proceed?" - **Options**: - `Formalize it first` — Run `/brainstorm [concept]` to structure it into a proper game concept document - `Jump straight in` — Go to `/setup-engine` now and write the GDD manually afterward 3. Show the recommended path: **Concept phase:** - `/brainstorm` or `/setup-engine` — (their pick from step 2) - `/prototype` — throwaway concept build: validate the core idea is fun before designing (1–3 days) - `/art-bible` — define visual identity (after brainstorm if run, or after concept doc exists) - `/design-review` — validate the concept doc - `/map-systems` — decompose the concept into individual systems - `/design-system` — author a GDD for each MVP system - `/review-all-gdds` — cross-system consistency check - `/gate-check` — validate readiness before architecture work **Architecture phase:** - `/create-architecture` — produce the master architecture blueprint and Required ADR list - `/architecture-decision (×N)` — record key technical decisions, following the Required ADR list - `/create-control-manifest` — compile decisions into an actionable rules sheet - `/architecture-review` — validate architecture coverage **Pre-Production phase:** - `/ux-design` — author UX specs for key screens (main menu, HUD, core interactions) - `/vertical-slice` — production-quality end-to-end build to validate the full game loop - `/playtest-report (×1+)` — document each vertical slice playtest session - `/create-epics` — map systems to epics - `/create-stories` — break epics into implementable stories - `/sprint-plan` — plan the first sprint **Production phase:** → pick up stories with `/dev-story` #### If D: Existing work 1. Share what you found in Phase 1: - "I can see you have [X source files / Y design docs / Z prototypes]..." - "Your engine is [configured as X / not yet configured]..." 2. **Sub-case D1 — Early stage** (engine not configured or only a game concept exists): - Recommend `/setup-engine` first if engine not configured - Then `/project-stage-detect` for a gap inventory **Sub-case D2 — GDDs, ADRs, or stories already exist:** - Explain: "Having files isn't the same as the template's skills being able to use them. GDDs might be missing required sections. `/adopt` checks this specifically." - Recommend: 1. `/project-stage-detect` — understand what phase and what's missing entirely 2. `/adopt` — audit whether existing artifacts are in the right internal format 3. Show the recommended path for D2: - `/project-stage-detect` — phase detection + existence gaps - `/adopt` — format compliance audit + migration plan - `/setup-engine` — if engine not configured - `/design-system retrofit [path]` — fill missing GDD sections - `/architecture-decision retrofit [path]` — add missing ADR sections - `/architecture-review` — bootstrap the TR requirement registry - `/gate-check` — validate readiness for next phase --- ## Phase 3c: Write Initial Stage File After confirming the starting path (and before asking about review mode), write the initial stage to `production/stage.txt`. Create the `production/` directory if it does not exist. Stage mapping: - **Path A, B, or C (starting from scratch)**: write `Concept` - **Path D, existing project, engine not configured or only a game concept exists**: write `Concept` - **Path D, existing project with GDDs but no architecture documents**: write `Systems Design` - **Path D, existing project with full architecture (ADRs, architecture doc)**: write `Technical Setup` Do this silently — no "May I write?" needed for this single-line file. Say: "I've set `production/stage.txt` to `[stage]` — this anchors your status line and stage detection." --- ## Phase 3b: Set Review Mode Check if `production/review-mode.txt` already exists. **If it exists**: Read it and show the current mode — "Review mode is set to `[current]`." — then proceed to Phase 4. Do not ask again. **If it does not exist**: Use `AskUserQuestion`: - **Prompt**: "One setup choice: how much design review would you want as you work through the workflow?" - **Options**: - `Full` — Director specialists review at each key workflow step. Best for teams, learning the workflow, or when you want thorough feedback on every decision. - `Lean (recommended)` — Directors only at phase gate transitions (/gate-check). Skips per-skill reviews. Balanced approach for solo devs and small teams. - `Solo` — No director reviews at all. Maximum speed. Best for game jams, prototypes, or if the reviews feel like overhead. Write the choice to `production/review-mode.txt` immediately after the user selects — no separate "May I write?" needed, as the write is a direct consequence of the selection: - `Full` → write `full` - `Lean (recommended)` → write `lean` - `Solo` → write `solo` Create the `production/` directory if it does not exist. --- ## Phase 4: Confirm Before Proceeding After presenting the recommended path, use `AskUserQuestion` to ask the user which step they'd like to take first. Never auto-run the next skill. - **Prompt**: "Would you like to start with [recommended first step]?" - **Options**: - `Yes, let's start with [recommended first step]` - `I'd like to do something else first` --- ## Phase 5: Hand Off When the user confirms their next step, respond with a single short line: "Type `[skill command]` to begin." Nothing else. Do not re-explain the skill or add encouragement. The `/start` skill's job is done. Verdict: **COMPLETE** — user oriented and handed off to next step. --- ## Edge Cases - **User picks D but project is empty**: Gently redirect — "It looks like the project is a fresh template with no artifacts yet. Would Path A or B be a better fit?" - **User picks A but project has code**: Mention what you found — "I noticed there's already code in `src/`. Did you mean to pick D (existing work)?" - **User is returning (engine configured, concept exists)**: Skip onboarding entirely — "It looks like you're already set up! Your engine is [X] and you have a game concept at `design/gdd/game-concept.md`. Review mode: `[read from production/review-mode.txt, or 'lean (default)' if missing]`. Want to pick up where you left off? Try `/sprint-plan` or just tell me what you'd like to work on." - **User doesn't fit any option**: Let them describe their situation in their own words and adapt. --- ## Collaborative Protocol 1. **Ask first** — never assume the user's state or intent 2. **Present options** — give clear paths, not mandates 3. **User decides** — they pick the direction 4. **No auto-execution** — recommend the next skill, don't run it without asking 5. **Adapt** — if the user's situation doesn't fit a template, listen and adjust ## Dónde encaja - Categoría: [Productividad](https://skillsagentes.com/categorias/productividad.md) — Planificación, toma de notas y automatización de flujos personales. - Creador: [Donchitos](https://skillsagentes.com/creators/donchitos.md) — 73 skills en el directorio - [Todas las skills](https://skillsagentes.com/skills.md) - [Ranking de instalaciones](https://skillsagentes.com/ranking.md) ## Otras skills del mismo repositorio - [Team Qa](https://skillsagentes.com/skills/donchitos/claude-code-game-studios/team-qa.md): Orquesta al equipo de QA (qa-lead y qa-tester) para producir un paquete completo de QA: plan de pruebas, smoke check, casos de prueba, ejecución manual y reporte de sign-off. - [Consistency Check](https://skillsagentes.com/skills/donchitos/claude-code-game-studios/consistency-check.md): Compara todos los GDDs contra el registro de entidades para detectar inconsistencias entre documentos: mismo stat, ítem o fórmula con valores distintos, usando un enfoque grep-first. - [Create Architecture](https://skillsagentes.com/skills/donchitos/claude-code-game-studios/create-architecture.md): Redacción guiada, sección por sección, del documento de arquitectura maestro del juego, consciente de la versión del motor y de sus posibles brechas de conocimiento. - [Day One Patch](https://skillsagentes.com/skills/donchitos/claude-code-game-studios/day-one-patch.md): Prepara un patch day-one para el lanzamiento de un juego: define alcance, prioriza, implementa y valida con un QA gate ligero, como un mini-sprint con plan de rollback. - [Hotfix](https://skillsagentes.com/skills/donchitos/claude-code-game-studios/hotfix.md): Flujo de arreglo urgente que se salta el proceso normal de sprint pero deja rastro de auditoría completo: crea rama hotfix, registra aprobaciones y asegura el backport correcto. --- Skills Agentes · [Índice de páginas en markdown](https://skillsagentes.com/sitemap.md) · [Inicio](https://skillsagentes.com/index.md)