create-architecture

Name: create-architecture
Availability: InStock
Author: dnkrow

Convert approved GDDs into an engine-version-aware architecture blueprint.

1|Updated May 15, 2026

Search Tags:#data flow #technical requirements #engine compatibility #module ownership #architecture generation #ADR audit #game systems design

Ready to run

npx skills add https://github.com/dnkrow/skill --skill create-architecture-dnkrow

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: create-architecture
Source: https://github.com/dnkrow/skill/tree/main/claude-global/create-architecture
Command: npx skills add https://github.com/dnkrow/skill --skill create-architecture-dnkrow

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you convert approved GDD content into a complete, engine-version-aware technical architecture blueprint, so you can start implementation with clear module ownership, data flow, and API contracts.

Core Features & Use Cases

Guided architecture authoring: Builds the master architecture document section by section, including layer mapping, ownership, and contracts.
Engine knowledge-gap verification: Reads the pinned engine reference to flag post-cutoff risks and validate decisions against the target engine version.
Traceability and decision readiness: Extracts a technical requirements baseline, audits existing ADRs, identifies gaps, and enumerates required new ADRs before writing the final architecture.

Quick Start

Use the create-architecture skill to produce docs/architecture/architecture.md by running it with focus on full coverage for the current project GDDs.

Frequently Asked Questions about create-architecture

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

FAQPage Schema

How do I generate a complete game architecture blueprint from approved GDD documentation?▼

To generate a game architecture blueprint, convert approved Game Design Documents into an engine-version-aware master document defining layer mapping, module ownership, data flow, and API boundaries before implementation begins.

What is the best way to map data flow and module ownership for game systems design?▼

Mapping data flow and module ownership requires extracting technical requirements from all GDDs and auditing existing Architecture Decision Records to build a traceable master architecture document with clear API boundary definitions.

Do I need to audit existing ADRs before defining API boundaries for my game project?▼

Yes, auditing existing ADRs is required before defining API boundaries to identify decision gaps, validate choices against the pinned engine reference, and enumerate required new ADRs for the final architecture.

How does engine compatibility factor into game architecture generation?▼

Engine compatibility is validated by reading pinned engine reference files to flag post-cutoff risks and ensure the master architecture blueprint aligns decisions with the target engine version.

Can I use this approach to plan end-to-end architecture for game projects across multiple GDDs?▼

Yes, this approach applies to end-to-end architecture planning by extracting a technical requirements baseline from all project GDDs to produce a comprehensive architecture markdown file with traceability.

Why does my game architecture plan lack traceability between technical requirements and module ownership?▼

Traceability gaps occur when architecture generation skips extracting the technical requirements baseline from GDDs and fails to audit existing ADRs before assigning module ownership and writing the final architecture document.