- Home
- Skills
- Game Development
- Game Systems Architect | Blueprint & Tech Design
More screenshots
Works with the AI Agents you already use
Game Systems Architect | Blueprint & Tech Design
Architect buildable game blueprints with strict system boundaries, event contracts, and vertical-slice milestones.
$1
Game Systems Architect | Blueprint & Tech Design
Example session with this skill installed
Plan the architecture for a top-down 2D extraction shooter in Godot. The player explores a proc-gen map, fights bots, loots gear, and must reach an exit to save progress. I'm a solo dev.
- Read your context and instructions
- Compiled the game systems architect
I have completed the technical blueprint for your extraction shooter. It includes 7 core systems, 5 event contracts, and a 4-stage vertical slice plan.
Game Blueprint: Extraction 2D (Godot)
1. Vision Contract
- Pitch: High-stakes looting where survival is the only way to progress.
- Core Loop: Infiltrate → Scavenge → Combat → Extract → Upgrade.
- Out of Scope: Multiplayer, character customization, persistent base building, vehicle systems.
2. Systems Inventory
| System | Owns (State) | Provides (Events) | Consumes | Complexity |
|---|---|---|---|---|
| MapGen | Tilemap data, NavMesh | map_ready, exit_spawned | None | L (Risk) |
| Inventory | Item list, Weight | item_added, loot_dropped | Input | M |
| Combat | Health, Projectiles | entity_died, hit_taken | Input, MapGen | M |
| Extraction | Timer, Exit status | extraction_started | Combat | S |
3. Event Contracts & Save Design
- Event:
request_extraction(player_id) ->validates player position, starts countdown, triggers UI. - Event:
on_loot_collected(item_data) ->updates inventory state, recalculates movement speed.
Save Logic: JSON-based. Persists Inventory and PlayerStats only upon extraction_complete. Mid-run crashes result in total loss of current run data (Extraction Genre standard).
4. Milestones
- M0 (Core Loop): Character movement, basic shooting, and a static exit point.
- M1 (Proc-Gen): Integration of MapGen system with basic enemy spawners.
- M2 (Persistence): Inventory UI and save/load cycle.
- Cuts for M0: Loot tables, sound effects, reloading logic, enemy AI variety.
Next steps
- Review the MapGen risk spike plan to decide between standard TileMaps or GDExtension for performance.
- Initialize the Godot project using the provided folder structure:
/src/systems/,/src/entities/,/assets/data/. - Begin implementation of the Combat system using a State Machine pattern.
Connects securely to your tools. The creator never sees your data.
About this skill
Stop building games by trial and error. This skill forces technical rigor onto your game design before you open an editor or write a single script. It prevents the common death spirals of scope creep, circular dependencies, and orphaned systems by generating a comprehensive technical design document that maps player experiences directly to system owners.
What it does
- Vision Contracting defines the core loop, scope facts, and a critical "out of scope" list to prevent bloat.
- Player Journey Mapping pairs every player action with the specific developer system required to make it happen.
- Systems Inventory establishes strict ownership boundaries for state and logic with complexity tiering.
- Event & Data Flow maps cross-system communication using typed event contracts and a single-writer ownership matrix.
- Milestone Planning breaks development into playable vertical slices rather than technical layers, including specific "cut lists" for each phase.
How it works
- Vision Phase: You provide the game pitch and constraints, and the agent interviews you to solidify the core loop.
- Architecture Pass: The agent maps the player journey to system candidates and resolves ownership.
- Contract Definition: The agent generates the event flow and persistence rules for the save system.
- Blueprint Delivery: You receive a structured technical design document ready for implementation.
Frameworks & tools
This skill is engine-agnostic but provides engine-aware folder structures and pattern picks for Unity, Godot, and Unreal. It follows modular architecture principles and FSM/Behavior Tree patterns.
Why this beats prompting it yourself
Generic prompts often result in vague feature lists rather than buildable blueprints. This skill enforces a verification checklist that catches circular dependencies and orphaned systems that standard LLM outputs typically ignore.
Use cases
- Designing a new indie project to ensure the scope fits a solo developer timeline.
- Auditing an existing project to identify technical debt and system bottlenecks.
- Preparing a technical design document for a development team or AI implementation agents.
Known limitations
Does not generate executable code or assets. Requires a fixed engine choice to provide specific folder layouts and design patterns.
Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Game Development.
Focuses on architecture, not implementation. Does not write game scripts. Requires an engine choice for folder structures. Engine-agnostic logic requires manual translation to specific API calls.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before buying a skill.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed 9 days ago