start
First-time onboarding — asks where you are, then guides you to the right workflow. No assumptions.
它会碰到什么
这一栏是扫描器报的事实，不是结论。命中多不等于有毒（安全工具、规则库、示例脚本本来就会包含危险写法），命中少也不等于干净。它和你手上的凭据、文件、网络有什么关系，需要你自己看。
技能内容
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/orproduction/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.
- Acknowledge that starting from zero is completely fine
- Briefly explain what
/brainstormdoes (guided ideation using professional frameworks — MDA, player psychology, verb-first design). Mention that it has two modes:/brainstorm openfor fully open exploration, or/brainstorm [hint]if they have even a vague theme (e.g., "space", "cozy", "horror"). - Recommend running
/brainstorm openas the next step, but invite them to use a hint if something comes to mind - 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
- Ask them to share their vague idea — even a few words is enough
- Validate the idea as a starting point (don't judge or redirect)
- Recommend running
/brainstorm [their hint]to develop it - 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
- Ask them to describe their concept in one sentence — genre and core mechanic. Use plain text, not AskUserQuestion (it's an open response).
- Acknowledge the concept, then use
AskUserQuestionto 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 documentJump straight in— Go to/setup-enginenow and write the GDD manually afterward
- Show the recommended path:
Concept phase:
/brainstormor/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
- 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]..."
- Sub-case D1 — Early stage (engine not configured or only a game concept exists):
- Recommend
/setup-enginefirst if engine not configured - Then
/project-stage-detectfor 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.
/adoptchecks this specifically." - Recommend:
/project-stage-detect— understand what phase and what's missing entirely/adopt— audit whether existing artifacts are in the right internal format
- 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→ writefullLean (recommended)→ writeleanSolo→ writesolo
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-planor 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
- Ask first — never assume the user's state or intent
- Present options — give clear paths, not mandates
- User decides — they pick the direction
- No auto-execution — recommend the next skill, don't run it without asking
- Adapt — if the user's situation doesn't fit a template, listen and adjust
想直接用这个技能？
本站把开放许可（MIT / Apache 等）的技能按仓库打包整理到网盘，点一下转存到你自己的网盘，不用一个个从 GitHub 拉。许可未声明的技能只给原始仓库链接，不打包。