New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Control Manifest Creator

by Donchitos in Donchitos/Claude-Code-Game-Studios

Builds a flat must-do and never-do rules sheet per layer from Accepted architecture decision records and writes it to docs/architecture/control-manifest.md.

MITAuto-check passedDevelopment

Install Control Manifest Creator

skills CLI
$ npx skills add Donchitos/Claude-Code-Game-Studios --skill create-control-manifest -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install Donchitos/Claude-Code-Game-Studios create-control-manifest --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/Donchitos/Claude-Code-Game-Studios.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/create-control-manifest .claude/skills/create-control-manifest && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
create-control-manifest
GitHub stars
26k
Token cost
~3.9k tokens
SKILL.md length
1,395 words
Files
1
Skills in repo
73
Repo updated
First seen
Licence
MIT

At a glance

Builds a flat must-do and never-do rules sheet per layer from Accepted architecture decision records and writes it to docs/architecture/control-manifest.md.

  • Works in 6 steps: Load All Inputs → Extract Rules from Each ADR → Add Global Rules → …
  • Turning Accepted ADRs into rules programmers can follow day to day
  • SKILL.md covers 1. Load All Inputs, 2. Extract Rules from Each ADR, 3. Add Global Rules and 4. Present Rules Summary…, plus 4 more sections
  • Calls bash

What it does

The control manifest is a rules sheet for programmers that answers what to do and what never to do, grouped by architectural layer. It draws on all Accepted ADRs, technical preferences and engine reference docs. Where ADRs explain why, the manifest states what. The output goes to docs/architecture/control-manifest.md; it is meant to run after /architecture-review passes and to be re-run whenever ADRs are accepted or revised.

The skill counts the ADR files first, then greps each file's Status section before reading any of them. If some are Accepted, it proceeds with that set and names every ADR left out in the preview you approve. If none are Accepted, it asks whether to use Proposed ones or stop, and never emits a silent empty manifest. If the ADRs lack a Status section, it stops and points you to /architecture-decision retrofit. It also reads naming and performance settings from project.yaml, records the ADR number and title behind every rule, and follows the project's automation modes (collaborative, guided or autonomous) when it asks questions.

When your agent uses it

  • Turning Accepted ADRs into rules programmers can follow day to day
  • Refreshing the rules sheet after new ADRs are accepted or revised
  • Preparing implementation guidance once an architecture review passes

Example prompts

  • “Create the control manifest from our Accepted ADRs.”
  • “We accepted two new ADRs today. Regenerate docs/architecture/control-manifest.md.”
  • “Build a must-do and never-do sheet per layer for the engine team.”

Requirements

  • ADR files at docs/architecture/adr-*.md, each with a Status section
  • Pre-approved tools (allowed-tools): Read, Glob, Grep, Write, Agent, AskUserQuestion, Bash(bash "*/.claude/skills/create-control-manifest/../../hooks/yaml-helper.sh" resolve_config *)

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. Load All Inputs
  2. Extract Rules from Each ADR
  3. Add Global Rules
  4. Present Rules Summary Before Writing
  5. Write the Control Manifest
  6. Suggest Next Steps

What it can do on your machine

Read from SKILL.md and the folder at commit be8993b. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Glob
    • Grep
    • Write
    • Agent
    • AskUserQuestion
    • Bash(bash "*/.claude/skills/create-control-manifest/../../hooks/yaml-helper.sh" resolve_config *)

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • bash

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Control Manifest Creator loads about 3.9k tokens when it runs. Until then it costs about 37 tokens; SKILL.md has 1,395 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~37
When it runs · the whole SKILL.md, loaded when a task matches
~3.9k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from Donchitos/Claude-Code-Game-Studios at commit be8993b, republished under its MIT licence (© Donchitos). 1,395 words, ~3,880 tokens.

