architecture-decision

Document technical decisions as standardized Architecture Decision Records for Babylon.js projects.

Updated Jul 16, 2026
One-click install
npx skills add https://github.com/johnatas-henrique/overdrive --skill architecture-decision-johnatas-henrique
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-decision
Source: https://github.com/johnatas-henrique/overdrive/tree/main/.opencode/skills/architecture-decision
Command: npx skills add https://github.com/johnatas-henrique/overdrive --skill architecture-decision-johnatas-henrique

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill eliminates the risk of undocumented, inconsistent technical decisions that lead to knowledge gaps, conflicting implementations, and repeated debates over past trade-offs for game development projects.

Core Features & Use Cases

  • Standardized ADR Generation: Creates fully formatted Architecture Decision Records (ADRs) that capture context, alternatives, consequences, and engine compatibility for major technical choices.
  • Retrofit Mode: Updates existing ADRs to add missing required sections like status, dependencies, and GDD linkage without modifying existing content.
  • Consistency Enforcement: Validates proposed decisions against existing architectural registry stances and engine-specific best practices to avoid contradictory system designs.
  • Use Case: When your team is selecting a networking solution for the 90s F1 racing game, use this skill to document the trade-offs between WebRTC and custom socket implementations, record dependencies on other ADRs, and validate the choice against Babylon.js compatibility requirements.

Quick Start

Invoke the architecture-decision skill with the title 'event-system-architecture' to start documenting your team's choice of event handling pattern for the game's core systems.

Frequently Asked Questions about architecture-decision

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

FAQPage Schema
How do I document technical trade-offs for game development system architecture?

Architecture decision records document technical trade-offs by standardizing context, alternatives, and consequences into a persistent registry. This prevents repeated debates over past engine selection choices and resolves team knowledge gaps.

What is an architecture decision record and when do I need one?

An architecture decision record is a standardized technical document capturing system design choices, dependencies, and engine compatibility constraints. You need one when selecting core systems like networking solutions or event handling patterns to enforce architectural consistency.

Can I use architecture decision records to validate choices against Babylon.js compatibility?

Architecture decision records validate choices against Babylon.js compatibility by cross-referencing proposed decisions with engine-specific documentation and breaking change logs. This ensures your system architecture aligns with engine best practices and avoids contradictory designs.

How do I update existing ADRs to add missing sections without losing content?

Updating existing ADRs to add missing sections without losing content uses a retrofit mode that appends required fields like status, dependencies, and game design document linkage. This preserves original technical trade-off evaluations while enforcing standardized documentation compliance.

Does this architecture decision tool work for evaluating WebRTC versus custom socket implementations?

The architecture decision tool evaluates WebRTC versus custom socket implementations by documenting networking trade-offs, recording cross-dependencies on other ADRs, and validating the final choice against Babylon.js compatibility requirements for your racing game.

Why should I enforce architectural consistency when selecting a game engine event system?

Enforcing architectural consistency when selecting a game engine event system prevents conflicting implementations and contradictory designs across your team. Validating proposals against an existing architectural registry ensures traceable, compatible technical choices for your Babylon.js project.