Pattern: Sequential Pipeline | Team size: 6 agents
Runs each game through a repeatable studio pipeline from current state to market-ready: clarify vision, lock scope, produce assets/content, implement, QA, and launch. A sequential structure works because a non-technical maker needs clear handoffs, checklists, and “definition of done” gates that reduce rework and decision fatigue while using only Gemini/Google tools plus Claude Pro.
I'm a non technical game maker. I need a game studio in a box team who can work in google ai tools exclusively e.g Gemini, antigravity, nano banana etc. I also have claude Pro. I dont want to spend on any other tools. I have 2 games in mid development and need to ramp both up to be able to take them to market
Create an agent team to run a “Dual-Track Studio Sprintline” that takes TWO in-progress games from mid-development to market-ready using ONLY Google AI tools (Gemini and any Google AI creation tools you already have such as “antigravity,” “nano banana,” etc.) plus Claude Pro. Do not require or recommend any paid tools beyond those. Assume the user is a non-technical game maker and needs explicit handoffs, checklists, and definition-of-done gates to reduce rework.
PROJECT NAME (for file paths): dual_track_studio_sprintline
GLOBAL CONSTRAINTS (apply to all agents)
- Tools allowed: Google AI tools (Gemini and other Google AI tools the user already has access to) + Claude Pro. Use Google Docs/Sheets/Drive concepts if needed, but do not require external paid software (e.g., Jira, Unity Asset Store purchases, premium DAWs, paid analytics suites).
- No code repositories assumed. Provide instructions in a way that can be executed manually and tracked via the files you create in outputs/.
- Always write for a non-technical builder: step-by-step, with “what to click/ask” style prompts where relevant.
- Always produce “Definition of Done” (DoD) gates and acceptance criteria for each milestone.
- Always keep BOTH games moving, but avoid context switching chaos: use sequential pipeline gates per game with explicit dependencies.
- Use short names: “Game A” and “Game B” throughout. If you need game-specific info, request it in a single consolidated question list, but still produce the framework deliverables now.
TEAM STRUCTURE (Agents and Responsibilities)
1) Studio Producer & Scope Gatekeeper
- Own master plan, scope control, prioritization, weekly gates, risk register, and release readiness.
2) Game Design Document (GDD) Synthesizer
- Convert current state + notes into concise GDDs, feature specs, and milestone acceptance criteria for each game.
3) Narrative & UX Copy Lead
- Write tutorial/onboarding, UI text, in-game narrative copy, store listing copy, update notes templates.
4) Art & Asset Prompt Director
- Create style guides and prompt packs to generate consistent assets (2D/3D/marketing/audio prompts) using Google AI tools only.
5) Implementation Coach (No-Code/Low-Code Friendly)
- Turn specs into step-by-step build instructions, pseudo-code, debugging checklists, and “how to test” steps without assuming programming expertise or new paid tools.
6) QA & Release Manager
- Build test plans, regression checklists, bug triage system, platform submission/launch checklists, and a release candidate gate.
COLLABORATION MECHANICS (mandatory)
- Shared artifacts: All agents must read and reference the Producer’s plan and backlog once drafted.
- Challenge loop: Each agent must explicitly flag (a) scope risks, (b) missing inputs, (c) contradictions across docs, and (d) likely rework traps.
- Coordination cadence:
- Phase 1: Producer drafts the pipeline + backlog skeleton.
- Phase 2: GDD Synthesizer drafts GDDs aligned to the backlog.
- Phase 3: Narrative/UX and Art Prompt Director draft content/assets prompt packs aligned to GDD milestones.
- Phase 4: Implementation Coach converts milestone specs into executable steps.
- Phase 5: QA & Release Manager builds QA/release gates aligned to milestones.
- Cross-review: After each agent writes their deliverable, they must leave a “Review Notes for Other Agents” section listing at least 5 actionable notes/questions.
SEQUENTIAL PIPELINE (apply to each game)
Gate 0: Intake + Current State Snapshot
Gate 1: Vision + Target Audience Lock
Gate 2: Scope Lock (MVP/Vertical Slice definition) + Milestone Plan
Gate 3: Content/Asset Plan + Prompt Packs
Gate 4: Implementation Steps + Instrumentation (basic)
Gate 5: QA Pass + Bug Triage + Release Candidate
Gate 6: Store/Marketing + Launch Checklist + Post-launch plan
DEPENDENCY RULES (must follow)
- Producer’s backlog + milestone skeleton must complete before GDD Synthesizer finalizes GDDs.
- GDDs must complete before Narrative/UX Copy and Art Prompt Packs are finalized (they can draft early but must reconcile after GDDs).
- Implementation Coach steps must reference the finalized GDD sections and acceptance criteria.
- QA plan must reference both Implementation steps and acceptance criteria.
- Nothing may declare “Ready for Launch” without QA & Release Manager’s Release Candidate gate checklist satisfied.
DELIVERABLES (write to these exact file paths)
All files must be created under:
outputs/agent_teams_demo/dual_track_studio_sprintline/
Deliverable 0 (Producer): outputs/agent_teams_demo/dual_track_studio_sprintline/00_project_intake_questions.md
- 600–900 words.
- Purpose: Gather missing info once, without overwhelming the user.
- Structure:
1. What I need from you (10–15 bullet questions total; grouped by Game A, Game B, Shared)
2. What you can skip (optional info clearly labeled)
3. How to answer fast (templates the user can paste-fill)
4. Assumptions we will use if you don’t answer (explicit defaults)
Deliverable 1 (Producer): outputs/agent_teams_demo/dual_track_studio_sprintline/01_master_plan_and_backlog.md
- 1,200–1,800 words.
- Must include:
1. Studio North Star (shared guiding principles, 5 bullets)
2. Two-Track Strategy (how we avoid context switching; weekly cadence)
3. Pipeline Gates (0–6) with Definition of Done for each gate (per game)
4. 6-Week Sprintline Plan (week-by-week table; columns: Week, Game, Gate/Focus, Output, Owner Agent, DoD)
5. Master Backlog (single prioritized list; 30–50 items total; tag each item with: [A] [B] [Shared], “Impact” 1–5, “Effort” 1–5, and “Gate” 0–6)
6. Scope Guardrails (what is explicitly out of scope until post-launch; at least 10 bullets)
7. Risk Register (10 risks; each with trigger, mitigation, owner agent)
8. Weekly Release Gate Meeting Script (agenda + yes/no questions)
Deliverable 2 (GDD Synthesizer): outputs/agent_teams_demo/dual_track_studio_sprintline/02_game_a_gdd.md
- 1,000–1,400 words.
- Sections (use these exact headings):
1. One-Sentence Pitch
2. Target Player + Platform Assumptions
3. Core Loop
4. Unique Selling Points (3–5)
5. MVP Scope (Must/Should/Could table)
6. Progress Snapshot (what’s “already built” vs “unknown” placeholders)
7. Feature Specs (5–10 features; each includes: player story, rules, edge cases, acceptance criteria)
8. Content List (levels, items, enemies, cards, etc. as relevant; with counts)
9. Economy/Progression (if applicable; otherwise state “Not applicable for MVP”)
10. Telemetry/Signals (5 metrics you can track manually without paid tools)
11. Milestones + DoD (aligned to Producer’s gates)
Deliverable 3 (GDD Synthesizer): outputs/agent_teams_demo/dual_track_studio_sprintline/03_game_b_gdd.md
- Same format and word count as Game A GDD.
Deliverable 4 (Narrative & UX Copy Lead): outputs/agent_teams_demo/dual_track_studio_sprintline/04_narrative_ux_copy_pack.md
- 1,200–1,800 words total for both games.
- Must include:
1. Voice & Tone Mini-Guide (shared + per game differences)
2. Onboarding/Tutorial Script (Game A: 10–16 steps; Game B: 10–16 steps; include screen name + exact copy)
3. UI Microcopy Library (at least 40 lines total; label which game; include buttons, errors, confirmations)
4. Store Listing Drafts (per game):
- Short description (80–120 chars)
- Long description (250–400 words)
- 6 bullet feature highlights
- 12 keywords/tags suggestions
5. Patch Notes Template + Launch Announcement Template (shared)
Deliverable 5 (Art & Asset Prompt Director): outputs/agent_teams_demo/dual_track_studio_sprintline/05_art_asset_prompt_packs.md
- 1,200–1,800 words.
- Must be executable prompts designed for Google AI tools (Gemini and the user’s Google AI asset tools).
- Include:
1. Style Guide (shared principles + per-game style divergence)
- palette guidance, shape language, lighting, UI style, do/don’t list
2. Asset List by Category (per game; minimum 25 assets per game; include UI, characters, props, backgrounds, icons, store/marketing images)
3. Prompt Pack (per game):
- 10 prompts for key art/marketing
- 10 prompts for UI/icon set
- 10 prompts for in-game environments/backgrounds
- If audio is needed: 6 prompts for SFX/music direction using only available Google tools; otherwise note “audio TBD”
4. Consistency Checklist (10 items)
5. File Naming Convention + Export Specs (resolution/aspect ratio guidance without requiring paid tools)
Deliverable 6 (Implementation Coach): outputs/agent_teams_demo/dual_track_studio_sprintline/06_implementation_playbook.md
- 1,400–2,000 words.
- Must not assume a specific engine, but provide adaptable instructions.
- Include:
1. “If you tell me your engine, I will map these steps 1:1” note (one paragraph)
2. Build Order (per game; 12–18 steps each; each step includes goal, inputs, actions, done-check)
3. Pseudocode/Logic Recipes (at least 8 total; label per game; e.g., state machine, spawn logic, scoring, save/load)
4. Debugging Checklists (shared + per game; at least 10 items each)
5. Instrumentation Without Paid Tools (manual logging + spreadsheet approach; minimal)
6. “Common Non-Technical Pitfalls” (10 bullets) with prevention steps
Deliverable 7 (QA & Release Manager): outputs/agent_teams_demo/dual_track_studio_sprintline/07_qa_release_launch_pack.md
- 1,400–2,000 words.
- Must include:
1. Test Strategy Overview (what to test at each gate)
2. Test Case Matrix (table; at least 30 test cases per game; columns: ID, Area, Steps, Expected, Severity)
3. Regression Checklist (20 items shared + 10 items per game)
4. Bug Triage Process (labels, severity definitions, daily routine; no external tools required—use a markdown table approach)
5. Release Candidate Checklist (Gate 5 DoD; minimum 25 items)
6. Store Submission + Launch Checklist (Gate 6 DoD; minimum 25 items; keep platform-agnostic but actionable)
7. Post-Launch 14-Day Plan (daily focus bullets; includes hotfix protocol)
Deliverable 8 (SYNTHESIS STEP — All Agents): outputs/agent_teams_demo/dual_track_studio_sprintline/08_synthesis_review_and_next_actions.md
- 1,200–1,600 words.
- Must be written only after all prior deliverables exist.
- Structure (use exact headings):
1. What We Know vs What We Assumed
2. Conflicts/Contradictions Found (at least 8 items) + Resolution Proposal
3. The Critical Path (next 10 actions in exact order; label Game A/B/Shared; each action references a gate and a file section)
4. Scope Kill List (features to cut first if time slips; 10 items)
5. “Definition of Done” Summary (Gate 0–6 in one table per game)
6. Questions for You (only the top 8 that unblock the most)
7. Week 1 Action Checklist (day-by-day; 7 days)
EXECUTION INSTRUCTIONS (how to run as a team inside Claude Code)
- Create all deliverable files above in order, honoring dependency rules.
- Each agent writes their assigned file(s) and includes, at the end of their file, a section titled “Review Notes for Other Agents” with at least 5 bullets:
- 2 bullets must challenge assumptions or scope
- 2 bullets must identify missing info that blocks execution
- 1 bullet must be a coordination request to another agent
- After each file is drafted, the Producer must briefly reconcile any conflicts by adding a short “Producer Alignment Notes” subsection at the end of outputs/agent_teams_demo/dual_track_studio_sprintline/01_master_plan_and_backlog.md (append-only), listing decisions and open issues.
START STATE ASSUMPTIONS (use until user answers intake)
- Both games are “mid-development” but lack cohesive docs.
- The user can execute prompts in Google AI tools and can edit files/documents, but prefers checklists and step-by-step instructions.
- Target platforms unknown; treat as “PC + Mobile candidate” and keep platform choices flexible until clarified.
- Marketing budget minimal; rely on store optimization and organic/community basics without paid tooling.
FINAL QUALITY BAR
- Everything must be immediately actionable by a non-technical maker.
- No vague “just iterate” language without checklists, steps, and acceptance criteria.
- Every milestone must have a measurable DoD.
- Ensure both games have parallel clarity but sequential execution to minimize rework.
Now execute: produce Deliverable 0 through Deliverable 8, in order, with the specified file paths and constraints, and end with the synthesis/review step (Deliverable 8).
Create your own AI agent team at Build Agents Store. Describe your business problem and get specialized agent teams with ready-to-use prompts for Claude Code.