Skip to content
/
Tier A A11 Governance

AI Governor Framework (Fr-e-d)

ai-governor-framework · Fr-e-d/AI-Governor-Framework · ★ 78 · last commit 2026-03-11

Provides structured governance protocols and in-repo rules to transform AI assistants into disciplined engineering partners that respect project architecture and coding standards.

Best whenContext engineering beats prompt engineering — give AI the right knowledge at the right time via an in-repo knowledge base, not bigger prompts.
Skip ifDumping entire codebase into one context window, Over-engineering synthesized architectural principles
vs seeds
bmad-method(structured multi-phase workflow with explicit protocols and review gates) but uses in-repo rules + manually invoked pro…
Primitive shape 1 total
Commands 1
00

Summary

AI Governor Framework — Summary

The AI Governor Framework (by Fr-e-d) is an archived methodology-doc framework that teaches AI coding assistants project-specific context via an in-repo knowledge base of rules and dev-workflow protocols. It has been explicitly superseded by the same author's GAAI framework.

Problem it solved: AI coding assistants lack awareness of a project's architecture, conventions, and constraints — they generate inconsistent, non-compliant code unless given structured context. The framework provides two components: passive governance rules (auto-applied by the IDE) and active operator protocols (manually invoked step-by-step).

Distinctive trait: A 6-protocol "Operator's Playbook" covering the full feature lifecycle (Bootstrap → Define PRD → Generate Tasks → Process Tasks → Quality Audit → Implementation Retrospective), with a 7-layer quality audit protocol and a /review command with 7 mode variants (quick, security, architecture, design, ui, deep-security, comprehensive).

Target audience: Developers using Cursor, Claude Code, or other AI assistants who want a structured, auditable development workflow governed by project-specific rules.

Status: ARCHIVED (GitHub: archived=True). The README explicitly redirects to GAAI: "This project has been superseded by GAAI — Governed Agentic AI Infrastructure."

Differs from seeds: Most similar to BMAD-METHOD (structured multi-phase workflow with explicit protocols and review gates) but uses in-repo rules rather than persona-based agents. Unlike BMAD's skill-activation pattern, AI Governor Framework uses Cursor's .mdc rules and Claude Code commands. The dev-workflow protocols are manually invoked, not auto-triggered — closer to agent-os's "commands that write markdown" pattern than BMAD's auto-activating skills.

01

Overview

AI Governor Framework — Overview

Origin

Created by Frédéric Geens (Fr-e-d). Apache 2.0 license. Inspired by snarktank/ai-dev-tasks. The project is now archived; the author has moved development to GAAI (GAAI-framework), described as "the production-ready evolution."

Status

ARCHIVED — explicitly superseded. From README:

"⚠️ This project has been superseded by GAAI — Governed Agentic AI Infrastructure. GAAI is the production-ready evolution of this framework — dual-track agents, persistent memory, skill-based execution, and a full decision trail. Battle-tested on 176 stories, 177 decisions, 84,000 lines of TypeScript."

Philosophy

"Stop fighting your AI assistant. Start governing it."

"This isn't about bigger prompts or dumping your entire codebase into one... It's about giving the AI the right information at the right time."

"Treat your project's knowledge base like your codebase."

Core Principle: Context Engineering

The framework rejects "bigger prompts" and instead advocates for an in-repo knowledge base:

  • Auditable & Versioned: Every rule change tracked in git
  • Evolutive: AI context evolves with the code
  • Portable: Clone the repo → full AI context immediately available
  • Efficient: Zero network latency, no external dependencies

The "Governor" Mental Model

The AI is a governance partner, not a code monkey. The framework:

  1. Teaches the AI the project's DNA via rules
  2. Provides protocols to invoke for complex tasks
  3. Requires quality audits before marking work complete
  4. Tracks decisions through retrospectives

Attribution

From README:

"This framework is an enhanced and structured adaptation inspired by the foundational work on AI-driven development by snarktank/ai-dev-tasks."

02

Architecture

AI Governor Framework — Architecture

Distribution

  • Type: standalone-repo (clone into .ai-governor/)
  • License: Apache-2.0
  • Language: None (docs only)
  • Status: ARCHIVED

Install Methods

# Clone into project subdirectory
git clone https://github.com/Fr-e-d/AI-Governor-Framework.git .ai-governor

