Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Repository Governance

    1

    Installs a strict, repo-agnostic rulebook for AI coding agents into any repository.

    $15

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    repository-governance

    repository-governance

    Example session with this skill installed

    Set up agent governance in ~/Code_Projects/invoice-cli — I want an AGENTS.md and rules that every coding agent follows. The license is MIT. Don't commit anything.

    • Read your context and instructions
    • Compiled the repository-governance

    Governance is installed in ~/Code_Projects/invoice-cli, the profile is filled from the repository, and the check passes. Nothing was committed and no existing file was overwritten.

    Install plan (dry run) and result

    Installed into /home/dill/Code_Projects/invoice-cli
      governance version 1.0.0
      created    .agent_tools/00_master_directives.md
      created    .agent_tools/01_style_guide.md
      created    .agent_tools/02_architecture.md
      created    .agent_tools/03_testing_rules.md
      created    .agent_tools/04_doc_updater.md
      created    .agent_tools/05_session_log.md
      created    .agent_tools/06_project_profile.md
      created    .agent_tools/07_project_memory.md
      created    AGENTS.md
      created    CHANGELOG.md
      created    CLAUDE.md
    

    Profile values read from the repository (pyproject.toml, .github/workflows/ci.yml, LICENSE)

    FieldValueSource
    LicenseMITLICENSE, pyproject.toml
    Lint / Formatruff check . / ruff format --check .CI workflow
    Type checkmypy src (strict)[tool.mypy], CI
    Testspytest[tool.pytest.ini_options], CI
    Buildnoneno build step in CI
    VersioningSemantic Versioningtag v0.3.1 matches version = "0.3.1"
    Session log / Changelogfile / filesingle-branch repo, default modes
    TreeREADME.md, heading "Repository Structure", depth:2added below the Usage section
    Agents may commitnoyour instruction

    Set from your answers or left for you: invariant "Ledger totals: ledger.total() sums the amount column as floats and never rounds"; layer boundary src/invoice_cli/ holds library and CLI code, no test code; decision records in docs/decisions/.

    Repository tree written to README.md

    .
    ├── .agent_tools/
    │   ├── 00_master_directives.md
    │   ├── 01_style_guide.md
    │   ├── 02_architecture.md
    │   ├── 03_testing_rules.md
    │   ├── 04_doc_updater.md
    │   ├── 05_session_log.md
    │   ├── 06_project_profile.md
    │   └── 07_project_memory.md
    ├── .github/
    │   └── workflows/  (1 file)
    ├── src/
    │   └── invoice_cli/  (4 files)
    ├── tests/
    │   └── test_ledger.py
    ├── .gitignore
    ├── AGENTS.md
    ├── CHANGELOG.md
    ├── CLAUDE.md
    ├── LICENSE
    ├── README.md
    └── pyproject.toml
    

    Governance check

    ok    all governance files present
    ok    no unfilled placeholders
    ok    profile fields valid
    ok    session log valid (1 entries, mode file)
    ok    changelog has an Unreleased section (CHANGELOG.md)
    ok    project memory within cap (22/100 lines)
    ok    tree current in README.md
    warn  decision records folder docs/decisions/ does not exist yet (created with the first record)
    result: ok
    

    Quality checks from the profile, run as the rules require

    CheckResult
    ruff check .passed
    ruff format --check .failed, pre-existing: tests/test_ledger.py would be reformatted
    mypy srcpassed, 4 source files
    pytestpassed, 1 test

    The format failure predates this task and was not touched; it is noted for you rather than masked.

    Session log entry appended

    - [2026-10-26] AGENTS.md, CLAUDE.md, CHANGELOG.md, .agent_tools/, README.md: installed repository-governance 1.0.0, filled profile from pyproject.toml and CI, added README tree
    

    Next steps

    1. Review .agent_tools/06_project_profile.md, especially the invariant and the layer boundary, which came from you rather than from files.
    2. Run ruff format tests/test_ledger.py if you want the format check green before the first governed commit.
    3. Commit when you are ready; git status shows the new files and the README change. Suggested message: docs: add agent governance (repository-governance 1.0.0).
    4. Optional: add check.py and tree.py --check to CI so the rules are enforced, not just documented.
    Repository tree written to README.md

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Most "agent rules" files are written once for one project and rot. This skill separates the two things that get mixed up in them: the rules, which are the same for every repository, and the facts, which are not.

    What gets installed

    • AGENTS.md — the entry point every agent reads first. It routes to the rule files, states the repository-mapping rule, caps how much history an agent may read, and requires one log entry per finished task.
    • CLAUDE.md — three @ imports so Claude Code loads AGENTS.md, the profile and the memory. Skipped with --no-claude-md.
    • .agent_tools/00–05 — master directives, style guide, architecture boundaries, testing rules (lint → format → type → tests → build, all mandatory where the repo has them), documentation updater, session log.
    • .agent_tools/06_project_profile.md — the only file with repo-specific values: languages, quality-check commands, layer boundaries, invariants, license, environment variables, and the modes below.
    • .agent_tools/07_project_memory.md — gotchas, decisions in force and non-obvious facts, hard-capped at 100 lines so it is read in full every session.
    • CHANGELOG.md — Keep a Changelog skeleton.

    Modes the profile chooses, so the layer scales from a weekend script to a monorepo

    FieldOptions
    Session logfile (one line per task), fragments (one file per task, no merge conflicts), git (the commit is the record), none
    Changelogfile (bullets under Unreleased) or fragments (changelog.d/, compiled at release)
    Treekept in README.md, in a dedicated file, or none (agents map with git ls-files)
    Decision recordsa folder of numbered ADR-style files, or none

    Bundled scripts (Python 3 standard library, no dependencies)

    • install.py <repo> [--dry-run] [--license ID] [--versioning TEXT] [--no-claude-md] — creates what is missing, appends a marked routing block to an existing AGENTS.md/CLAUDE.md, never overwrites, idempotent.
    • check.py <repo> — one line per check (files, placeholders, profile values, log and changelog shape, memory cap, tree freshness), exit 1 on failure. Drop it into CI or pre-commit.
    • tree.py <repo> [--check | --write] — deterministic repository tree at the detail level the profile sets; --check for CI.
    • release.py <repo> <version> [--dry-run] [--archive-log] — moves Unreleased and changelog fragments under a dated version heading; archives old log fragments monthly.

    How the agent uses it

    Confirm the target, read the LICENSE, preview with --dry-run, install, fill the profile from pyproject.toml / package.json / Cargo.toml / CI workflows, build the tree, run check.py until it prints result: ok, run the repo's own quality checks, write the first log line. The owner is asked only for what files cannot tell: invariants, layer boundaries, whether agents may commit.

    Built from a governance layer that ran a production FastAPI project for 300+ commits, then generalised so nothing project-specific remains in the rules.

    • A skill cannot enforce anything. The rules are text. Enforcement needs check.py and tree.py --check wired into CI or a pre-commit hook by the owner. The skill offers this; it does not configure it.
    • The installer refuses to merge into an existing .agent_tools/ setup. If a repo already routes AGENTS.md to .agent_tools/, the installer keeps that file untouched and prints the two routing lines to add by hand.
    • The profile is filled by an agent and must be reviewed. Commands are read from config files, but invariants and boundaries come from the owner's answers.
    • Existing long log entries are not rewritten. The 200-character cap is enforced only on the newest entry; older ones produce a warning, because the log is append-only by rule.
    • release.py deletes compiled changelog fragments by default (as towncrier does). Git keeps their history; --keep-fragments and --dry-run exist.
    • Agents without this skill follow rules 04 and 05 by hand. The process is written out in words, but a hand-built tree has to match tree.py's output exactly or the check fails.
    • Claude Code's native AGENTS.md reading is version-dependent, so a CLAUDE.md is created by default. Use --no-claude-md if you know your version reads AGENTS.md.
    • No automatic triggers. Nothing runs at session start unless the owner adds a hook; the memory file is loaded through CLAUDE.md imports instead.
    • Tested on one operating system and one Python version; see the compatibility note.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 21 days ago

    Requires

    Python 3.10+

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    File Scopes

    LICENSE*
    pyproject.toml
    setup.cfg
    package.json
    Cargo.toml
    go.mod
    Makefile
    justfile
    .pre-commit-config.yaml
    .github/workflows/*.yml
    .github/workflows/*.yaml
    README.md
    AGENTS.md
    CLAUDE.md
    CHANGELOG.md
    .agent_tools/0[0-7]_*.md
    docs/STRUCTURE.md
    changelog.d/*.md
    docs/decisions/????-*.md
    .agent_tools/log/????-??-??-*.md
    Listed21 days ago

    What's inside

    Frequently Asked Questions

    It creates a standardized layer of machine-readable files (like .agent_tools/ and routing docs) that ensure AI agents follow your specific architecture, build commands, and style rules without manual prompting.

    The skill is designed to be agent-agnostic; it installs routing files like CLAUDE.md and AGENTS.md that provide a 'source of truth' for any LLM or coding agent that scans your repository structure.

    The installer uses a non-destructive approach that appends to existing files using markers rather than overwriting them, ensuring your original configurations and documentation remain intact.

    You receive a suite of Python-based automation scripts for tree generation and governance checks, a template library for repository rules, and a structured profiling system to centralize your project's metadata.

    The skill includes a check.py validation script that audits your governance files for compliance and a tree.py script that automatically updates your repository's visual structure as files change.

    The only requirement is a Python 3 environment to run the automation and validation scripts; the governance files themselves are simple Markdown and JSON, making them compatible with any tech stack.

    No. Existing files are kept byte for byte. `AGENTS.md` and `CLAUDE.md` get a clearly marked block appended at the end; the tree is added to the tree file as a new section or replaces only an existing section with the same heading. The installer opens new files in exclusive-create mode so it cannot overwrite even by accident.

    Keep your tool and set the profile's changelog mode to `file` with your generated changelog as the changelog file. The rules then only ask agents to record notable changes the way your tool expects.

    Set those commands to `none`. Rules that depend on a `none` field do not apply, and the testing rule then requires the agent to say explicitly how the change was verified instead.

    The log records what happened, one line per task, append-only. The memory records what the next agent needs to know: gotchas, decisions in force, non-obvious facts. It is capped at 100 lines and edited in place, so it stays readable in full.

    Only if the profile says `Agents may commit: yes`. With `no`, every rule that would commit leaves the change for the owner instead. The `git` session-log mode requires `yes`, and the check script enforces that.

    Yes, with the `fragments` modes to avoid merge conflicts and a `depth:N` or `none` tree. For per-package guidance, add a small `AGENTS.md` in each package folder; Claude Code and Codex load it when working there. The skill documents this but does not generate it.

    `check.py` warns when the profile's installed version differs from the skill's. Compare your `.agent_tools/` with the skill's `assets/.agent_tools/` and apply what you want; the installer will never replace your files for you.

    Any agent that reads the Agent Skills format and can run Python. It has been run with Claude Code. The files it installs are plain Markdown that any AGENTS.md-aware tool reads.

    New in Agents & Orchestration