Own the creative vision across pillars, art direction, audio direction, narrative tone, and target audience. The creative director is the arbiter when design decisions conflict with aesthetic direction.

Decompose the concept into verifiable units for downstream stages. Gamedev elaboration differs from other studios — early units often target the *prototype*, not final production.

Define the game's pillars, core loop, fantasy, and player experience. Decisions here lock in what the rest of production builds toward — vague pillars produce muddled games.

Iterate the core loop during prototype. The designer's job here is to watch playtests, identify what's not landing, and change the design — not defend the concept doc.

Run playtests with real players outside the team and capture honest feedback on whether the core loop is fun. The team always thinks their prototype is fun — playtesters are how you find out.

Build the smallest playable thing that validates the core loop. Prototype code is disposable — prioritize speed and answerability over architecture, polish, or maintainability.

Build the actual content that the player experiences — levels, encounters, narrative beats, quests, audio cues, visuals. Content authors work against the systems built by gameplay-engineers and must not be blocked on engineering support for routine authoring.

Implement the validated core loop at production quality. Unlike prototype code, production code is maintainable, testable, and survives the full project. Build the systems that the rest of content and design lean on.

Review production work for adherence to pillars, concept, and scope. The reviewer is the scope gatekeeper — production is where scope creep shows up, and the reviewer's job is to catch it before it compounds.

Design the interlocking systems that make up the full game — economies, progression curves, difficulty tuning, meta-systems. Systems designers work at the game-level math layer, one step above individual mechanics.

Fix gameplay bugs, resolve edge cases, and smooth out rough systems code. Polish-phase engineering is reactive — you're fixing what playtesters and QA surface, not building new things.

Optimize the game to meet platform performance targets — frame rate, load times, memory footprint, thermal behavior on mobile/console. Performance problems that ship become review-score problems.

Find bugs and regressions before players do. Polish-phase QA is about volume and coverage — touch every system, every content piece, every platform, and catch what the team missed.

Tune game feel — timing, responsiveness, juice, pacing, difficulty curves. Tuning is what separates a functional game from a game that feels great, and players can always tell the difference even if they can't articulate why.

Navigate platform certification requirements for each target platform. Every platform has its own TRC/XR/lotcheck requirements and rejection reasons — the cert specialist knows them and preps the build to pass.

Build, package, and submit the game to target storefronts and platform holders. Manage the submission pipeline, handle rejections, ship patches, and own the post-launch hotfix loop.