Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Game Software Architect Specialist

    1

    Turn gameplay rules into clear timing, state, save and asset contracts, with technical trade-offs and a first implementation slice your team can follow.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Game Software Architect Specialist

    Game Software Architect Specialist

    Example session with this skill installed

    Design an engine-neutral architecture for an offline 2D arena prototype. Confirmed rules: DASH-1, a press consumes one dash and the next dash is permitted after 20 simulation ticks; PAUSE-1, pausing freezes simulation and cooldown while the menu animates; INPUT-1, one captured press may be consumed only once even if a render frame catches up through several simulation ticks. Checkpoints persist position, health and collected pickup IDs, but not an in-progress dash. Engine, tick rate and hold-to-repeat policy are undecided. No project files or tools are available. Give concrete contracts, alternatives, criteria and the first implementable slice without inventing APIs or measured performance.

    • Read your context and instructions
    • Compiled the game software architect

    Illustrative preview: this representative editorial result is not a recorded runtime session.

    task_id: ARENA-ARCH-1
    artifact_id: TIMING-SAVE-CONTRACT
    version: 1
    status: NEEDS_DECISION
    producer / recipient: game architect / prototype owner and developer
    objective / scope: Close simulation, one-shot input and checkpoint boundaries for the supplied arena rules.
    inputs_and_sources: DASH-1, PAUSE-1, INPUT-1 and the checkpoint fields supplied in the request; no repository inspected.
    confirmed_decisions: Offline 2D; cooldown uses simulation ticks; pause freezes simulation; menu animation uses a separate cosmetic clock.
    recommendations_and_pending: Hold/repeat policy, post-load dash availability and input buffering while paused need their decision owner. Engine and tick rate remain unspecified.
    criteria: DASH-1, PAUSE-1, INPUT-1, SAVE-1 proposed below
    next_action: Prototype owner settles the pending input/load policies; developer can begin the resolved clock and one-shot consumption slice.

    Architecture packet
    Player path: capture press -> authoritative simulation accepts or rejects dash -> presentation reacts -> checkpoint serializes the defined durable state.

    Proposed decisions

    1. Simulation owns an integer tick and next_dash_tick. On a permitted dash at tick T, set next_dash_tick = T + 20. Permit again at that boundary, not before it. No seconds conversion or tick frequency is inferred.
    2. Input capture queues one action token per physical press. The simulation consumes a token once, irrespective of catch-up tick count. Held input does not create extra tokens until its policy is settled. Alternative: consume a frame edge directly; simpler but risks reuse across catch-up ticks without an explicit consumed flag.
    3. Pause stops authoritative tick advancement and rule effects. Menu animation follows a cosmetic clock. A single shared wall-clock timer is rejected because it conflicts with PAUSE-1.
    4. The checkpoint codec validates position, health and stable pickup IDs before applying them to temporary state. In-progress dash is excluded. Whether load starts ready or starts a new cooldown is unresolved; do not silently choose.

    Contract / owner / failure

    • Clock: simulation scheduler; tick does not advance while paused; menu has no authority over gameplay.
    • Dash gate: rule state; input is accepted only when the supplied eligibility rules and cooldown permit; repeated delivery must not issue a second dash.
    • Input queue: input adapter; each press has one consumable identity; focus loss and paused buffering follow policies still pending.
    • Save restore: checkpoint coordinator; validation precedes coherent state replacement; malformed data cannot partially overwrite live state.

    Proof map, planned only

    • DASH-1: dash at tick 100; tick 119 rejects, tick 120 permits. Rule-level trace.
    • PAUSE-1: pause at tick 110; elapsed wall time cannot change tick/cooldown; separately inspect menu animation in the chosen engine.
    • INPUT-1: one press followed by a render frame with several catch-up ticks emits at most one accepted dash. Input/scheduler integration probe.
    • SAVE-1, proposed criterion: restore only the three durable fields atomically; post-load dash behavior waits for a decision. Rule codec plus scene integration and invalid-save probes.

    First slice: implement the simulation clock and one-shot token consumption with an isolated rule fixture; defer unresolved hold/buffering and post-load dash behavior. A follow-up engine integration slice must prove input capture and animated menu behavior. No implementation, benchmark, engine run, controller test or playtest was performed; this is a proposed architecture, not a compatibility or fun claim.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Keep your next feature from breaking the game around it.

    Game Software Architect Specialist turns gameplay intent into technical decisions that survive integration. Use it when input, timing, state, saves, scenes or assets cross system boundaries and a quick local fix could create a larger contradiction.

    The method follows a player action from captured input through authoritative rules, presentation and durable state. It names the owner of each transition, compares credible alternatives and chooses a solution sized to your current project. Engine, platform and performance decisions follow your actual constraints rather than a fashionable default architecture.

    Your architecture packet can include

    • Timing, input, state and persistence contracts with observable acceptance criteria.
    • Decisions and alternatives explaining costs, failure modes and when to reconsider.
    • A first implementation slice or technical experiment, plus the integration and device checks it needs.

    For example, define a dash cooldown that freezes during pause while menu animation continues. The specialist can separate clocks, preserve one press across catch-up ticks and specify checkpoint behavior without inventing an engine API.

    Bring confirmed rules, the affected player path, project context and engine/platform details when known. The complete standalone method and reference are included. You supply AI access and project tools. Engine-neutral architecture can begin from a brief; implementing the design and establishing runtime performance require the actual project and target environment.

    Delivers architecture rather than implementation or release certification. Engine behavior, performance, determinism and platform support require checks in the actual target environment. No engine, hardware or AI subscription is included.

    How to use

    1. 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. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    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 1 month ago

    Permissions

    Read Files

    Reading the installed skill and supplied project materials is required for file-based use. Terminal or write access, where declared, is conditional on the requested execution or implementation mode and the buyer's authorization. Planning can use supplied text without those tools. Optional research uses only browsing/network access authorized by the buyer. No credential, environment-variable or account access is mandatory.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    Use it when a feature crosses timing, state, save, asset or platform boundaries, or a consequential technical choice is unresolved. It closes the contracts before implementation.

    Yes. It can produce engine-neutral contracts and compare options from your constraints. Engine-specific APIs and compatibility need the selected engine version and supporting documentation.

    This role delivers the technical decisions, contracts and first implementation slice. Your developer or coding assistant performs the implementation in the available project.

    No. The complete standalone method and reference are included. This role's underlying method is also part of Game Squad Agent Skills; other roles are optional.

    An illustrative timing, input and checkpoint architecture packet. It demonstrates the decision format, rather than a recorded model session, engine run or measured performance result.

    Yes. Personal and commercial project use is permitted. Purchased source materials remain personal and non-transferable under Agensi terms; keep the source private.

    New in APIs & Backend