create-control-manifest

Generate a flat rules sheet from ADRs and technical documentation.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill eliminates inconsistent code implementation caused by ADRs only explaining the reasoning behind architectural decisions, without providing clear, actionable "what to do" and "what never to do" guidance for development teams.

Core Features & Use Cases

  • Rule Extraction from ADRs: Automatically pulls required patterns, forbidden approaches, performance guardrails, and engine API constraints from all accepted ADRs, eliminating manual rule compilation.
  • Layer-Based Organization: Groups rules by architectural layer (Foundation, Core, Feature, Presentation) plus global cross-cutting rules for easy reference during implementation.
  • Source-Traceable Rules: Every rule is tagged with its source ADR or technical document, so programmers can quickly access the full context behind any requirement.
  • Use Case: After your team completes an architecture review and accepts all ADRs, use this Skill to generate a control manifest that serves as a single source of truth for all implementation rules, reducing misalignment and rework.

Quick Start

Use the create-control-manifest skill to generate an actionable programming rules manifest from your project's accepted ADRs and technical documentation after your architecture review is complete.

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 architectural decision records into actionable programming rules?

To translate architectural decision records into programming rules, you can generate a control manifest that extracts required patterns, forbidden approaches, and API constraints from accepted ADRs into clear implementation do's and don'ts.

What is the best way to enforce code standards from technical documentation across development teams?

The best way to enforce code standards from technical documentation is to consolidate accepted ADRs and engine references into a single source-traceable rules sheet, ensuring consistent code implementation across all architectural layers.

How do I organize implementation guidelines by architectural layer for developers?

You organize implementation guidelines by grouping extracted technical documentation rules into specific architectural layers such as Foundation, Core, Feature, and Presentation, alongside global cross-cutting rules for easy developer reference.

Can I trace specific code standards back to their original architectural decision records?

Yes, you can trace code standards back to their original architectural decision records because every generated programming rule is tagged with its source ADR or technical document, providing full context behind the requirement.

When do I need to generate a control manifest for my software architecture?

You need to generate a control manifest after your team completes an architecture review and accepts ADRs, serving as a versioned reference to detect stale implementation rules and enforce performance guardrails during development.

Why do my developers ignore our technical documentation during implementation?

Developers often ignore technical documentation because ADRs explain architectural reasoning without providing actionable guidance, which is solved by translating those decisions into a flat, explicit do's and don'ts rules sheet.