Download SKILL.mdSave it as .claude/skills/create-control-manifest/SKILL.md (or your agent's skills folder).
name
create-control-manifest
description
Flat must-do/never-do rules sheet per system and layer, extracted from Accepted ADRs. ADRs explain why; this is actionable.
allowed-tools
Read, Glob, Grep, Write, Agent, AskUserQuestion, Bash(bash "*/.claude/skills/create-control-manifest/../../hooks/yaml-helper.sh" resolve_config *)
argument-hint
[update — regenerate from current ADRs] [--review full|lean|solo]
user-invocable
true
model
sonnet

!bash "${CLAUDE_SKILL_DIR}/../../hooks/yaml-helper.sh" resolve_config --keys review_mode,automation

Resolved above — use as-is; --review overrides review_mode for this run. No block → defaults in .claude/docs/config-resolution.md.

Create Control Manifest

The Control Manifest is a flat, actionable rules sheet for programmers. It answers "what do I do?" and "what must I never do?" — organized by architectural layer, extracted from all Accepted ADRs, technical preferences, and engine reference docs. Where ADRs explain why, the manifest tells you what.

Output: docs/architecture/control-manifest.md

When to run: After /architecture-review passes and ADRs are in Accepted status. Re-run whenever new ADRs are accepted or existing ADRs are revised.

Every AskUserQuestion call follows .claude/docs/automation-modes.md (collaborative asks always · guided major-only · autonomous logs and proceeds; automation_always_ask categories always prompt).

1. Load All Inputs

ADRs

Establish the denominator first. Glob docs/architecture/adr-*.md. Call the count N. If N is 0: "No ADRs found — run /architecture-decision before building a control manifest." Stop.

Resolve status without reading the ADRs — the filter must precede the read, not follow it:

Grep pattern="^## Status" glob="docs/architecture/adr-*.md" output_mode="content" -A 3

Interpret against N:

ResultMeaningAction
N matches, some read AcceptedNormal.The Accepted set is A; proceed with A. Name every ADR left out, with its status, in the Phase 4 preview — the user approves a manifest knowing what it does not cover.
N matches, none AcceptedGenuinely no Accepted ADRs."[N] ADRs found, none Accepted. A manifest built from Proposed ADRs would encode decisions that may still change." Ask whether to proceed with Proposed or stop. Do not silently emit an empty manifest.
0 matches, N > 0Malformed ADRs — not an empty Accepted set. ## Status is BLOCKING-if-missing."[N] ADRs found, none has a ## Status section — acceptance cannot be determined. Run /architecture-decision retrofit [file] on each." Stop. Do not treat all ADRs as Accepted; do not emit a manifest.
  • Note the ADR number and title for every rule sourced.
Project Config
  • Read naming.* and performance.* from project.yaml; for any key absent or empty, fall back to .claude/docs/technical-preferences.md
  • Read approved libraries/addons and forbidden patterns from .claude/docs/technical-preferences.md (not migrated to project.yaml)
Engine Reference
  • Read docs/engine-reference/[engine]/VERSION.md for engine + version
  • Read docs/engine-reference/[engine]/deprecated-apis.md — these become forbidden API entries
  • Read docs/engine-reference/[engine]/current-best-practices.md if it exists
Existing Artifacts
  • Glob docs/architecture/control-manifest.md (present → this run is a regeneration; Read it before the Phase 5 write, which overwrites it) and production/epics/*/EPIC.md (present → epics exist). Phase 6 picks its next step from both.

Report: "Loaded [N] Accepted ADRs, engine: [name + version]."

2. Extract Rules from Each ADR

Read only these four sections per Accepted ADR — not the whole file. Context, Consequences, Migration Plan and Validation Criteria explain why a decision was made; the manifest records what to do, so they are not needed here:

Grep pattern="^## (Decision|Alternatives Considered|Performance Implications|Engine Compatibility)" glob="docs/architecture/adr-*.md" output_mode="content" -A 30

Filter the results to the Accepted set A resolved above. If a section is absent for a given ADR, note it per ADR and continue; if a section is absent across all of A, report "No Accepted ADR contains a [section] section — the manifest's [category] rules will be empty. Verify this is intended." Escalate to a full read of one ADR only when its scanned sections cross-reference material outside them (e.g. a Decision that says "subject to the constraints in Context").

For each Accepted ADR, extract:

Required Patterns (from the ## Decision section)
  • Every "must", "should", "required to", "always" statement in the Decision body — including any ### Implementation Guidelines sub-heading when the ADR has one (newer ADRs emit it; older ones state mandates directly in ## Decision). Never scan for ### Implementation Guidelines alone — it is absent from many skill-authored ADRs, and scanning for it yields an empty Required Patterns section on a manifest that should have been full.
  • Every specific pattern or approach mandated
Forbidden Approaches (from "Alternatives Considered" sections)
  • Every alternative that was explicitly rejected — why it was rejected becomes the rule ("never use X because Y")
  • Any anti-patterns explicitly called out
Performance Guardrails (from "Performance Implications" section)
  • Budget constraints: "max N ms per frame for this system"
  • Memory limits: "this system must not exceed N MB"
Engine API Constraints (from "Engine Compatibility" section)
  • Post-cutoff APIs that require verification
  • Verified behaviours that differ from default LLM assumptions
  • API fields or methods that behave differently in the pinned engine version
Layer Classification

Classify each rule by the architectural layer of the system it governs:

  • Foundation: Scene management, event architecture, save/load, engine init
  • Core: Core gameplay loops, main player systems, physics/collision
  • Feature: Secondary systems, secondary mechanics, AI
  • Presentation: Rendering, audio, UI, VFX, shaders

If an ADR spans multiple layers, duplicate the rule into each relevant layer.

3. Add Global Rules

Combine rules that apply to all layers. Each carries its source into the manifest, as a layer rule does — the project.yaml key, technical-preferences.md, or the engine-reference file:

From project config (project.yaml, else technical-preferences.md):
  • Naming conventions — naming.*: classes, variables, signals/events, files, constants
  • Performance budgets — performance.*: target framerate, frame budget, draw call limits, memory ceiling
Show full SKILL.md (605 more words)Show less
From deprecated-apis.md:
  • Deprecated APIs → Forbidden API entries, filtered for relevance to this project. Do not copy the deprecation table wholesale.

    Each entry must apply to what this project actually builds. deprecated-apis.md mixes dimensions and subsystems: its GodotPhysics3D → Jolt Physics 3D row is 3D-only, so emitting it unqualified gives a 2D project a global rule about a physics engine it never uses. If you cannot tell whether an entry applies — 2D vs 3D, a module the project does not include — either scope the rule ("when using 3D physics: ...") or omit it and note it as unresolved. A manifest of rules that do not apply is one nobody reads, and /create-stories consumes this file.

From current-best-practices.md (if available):
  • Engine-recommended patterns → Required entries
From technical-preferences.md forbidden patterns:
  • Copy any "Forbidden Patterns" entries directly

4. Present Rules Summary Before Writing

Before writing the manifest, present a summary to the user:

## Control Manifest Preview
Engine: [name + version]
ADRs covered: [list ADR numbers]
ADRs excluded: [ADR-NNNN ([status]), … — every ADR not in the Accepted set, or "None"]
Total rules extracted:
  - Foundation layer: [N] required, [M] forbidden, [P] guardrails
  - Core layer: [N] required, [M] forbidden, [P] guardrails
  - Feature layer: ...
  - Presentation layer: ...
  - Global: [N] naming conventions, [M] forbidden APIs, [P] approved libraries

Use AskUserQuestion:

  • Prompt: "Does this rule summary look complete?"
  • Options:
    • [A] Yes — looks good, run the director review and write the manifest
    • [B] Add rules — I have additional rules to include before writing
    • [C] Remove rules — some extracted rules should be dropped
    • [D] Stop here — I need to review the ADRs first

4b. Director Gate — Technical Review

Review mode check — apply before spawning TD-MANIFEST:

  • solo → skip. Note: "TD-MANIFEST skipped — Solo mode." Proceed to Phase 5.
  • lean → skip. Note: "TD-MANIFEST skipped — Lean mode." Proceed to Phase 5.
  • full → spawn as normal.

Spawn technical-director via Agent using gate TD-MANIFEST (.claude/docs/director-gates/td-manifest.md).

Pass: the Control Manifest Preview from Phase 4 (rule counts per layer, full extracted rule list), the list of ADRs covered, engine version, and any rules sourced from technical-preferences.md or engine reference docs.

The technical-director reviews whether:

  • All mandatory ADR patterns are captured and accurately stated
  • Forbidden approaches are complete and correctly attributed
  • No rules were added that lack a source ADR or preference document
  • Performance guardrails are consistent with the ADR constraints

Apply the verdict:

  • APPROVE → proceed to Phase 5
  • CONCERNS → surface via AskUserQuestion with options: Revise flagged rules / Accept and proceed / Discuss further
  • REJECT → do not write the manifest; fix the flagged rules and re-present the summary
  • NOT ASSESSED [missing input] → not an approval (.claude/docs/director-gates.md): name what was missing, then supply it and re-run the gate — or, if the user chooses to go on without it, continue to Phase 5 and state TD-MANIFEST: NOT ASSESSED — [input] in the output and the final Verdict line

5. Write the Control Manifest

Use AskUserQuestion:

  • Prompt: "May I write the Control Manifest?"
  • Options:
    • [A] Yes — write to docs/architecture/control-manifest.md
    • [B] Show me the full draft first, then ask again
    • [C] Not yet — I want to make more changes

Format:

markdown
# Control Manifest

> **Engine**: [name + version]
> **Last Updated**: [date]
> **Manifest Version**: [date]
> **ADRs Covered**: [ADR-NNNN, ADR-MMMM, ...]
> **Status**: [Active — regenerate with `/create-control-manifest update` when ADRs change]

`Manifest Version` is the date this manifest was generated. Story files embed
this date when created. `/story-readiness` compares a story's embedded version
to this field to detect stories written against stale rules. Always matches
`Last Updated` — they are the same date, serving different consumers.

This manifest is a programmer's quick-reference extracted from all Accepted ADRs,
technical preferences, and engine reference docs. For the reasoning behind each
rule, see the referenced ADR.

---

## Foundation Layer Rules

*Applies to: scene management, event architecture, save/load, engine initialisation*

### Required Patterns
- **[rule]** — source: [ADR-NNNN]
- **[rule]** — source: [ADR-NNNN]

### Forbidden Approaches
- **Never [anti-pattern]** — [brief reason] — source: [ADR-NNNN]

### Performance Guardrails
- **[system]**: max [N]ms/frame — source: [ADR-NNNN]

---

## Core Layer Rules

*Applies to: core gameplay loop, main player systems, physics, collision*

### Required Patterns
...

### Forbidden Approaches
...

### Performance Guardrails
...

---

## Feature Layer Rules

*Applies to: secondary mechanics, AI systems, secondary features*

### Required Patterns
...

### Forbidden Approaches
...

---

## Presentation Layer Rules

*Applies to: rendering, audio, UI, VFX, shaders, animations*

### Required Patterns
...

### Forbidden Approaches
...

---

## Global Rules (All Layers)

### Naming Conventions
| Element | Convention | Example | Source |
|---------|-----------|---------|--------|
| Classes | [from naming.* in project.yaml, else technical-preferences.md] | [example] | [`naming.classes` in project.yaml, or technical-preferences.md] |
| Variables | [from naming.* in project.yaml, else technical-preferences.md] | [example] | [`naming.variables` in project.yaml, or technical-preferences.md] |
| Signals/Events | [from naming.* in project.yaml, else technical-preferences.md] | [example] | [`naming.signals` in project.yaml, or technical-preferences.md] |
| Files | [from naming.* in project.yaml, else technical-preferences.md] | [example] | [`naming.files` in project.yaml, or technical-preferences.md] |
| Constants | [from naming.* in project.yaml, else technical-preferences.md] | [example] | [`naming.constants` in project.yaml, or technical-preferences.md] |

### Performance Budgets
| Target | Value | Source |
|--------|-------|--------|
| Framerate | [from performance.* in project.yaml, else technical-preferences.md] | [`performance.target_framerate` in project.yaml, or technical-preferences.md] |
| Frame budget | [from performance.* in project.yaml, else technical-preferences.md] | [`performance.frame_budget_ms` in project.yaml, or technical-preferences.md] |
| Draw calls | [from performance.* in project.yaml, else technical-preferences.md] | [`performance.draw_call_limit` in project.yaml, or technical-preferences.md] |
| Memory ceiling | [from performance.* in project.yaml, else technical-preferences.md] | [`performance.memory_ceiling_mb` in project.yaml, or technical-preferences.md] |

### Approved Libraries / Addons
- [library] — approved for [purpose] — source: technical-preferences.md

### Forbidden APIs ([engine version])
These APIs are deprecated or unverified for [engine + version]:
- `[api name]` — deprecated since [version] / unverified post-cutoff
- Source: `docs/engine-reference/[engine]/deprecated-apis.md`

### Cross-Cutting Constraints
- [constraint that applies everywhere, regardless of layer] — source: [ADR-NNNN, preference key or engine-reference file]

6. Suggest Next Steps

After writing the manifest:

  • If epics/stories don't exist yet: "Run /create-epics layer: foundation then /create-stories [epic-slug] — programmers can now use this manifest when writing story implementation notes."
  • If this is a regeneration (manifest already existed): "Updated. Recommend notifying the team of changed rules — especially any new Forbidden entries."

Collaborative Protocol

Applies in collaborative mode (the default). For guided and autonomous modes, see .claude/docs/automation-modes.md — the rules below describe what collaborative mode requires, not universal behavior.

  1. Load silently — read all inputs before presenting anything
  2. Show the summary first — let the user see the scope before writing
  3. Ask before writing — always confirm before creating or overwriting the manifest. On write: Verdict: COMPLETE — control manifest written. On decline: Verdict: BLOCKED — user declined write.
  4. Source every rule — never add a rule that doesn't trace to an ADR, a technical preference, or an engine reference doc
  5. No interpretation — extract rules as stated in ADRs; do not paraphrase in ways that change meaning

© Donchitos, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .claude/skills/create-control-manifest of Donchitos/Claude-Code-Game-Studios.

Open the folder on GitHubat commit be8993b

Compare with similar skills

Control Manifest Creator next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Control Manifest Creator compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Control Manifest Creator this skillDonchitos/Claude-Code-Game-Studios26k—~3.9kAutomated safety check: PassMIT
Architecture Docs Writerprisma/orm48k—~1.6kAutomated safety check: PassApache-2.0
Dark Architecture Diagram BuilderCocoon-AI/architecture-diagram-generator7.4k1 repos~2.1kAutomated safety check: PassMIT
Deepwiki Rssopaco/deepwiki-rs3.1k—~748Automated safety check: PassMIT
Mermaid Diagramsjjmartres/opencode1336 repos~1.9kAutomated safety check: PassMIT
Create Vibe Featuremistralai/mistral-vibe5.1k—~1.2kAutomated safety check: PassApache-2.0

Similar skills

  • Architecture Docs Writer

    prisma/orm

    Official

    Guides writing and rewriting architecture subsystem docs, ADRs and reference pages so they make sense to a developer with no prior project context.

    48k GitHub stars~1.6k tokensUpdated today
    DevelopmentAuto-check passed

  • Dark Architecture Diagram Builder

    Cocoon-AI/architecture-diagram-generator

    Creates dark-themed system, cloud, security and network architecture diagrams as self-contained HTML files with inline SVG and CSS.

    7.4k GitHub starsUsed in 1 repo~2.1k tokens
    DevelopmentAuto-check passed

  • Deepwiki Rs

    sopaco/deepwiki-rs

    AI-powered Rust documentation generation engine for comprehensive codebase analysis, C4 architecture diagrams, and automated technical documentation.

    3.1k GitHub stars~748 tokensUpdated 25 days ago
    DevelopmentAuto-check passed

  • Mermaid Diagrams

    jjmartres/opencode

    Helps an agent pick the right Mermaid diagram type and write the syntax for class, sequence, flow, ER, C4, state and other software diagrams.

    133 GitHub starsUsed in 6 repos~1.9k tokens
    DevelopmentAuto-check passed

  • Create Vibe Feature

    mistralai/mistral-vibe

    Official

    Guides feature work in the Mistral Vibe Python CLI so each change lands in the right module and matches the project's architecture decision records.

    5.1k GitHub stars~1.2k tokensUpdated 2 days ago
    DevelopmentAuto-check passed

  • Docs

    brickbots/PiFinder

    Author and edit PiFinder's user-facing documentation in the project's house style.

    250 GitHub stars~6.2k tokensUpdated 2 days ago
    DevelopmentAuto-check passed

More from Donchitos/Claude-Code-Game-Studios

All 73 skills in this repo

  • Architecture Decision

    Donchitos/Claude-Code-Game-Studios

    Create an ADR documenting a technical decision: context, alternatives considered, consequences.

    26k GitHub stars~1.7k tokensUpdated yesterday
    Auto-check passed

  • Dev Story

    Donchitos/Claude-Code-Game-Studios

    Implement a story: ADR guidelines, right programmer agent, code plus test.

    26k GitHub stars~2.4k tokensUpdated yesterday
    Auto-check: notes

  • Game Asset Audit

    Donchitos/Claude-Code-Game-Studios

    Audits game assets against naming conventions, file size budgets and format standards, and finds orphaned assets and missing references.

    26k GitHub stars~2k tokensUpdated yesterday
    Auto-check passed

  • Game Asset Spec Writer

    Donchitos/Claude-Code-Game-Studios

    Writes per-asset visual specs and AI image-generation prompts for a game's characters, enemies and screens, driven by the GDD, art bible and an entity inventory.

    26k GitHub stars~5k tokensUpdated yesterday
    Auto-check passed

  • Game Balance Check

    Donchitos/Claude-Code-Game-Studios

    Checks game data and formulas for balance outliers, broken progression, degenerate strategies and economy problems, and answers 'could not run' when the data is missing.

    26k GitHub stars~2.2k tokensUpdated yesterday
    Auto-check passed

  • Structured Bug Reports

    Donchitos/Claude-Code-Game-Studios

    Turns a description into a structured bug report, or scans code for likely bugs, then verifies and closes reports through four modes.

    26k GitHub stars~2.5k tokensUpdated yesterday
    Auto-check: notes

Categories

Questions about Control Manifest Creator

What does Control Manifest Creator do?

Builds a flat must-do and never-do rules sheet per layer from Accepted architecture decision records and writes it to docs/architecture/control-manifest.md. The control manifest is a rules sheet for programmers that answers what to do and what never to do, grouped by architectural layer. It draws on all Accepted ADRs, technical preferences and engine reference docs.

When should I use Control Manifest Creator?

Control Manifest Creator fits situations like: turning Accepted ADRs into rules programmers can follow day to day; refreshing the rules sheet after new ADRs are accepted or revised; preparing implementation guidance once an architecture review passes.

How do I install Control Manifest Creator in Claude Code?

Run `npx skills add Donchitos/Claude-Code-Game-Studios --skill create-control-manifest -a claude-code`. Or copy the skill folder (.claude/skills/create-control-manifest in Donchitos/Claude-Code-Game-Studios) into .claude/skills/create-control-manifest in your project. Claude Code loads it when a task matches its description.

How do I install Control Manifest Creator in Codex?

Run `npx skills add Donchitos/Claude-Code-Game-Studios --skill create-control-manifest -a codex`. Or copy the skill folder (.claude/skills/create-control-manifest in Donchitos/Claude-Code-Game-Studios) into .agents/skills/create-control-manifest in your project. Codex loads it when a task matches its description.

Can I use Control Manifest Creator in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add Donchitos/Claude-Code-Game-Studios --skill create-control-manifest -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/create-control-manifest, .gemini/skills/create-control-manifest, .github/skills/create-control-manifest and .opencode/skills/create-control-manifest in your project.

What does Control Manifest Creator need to run?

Going by SKILL.md and its folder, Control Manifest Creator needs the command-line tools its instructions call (bash). Our summary lists: ADR files at docs/architecture/adr-*.md, each with a Status section. Its frontmatter pre-approves these tools: Read, Glob, Grep, Write, Agent, AskUserQuestion, Bash(bash "*/.claude/skills/create-control-manifest/../../hooks/yaml-helper.sh" resolve_config *).

Does Control Manifest Creator access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Control Manifest Creator safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Control Manifest Creator use?

Control Manifest Creator is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Control Manifest Creator use?

About 3.9k tokens (SKILL.md is roughly 16k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Control Manifest Creator?

Skills that share tags, products or a category with Control Manifest Creator: Architecture Docs Writer (prisma/orm, 48k stars), Dark Architecture Diagram Builder (Cocoon-AI/architecture-diagram-generator, 7.4k stars), Deepwiki Rs (sopaco/deepwiki-rs, 3.1k stars) and Mermaid Diagrams (jjmartres/opencode, 133 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Control Manifest Creator?

Donchitos (a GitHub user) maintains it in Donchitos/Claude-Code-Game-Studios, which has 25,951 GitHub stars. The repository holds 73 skills in this directory. The repository was last updated on October 8, 2026.

Source: Donchitos/Claude-Code-Game-Studios on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.