Trace changes in a game design document to related architecture decision records, which explain technical choices. Compare their assumptions with the revised design, report which decisions need review, and guide updates to decisions and requirement links.
Create a game release checklist tailored to target devices and distribution requirements. Review builds, bugs, store information, and launch preparations, then report readiness while clearly separating known blockers from checks that could not be assessed.
Implement a planned game development task by gathering its specifications and design decisions, then assigning the right programming specialist. Coordinate source changes, tests where required, visual evidence, and session state for subsequent review and closure.
Build a quick, disposable game prototype in HTML, a game engine, or on paper to test one core mechanic. Use playtest findings to decide whether to continue, change direction, stop, or leave the idea unassessed.
Break a game concept into the systems it needs, including supporting systems that are easy to overlook. Map dependencies, assign priorities by development stage, and create an index showing the recommended order for detailed design.
Review skill and agent definitions for structural issues and whether their instructions meet expected behavior. Four modes cover structure, test specifications, category criteria, and coverage reports that reveal missing specifications or checks.
Turn game bug descriptions or suspected code problems into structured reports with reproduction steps, severity, and priority. Follow reported bugs through fix verification and closure, recording test results or manual checks before marking an issue closed.
Create an onboarding document for a new contributor or agent, tailored to their role. Gather project context, relevant conventions, key files, current work, and suggested first tasks into a practical starting guide.
Prepare a game's launch day patch by selecting known bugs that are safe to fix quickly. Coordinate minimal fixes, verify affected areas, and document deferred issues, quality checks, rollback procedures, and patch notes.
Turn accepted architecture decisions, project preferences, and engine references into a practical rules document. Organize required patterns, forbidden approaches, and performance limits by architectural layer, with a source attached to each rule.
Review game code for likely performance bottlenecks in processing, memory, rendering, and data loading. Compare available estimates with configured limits and produce ranked optimization recommendations, including expected impact, effort, risks, and areas needing runtime measurement.
Turn small game changes into concise specifications with clear reasons, rules, and acceptance criteria. Check existing design documents and earlier specifications, then document tuning adjustments, minor behavior changes, or small features before implementation.
Translate approved game designs into a technical blueprint before coding begins. Map system layers, module responsibilities, data flow, and API boundaries, then check architecture decisions against the pinned engine and identify missing knowledge or decisions.
Check whether a game project is ready for its next development phase. Review required documents, test evidence, and quality criteria, then receive a readiness verdict with blockers, missing materials, and any checks that could not be completed.
Choose a game engine and version, record the choice in project configuration, and prepare reference documents for newer releases. The skill also supports refreshing those references and guiding migration between engine versions.
Compare existing game tests with key paths in the game design document, find fixed bugs without tests to catch recurrence, and identify coverage gaps from new features. Maintain a release checklist of existing tests.
Document a technical decision in an architecture decision record, or ADR. Capture its context, alternatives, and consequences, assign a record number, and distinguish a proposed decision from an accepted one so dependent work reflects its actual status.
Review a sprint or milestone by comparing planned work with actual results. Summarize completion, estimation gaps, and blockers, then produce a retrospective with specific improvement actions, owners, and deadlines for the next iteration.
Create a game's art direction document, defining its visual rules, mood, shapes, colors, and production standards. Review and approve sections individually, with guidance that connects character, environment, and interface design to the game's concept and technical constraints.
Review game code for architecture, coding standards, testability, and performance concerns. Get findings tied to specific code, checks against recorded design decisions, and a report separating required fixes from optional improvements.
Write a game design document for one system, such as combat, crafting, or dialogue. Work through sections with specialist agent input, check dependencies against existing designs, and save approved sections with progress records for later continuation.
Handle critical bugs in a released game through an emergency workflow. Investigate the cause, prepare a minimal fix, track reviews and tests, and verify the fix reaches development branches, with deployment approval and post-release checks recorded.
Create a game playtest report template or turn session notes into organized feedback. Separate gameplay problems from bugs, compare observations with design intent, and identify priorities for design changes, balance adjustments, and polish.
Turn game design and architecture documents into epics, bounded groups of development work for individual modules. Produce scope documents and an index, showing which requirements have recorded design decisions and where guidance is missing.
Is this your account? Link GitHub to bring it onto your creator page (Japanese)