# For Cursor: copy rules + prompts
mkdir -p .cursor/rules && cp -r .ai-governor/rules/* .cursor/rules/
mkdir -p .cursor/prompts && cp -r .ai-governor/.cursor/prompts/* .cursor/prompts/

# For Claude Code: copy commands
mkdir -p .claude/commands && cp -r .ai-governor/.claude/commands/* .claude/commands/

Required Runtime

None — documentation only.

Directory Structure

AI-Governor-Framework/
├── CLAUDE.md                    # Claude Code guidance
├── OpenCode.md                  # OpenCode guidance
├── .claude/
│   └── commands/
│       └── review.md            # /review command
├── .cursor/                     # (from .gitignore — user creates)
│   └── prompts/                 # Cursor-specific prompts
├── rules/
│   ├── README.md
│   ├── common-rules/            # Cross-cutting rules
│   └── master-rules/            # Core governance rules
├── dev-workflow/
│   ├── README.md
│   ├── 0-bootstrap-your-project.md
│   ├── 1-create-prd.md
│   ├── 2-generate-tasks.md
│   ├── 3-process-tasks.md
│   ├── 4-quality-audit.md       # 7-layer audit orchestrator
│   ├── 5-implementation-retrospective.md
│   └── review-protocols/        # Specialized review protocol files
├── CHANGELOG.md
└── CONTRIBUTING.md

Target AI Tools

  • Claude Code (.claude/commands/)
  • Cursor (.cursor/rules/ + .cursor/prompts/)
  • OpenCode (OpenCode.md)
  • Other AI assistants (read CLAUDE.md or README directly)

No Hooks

No Claude Code hooks or automated triggers. All workflow is manually invoked via the dev-workflow protocols or the /review command.

03

Components

AI Governor Framework — Components

Commands (1)

Name Purpose
/review Quality audit orchestrator with 7 modes: quick (code review), security, architecture, design (design system compliance), ui (accessibility), deep-security (pre-production), comprehensive (run all). Routes to specialized protocol files.

Dev-Workflow Protocols (6 — manually invoked markdown files)

File Protocol Purpose
0-bootstrap-your-project.md PROTOCOL 0: Bootstrap Codebase analysis → Context Kit creation → READMEs + rules generation
1-create-prd.md PROTOCOL 1: Define Transform idea into detailed PRD
2-generate-tasks.md PROTOCOL 2: Plan Convert PRD into step-by-step technical plan
3-process-tasks.md PROTOCOL 3: Implement Execute the plan
4-quality-audit.md PROTOCOL 4: Quality Audit 7-layer quality review orchestrator
5-implementation-retrospective.md PROTOCOL 5: Retrospective Process retrospective to continuously improve the system

Review Protocols (7 modes under dev-workflow/review-protocols/)

Mode Focus
code-review Design compliance + code quality
security-check Security + module/component boundaries
architecture-review High-level design + performance architecture
design-system Design system compliance + component usage
ui-accessibility Accessibility + user experience validation
pre-production Complete security validation with testing
Comprehensive All above, sequentially

Rules (2 categories)

Category Purpose
rules/master-rules/ Core governance rules (always-apply: true for Cursor)
rules/common-rules/ Cross-cutting utility rules

No Hooks, No Skills, No MCP

Pure methodology document framework. No automation.

05

Prompts

AI Governor Framework — Prompts

Prompt 1: Bootstrap Protocol (dev-workflow/0-bootstrap-your-project.md)

Technique: Multi-step persona-instruction with mandatory [MUST] actions, user checkpoint gates, and explicit anti-over-engineering guidance.

# PROTOCOL 0: PROJECT BOOTSTRAP & CONTEXT ENGINEERING

## 1. AI ROLE AND MISSION

You are an **AI Codebase Analyst & Context Architect**. Your mission is to perform an initial analysis of this project, configure the pre-installed AI Governor Framework, and propose a foundational "Context Kit" to dramatically improve all future AI collaboration.

...

### STEP 4: Autonomous Deep Dive & Synthesis

1.  **`[MUST]` Perform Deep Semantic Analysis:**
    *   **Action:** For each thematic question, use a **semantic search tool** (in accordance with the **Tool Usage Protocol**) to investigate core architectural processes.

2.  **`[MUST]` Synthesize Findings into Principles:**
    *   **[GUIDELINE] Avoid Over-Engineering:** The synthesized principle should represent the simplest, most direct solution to the problem observed. Do not abstract prematurely or introduce patterns that are not explicitly present and justified in the codebase. Favor pragmatic, clear conventions over complex, theoretical ones.

### STEP 5: Collaborative Validation (The "Checkpoint")

1.  **`[MUST]` Present a Consolidated Report for Validation:**
    *   **Communication:**
        > "My analysis is complete. Here is what I've understood. Please validate, correct, or complete this summary.
        >
        > ### ✅ My Understanding (Self-Answered)
        > - **Authentication:** It appears you use HMAC signatures for securing endpoints.
        >
        > ### ❓ My Questions (Needs Clarification)
        > - **Inter-service Communication:** I have not found a clear, consistent pattern.
        >
        > I will await your feedback before building the Context Kit."
    *   **Halt and await user validation.**

Prompt 2: Quality Audit Orchestrator (dev-workflow/4-quality-audit.md)

Technique: Orchestrator persona with mode-routing table; references external specialized protocol files; emphasizes structured, consistent reporting.

# PROTOCOL 4: QUALITY AUDIT ORCHESTRATOR

## AI Persona
I am a **Senior Quality Engineer** acting as an **Audit Orchestrator**. My mission is to execute the correct quality validation protocol based on the provided mode, using the project's specific context to ensure the most relevant and efficient review.

## EXECUTION MODES (Via Unified `/review`)

### Mode: `quick` ("/review" → "Code Review")
```yaml
Focus: Design compliance + Code quality core
Protocol: Loads and executes instructions from `@review-protocols/code-review.md`

Mode: comprehensive ("/review" → "🚀 Run All")

Focus: Complete quality validation across all layers.
Protocol: This mode is special. It sequentially executes ALL the above protocols...
09

Uniqueness

AI Governor Framework — Uniqueness

Differs from Seeds

AI Governor Framework is closest to BMAD-METHOD (multi-phase workflow with explicit protocols, review gates, and persona-based quality review) but uses in-repo rules + manually invoked protocols rather than auto-activating skills. Unlike BMAD's 34-skill autonomous activation, every AI Governor protocol requires explicit user invocation. The /review command with 7 modes is more sophisticated than any single seed framework's review capability. Unlike agent-os (another in-repo rules framework), AI Governor Framework has an active Bootstrap protocol that generates the rules contextually rather than providing generic templates.

Status Note

This framework is ARCHIVED. Analysis is provided for completeness and historical context. Active users should use GAAI instead.

Key Differentiators (at time of active development)

  1. Bootstrap protocol: Actively generates project-specific rules from codebase analysis, rather than shipping generic templates.
  2. 7-mode /review command: More nuanced review modes than any seed framework.
  3. Collaborative validation checkpoint: The "✅ My Understanding / ❓ My Questions" pattern is a formalized human-in-the-loop review step.
  4. Multi-tool compatibility: Cursor rules (.mdc), Claude Code commands, OpenCode boot sequence — all from one repo.
  5. Predecessor/successor lineage: Directly traceable to GAAI — both by Fr-e-d.

Observable Failure Modes

  • No automation: Every workflow step is manual. Teams skip protocols under deadline pressure.
  • No memory: Generated context (READMEs/rules) goes stale as codebase evolves without explicit re-Bootstrap.
  • Rule format fragility: Master-rules need .mdc renaming and frontmatter for Cursor — easy to misconfigure.
  • No enforcement: Rules are passive guidance. The agent can ignore them.
  • ARCHIVED: No maintenance or security patches going forward.

Relationship to GAAI

GAAI adds everything AI Governor Framework lacked:

  • Persistent memory (decision logs, cross-session patterns)
  • Backlog-driven delivery (no manual protocol chaining required)
  • Skills execution (47 SKILL.md units)
  • Delivery daemon (autonomous background execution)
  • Multi-agent separation (Discovery vs Delivery)
04

Workflow

AI Governor Framework — Workflow

Operator's Playbook (Sequential Protocols)

PROTOCOL 0 — Bootstrap (one-time setup)
  → Detect tooling (Cursor? Claude Code?)
  → Map codebase structure
  → Generate thematic investigation questions
  → Autonomous deep dive (semantic code analysis)
  → Collaborative validation checkpoint with user
  → Generate documentation (READMEs)
  → Generate governance rules
  → Output: Context Kit (READMEs + rules)

PROTOCOL 1 — Define
  → Transform idea into detailed PRD
  → Approval gate: user validates PRD

PROTOCOL 2 — Plan
  → Convert PRD into technical task plan
  → Approval gate: user validates plan

PROTOCOL 3 — Implement & Review
  → Execute plan tasks
  → After each task → run PROTOCOL 4 (Quality Audit)

PROTOCOL 4 — Quality Audit (via /review)
  → Select mode: quick/security/architecture/design/ui/deep-security/comprehensive
  → Load appropriate protocol file
  → Execute 7-layer quality review
  → Consolidated report

PROTOCOL 5 — Retrospective
  → Review implementation process
  → Identify improvements
  → Update framework rules accordingly

Phase-to-Artifact Map

Phase Artifact
Bootstrap README.md files, governance rules
Define PRD document
Plan Technical task plan
Quality Audit Review report
Retrospective Updated rules/process notes

Approval Gates

Gate Trigger Type
Bootstrap validation After codebase analysis (Protocol 0, Step 5) freetext-clarify
PRD validation After Protocol 1 file-review
Task plan validation After Protocol 2 file-review
/review mode selection When invoking /review choice-list

Bootstrap Deep Dive Pattern

Protocol 0 uses a distinctive 5-step validation flow:

  1. Autonomous analysis
  2. Present: "✅ My Understanding (Self-Answered)" + "❓ My Questions (Needs Clarification)"
  3. Halt and await user validation
  4. Iterate until user confirms accuracy
  5. Only then generate the Context Kit

This reflects the framework's core principle: the AI's understanding must be explicitly validated before it generates governance artifacts.

06

Memory Context

AI Governor Framework — Memory & Context

State Storage

In-repo files (no external state):

Path Purpose
rules/ Governance rules (passive context for AI)
dev-workflow/ Protocol templates (active reference for AI)
Project READMEs Generated architectural context
.cursor/rules/ / .claude/commands/ IDE-specific rule/command copies

Persistence Model

  • Project-scoped: Rules and generated READMEs live in the repository
  • Version-controlled: Every rule change tracked in git (by design)
  • No cross-session memory: No structured memory system; context is in files

Context Injection

  • Cursor: Rules in .cursor/rules/ with alwaysApply: true for master-rules (auto-injected)
  • Claude Code: Commands in .claude/commands/; CLAUDE.md for baseline context
  • OpenCode: OpenCode.md boot sequence

The Bootstrap protocol generates project-specific READMEs that serve as architectural context injected passively into future AI sessions.

Compaction Handling

Not applicable — no Claude Code hooks.

Cross-Session Handoff

The generated READMEs and rules serve as persistent cross-session context. The architectural knowledge built during Bootstrap is available to every future session.

Relationship to GAAI

GAAI (the successor) adds what AI Governor lacks:

  • Persistent memory (decision logs, cross-session)
  • Structured backlog (cross-session state)
  • Skills execution system (47+ skills)
  • Delivery daemon (background autonomous execution)
07

Orchestration

AI Governor Framework — Orchestration

Multi-Agent

No — single AI session executing manually invoked protocols.

Orchestration Pattern

Sequential — the Operator's Playbook is a linear pipeline: Bootstrap → Define → Plan → Implement → Audit → Retrospective. Each step is manually triggered.

Execution Mode

Interactive-loop (user manually invokes each protocol in sequence).

Multi-Model

No.

Isolation Mechanism

None.

Consensus Mechanism

None. However, the Bootstrap protocol includes a distinctive human-validation checkpoint (human must confirm AI's understanding before rules are generated) — this is a human-in-the-loop consensus mechanism for the context-generation phase.

Prompt Chaining

Yes — the dev-workflow protocols are designed to chain: PRD → task list → implementation → quality audit → retrospective. Each protocol's output is input context for the next.

Crash Recovery

No explicit mechanism. Protocols are stateless — each can be re-run independently.

Note: Author Relationship

This framework and GAAI are both by the same author (Frédéric Geens / Fr-e-d). AI Governor Framework is the predecessor; GAAI is the successor. The README explicitly redirects users to GAAI.

08

Ui Cli Surface

AI Governor Framework — UI / CLI Surface

CLI Binary

None. Installation is manual file copying via bash commands in README.

Commands (1)

/review — Claude Code slash command with 7 interactive modes.

IDE Integration

  • Cursor: Rules in .cursor/rules/ (auto-applied); prompts in .cursor/prompts/
  • Claude Code: CLAUDE.md + .claude/commands/review.md
  • OpenCode: OpenCode.md

Observability

None — no logging, no audit trail, no telemetry.

Status

ARCHIVED. The GitHub repo is archived=True, meaning no new issues, PRs, or changes accepted. The framework is in maintenance-only mode while GAAI receives active development.

Related frameworks

same archetype · same primary tool · same memory type

OpenHarness ★ 13k
A11 Governance

Open-source Python agent runtime providing complete harness infrastructure: tools, memory, governance, swarm coordination, and…

Trae Agent ★ 12k
A11 Governance

Research-friendly open-source CLI coding agent by ByteDance, designed for academic ablation studies and modular LLM provider…

Sweep AI ★ 7.7k
A11 Governance

Autonomous GitHub bot that converts issues to pull requests using a sequential multi-agent pipeline.

Agent Governance Toolkit (microsoft) ★ 2.3k
A11 Governance

Enterprise-grade AI agent governance: YAML policy enforcement, 12-vector prompt injection defense, zero-trust identity,…

TDD Guard ★ 2.1k
A11 Governance

Mechanically enforces the Red-Green-Refactor TDD cycle by blocking file writes that violate TDD principles via a PreToolUse hook…

Agentic Coding Flywheel Setup (ACFS) ★ 1.5k
A11 Governance

Take a complete beginner from laptop to three AI coding agents running on a VPS in 30 minutes via an idempotent manifest-driven…