create-control-manifest

Generate a flat control manifest from ADRs and engine references.

14|1|Updated Apr 12, 2026
One-click install
npx skills add https://github.com/Euraika-Labs/Codex-Code-Game-Studios --skill create-control-manifest-euraika-labs
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: create-control-manifest
Source: https://github.com/Euraika-Labs/Codex-Code-Game-Studios/tree/main/.agents/skills/create-control-manifest
Command: npx skills add https://github.com/Euraika-Labs/Codex-Code-Game-Studios --skill create-control-manifest-euraika-labs

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Programmers often struggle to translate architectural decisions and engine constraints into concise, actionable guidelines, leading to inconsistencies and missed requirements. This Skill produces a flat control manifest that lists what to do and what never to do, extracted from accepted ADRs, technical preferences, and engine references.

Core Features & Use Cases

  • Extracts required patterns, forbidden approaches, performance guardrails, and API constraints from accepted ADRs and engine documentation.
  • Classifies each rule by architectural layer (Foundation, Core, Feature, Presentation) and adds global conventions.
  • Generates a markdown manifest at docs/architecture/control-manifest.md for quick reference.
  • Optionally runs a technical director review gate before committing the manifest.
  • Ideal after an architecture review passes, ensuring the development team has a single source of truth for implementation rules.

Quick Start

Invoke the create control manifest command after the architecture review passes to generate the control manifest.

Frequently Asked Questions about create-control-manifest

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

FAQPage Schema
How do I translate ADRs into actionable coding rules for developers?

Creating a control manifest translates ADRs into actionable coding rules by extracting required patterns, forbidden approaches, and performance guardrails into a flat markdown reference. It processes accepted ADRs and engine references to generate a single source of truth for implementation.

What is a control manifest in software architecture?

A control manifest is a flat, actionable document that consolidates architectural decisions into specific coding rules. It classifies requirements by architectural layer, such as Foundation or Presentation, and includes global naming conventions and deprecated API listings to ensure consistent implementation across the codebase.

How do I consolidate technical preferences and engine constraints into a single document?

Consolidating technical preferences and engine constraints involves processing accepted ADRs and engine reference documents to extract rules. The resulting control manifest groups these rules per architectural layer and adds performance budgets, enabling developers to reference a unified set of implementation standards.

When should I generate a control manifest after an architecture review?

Generating a control manifest is ideal immediately after an architecture review passes. This ensures the development team receives a single, accurate source of truth listing required patterns and forbidden approaches before implementation begins across the codebase.

Can I include performance budgets and deprecated API listings in an architectural manifest?

An architectural manifest can include performance budgets and deprecated API listings. It extracts performance guardrails and API constraints from accepted ADRs and engine documentation, combining them with layer classifications and naming conventions in the generated markdown file.

Does the control manifest organize rules by architectural layer?

The control manifest organizes rules by architectural layer, specifically classifying them into Foundation, Core, Feature, and Presentation tiers. This classification helps programmers quickly locate relevant constraints and required patterns for their specific development context.