One-click install
npx skills add https://github.com/MichaelSolati/mkai --skill architecture-review-michaelsolati
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-review
Source: https://github.com/MichaelSolati/mkai/tree/main/profiles/game-dev/skills/architecture-review
Command: npx skills add https://github.com/MichaelSolati/mkai --skill architecture-review-michaelsolati

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Game development teams frequently encounter costly rework and technical debt when architectural decisions are not aligned with game design documents (GDDs), contain cross-team conflicts, or are incompatible with the project's pinned game engine. This Skill provides a structured, repeatable review process to catch these issues early in the development cycle, before they impact production.

Core Features & Use Cases

  • Full Traceability Matrix Generation: Maps every technical requirement extracted from GDDs to architectural decision records (ADRs) to identify uncovered requirements and coverage gaps, with support for extended Requirements Traceability Matrices (RTM) that link requirements to implementation stories and tests.
  • Cross-ADR Conflict Detection: Automatically identifies contradictions between architectural decisions, including data ownership conflicts, performance budget overruns, dependency cycles, and inconsistent state management rules.
  • Engine Compatibility Auditing: Validates all ADRs against the project's pinned engine version to flag deprecated API usage, version mismatches, and engine-specific anti-patterns, with optional consultation from engine specialist subagents for nuanced validation.
  • Use Case: Use this Skill during the transition from Technical Setup to Pre-Production to validate that your game's architecture is implementation-ready, or after writing new ADRs to ensure they do not introduce conflicts, gaps, or engine incompatibilities.

Quick Start

Use the architecture-review skill to perform a full audit of your game project's architecture against all GDDs and engine requirements, and receive a PASS/CONCERNS/FAIL verdict with a prioritized list of required ADRs to address any gaps.

Frequently Asked Questions about architecture-review

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I validate game architecture against my GDD and engine requirements?

To validate game architecture against a GDD and engine requirements, perform a full audit that maps technical requirements to architectural decision records and checks for engine compatibility. This process generates a traceability matrix and a PASS/CONCERNS/FAIL verdict.

What is a traceability matrix for game architecture and when do I need it?

A traceability matrix for game architecture maps every technical requirement extracted from GDDs to corresponding architectural decision records to identify coverage gaps. You need it during the transition from Technical Setup to Pre-Production to ensure architecture is implementation-ready.

How do I detect conflicts between architectural decision records in game development?

Detect conflicts between architectural decision records by auditing for data ownership contradictions, performance budget overruns, dependency cycles, and inconsistent state management rules. This cross-ADR conflict detection prevents costly rework before production.

Does this architecture audit check game engine compatibility and deprecated APIs?

Yes, the architecture audit validates all ADRs against the project's pinned engine version to flag deprecated API usage, version mismatches, and engine-specific anti-patterns. It ensures engine compatibility before implementation begins.

Can I use this architecture review for a game project transitioning to Pre-Production?

Yes, you can use this architecture review during the transition from Technical Setup to Pre-Production to validate that your game's architecture is implementation-ready. It identifies uncovered requirements and engine incompatibilities early in the cycle.

What are the limitations of using ADRs to cover GDD technical requirements?

A limitation of using ADRs to cover GDD requirements is the potential for hidden cross-team conflicts, dependency cycles, and deprecated API usage if not audited against the pinned engine version. Unaudited records lead to technical debt and costly rework.