Skip to content

Repository files navigation

title Agent Constitution 📜
description Universal validated context architecture for AI Agents (VS Code, Antigravity, Claude)
location README.md
last_updated 2026-06-23
Agent Constitution logo

Agent Constitution 📜

License: MIT Status: Active Skills: 368 Agents: 63 Commands: 79 Docs: Technical LinkedIn

The Validated Context Architecture for AI Agents.
368 skills · 63 agents · 79 commands · Works with Claude Code, Cursor, Codex, Gemini CLI

bash <(curl -fsSL https://raw.githubusercontent.com/su6i/agent-constitution/main/install.sh)

🇮🇷 نسخه فارسیContributingChangelog


Demo

Demo

Regenerate: vhs assets/demo.tape


📍 Primary Document

The main technical document of this repository is AGENTIC-CODING-SETUP.md.

If you want the core benchmark analysis, cost model, routing strategy, setup patterns, and low-cost agentic coding methodology, start there first. The rest of the repository either:

  • introduces that document,
  • operationalizes it,
  • localizes it,
  • or extends it with reusable rules, workflows, and templates.

For the repository map, see docs/INFORMATION-ARCHITECTURE.md.


🏗 The Problem

Most AI Agents (Cursor, AntiGravity, Windsurf, Copilot) fail because their "memory" is unstructured. You give them a 50-page prompt, they hallucinate. You give them nothing, they write spaghetti code. We needed a middle ground: A strict, modular "Constitution" that forces Agents to behave like Senior Engineers.

⚡ The Solution: Context Architecture

This repository is not just "rules". It is a Modular Context Architecture. It breaks down the software lifecycle into 5 atomic, linked workflows. The Agent loads only what it needs, when it needs it.

In practice, the repository now has a clear center of gravity:

  • AGENTIC-CODING-SETUP.md is the flagship guide and canonical technical reference.
  • README.md is the onboarding and navigation layer.
  • AGENTS.md is the execution contract and the canonical entry point for every agent harness.
  • GEMINI.md, GROK.md, QWEN.md, MINIMAX.md, .cursorrules, .windsurfrules, .clinerules, and .github/copilot-instructions.md are thin bootloaders: whichever config file a tool reads natively, it lands there and is routed to AGENTS.mdrules/. No rules are duplicated in them (rule 045).
  • .agent/, templates/, bin/, and docs/ are the implementation and support layers around that core guidance.

Short-Form Digest

Every bootloader tells the agent to read rules/DIGEST.md first — it is the auto-generated digest of every non-negotiable section in rules/*.md (markers wrap the full original text, not a compressed summary). Generated by bin/generate-digest.sh from HTML-comment markers (<!-- digest:start --> … <!-- digest:end -->); CI runs bin/generate-digest.sh --check on every push/PR and fails if the digest drifts from the source rules (see rules/045 §Digest Mechanism).

Reading the digest is attested with bin/ack-rules.sh: it prints the digest to stdout (so it enters the agent's context) and writes a gitignored .rules-ack holding the digest hash. Where templates/hooks/pre-commit is installed, Rule 7 blocks a commit whose .rules-ack is missing or stale. It is hash-based only — a new branch needs no fresh ack — it skips merge commits, and it is a silent no-op in any repo that has not installed bin/ack-rules.sh.

The same hook's Rule 8 blocks a newly added or renamed path whose name contains a non-ASCII byte (rules/000 §Language Policy). Only new paths are checked, so it never fires on files that predate the rule, and the file's content language is a separate question.

Core Features

  • ⚖️ The Neural Gavel: A strict .cursorrules router that prevents the Agent from guessing.
  • 🧠 Modular Memory: Workflows for Init, Docs, AI, and QA are split to prevent "Lost-in-the-Middle" errors.
  • 🛡️ Truth Protocol: Agents are forbidden from marking tasks "Done" without ls -R verification.
  • 🤖 Anti-Hallucination: Strict file collision and deletion safety protocols.

🚀 Quick Start

Read Order

  1. Read AGENTIC-CODING-SETUP.md for the core methodology.
  2. Read AGENTS.md for execution constraints and agent behavior.
  3. Use the workflow, template, and skill files as modular extensions of the core guide.

Option A: Automated Scaffolding (Recommended)

  1. Install the Scaffolder:

    # Add this alias to your shell config (~/.zshrc)
    alias init-gh='~/path/to/agent-constitution/bin/scaffold.sh'
  2. Run in any new project:

    mkdir my-new-project && cd my-new-project
    init-gh

    Result: The rules/, workflows/, and .agent/prompts/ are injected and committed automatically.

Option B: Manual Setup

  1. Clone this repo.
  2. Copy rules/, workflows/, and .agent/prompts/ to your project root.
  3. Ask your Agent:

    "Audit my codebase against the Quality Assurance protocol."

⚙️ Personalization

Before using this constitution in your own project, replace the author email with your own:

File Lines What to change
rules/040-git.md 51, 52, 53, 81 Replace <your-git-email> with your own email

Why: The Commit Identity rule enforces a specific author email on every commit. The value shipped in this repo is the original author's address — it must be yours before you start using the rules.

# Quick replace (run from the repo root):
sed -i '' 's/<your-git-email>/your@email.com/g' rules/040-git.md

Then set your global git identity to match:

git config --global user.email "your@email.com"
git config --global user.name  "Your Name"

🪝 Git Hooks (automatic enforcement)

Three hooks turn the non-negotiable git rules (rules/040-git.md) into deterministic gates that no agent or human can "forget". Their canonical sources live in templates/hooks/ — installing them needs nothing but a copy into your repo's .git/hooks/:

cp templates/hooks/pre-commit templates/hooks/pre-merge-commit templates/hooks/commit-msg /path/to/your-repo/.git/hooks/
chmod +x /path/to/your-repo/.git/hooks/pre-commit /path/to/your-repo/.git/hooks/pre-merge-commit /path/to/your-repo/.git/hooks/commit-msg

If you use the optional amir-cli automation, amir init-project (new repos) and amir update-projects (existing repos) install them for you.

Hook What it blocks
pre-commit Direct commits to main/master (use a feature branch); the Docs Checklist — a code change must also touch a doc (README / CHANGELOG / docs/ / *.md); personal/memory files (TODO.md, SESSION.md, force-added CLAUDE.md, …) — deleting one is allowed, that's the remediation; secrets/PII in added lines; and a skills/**.md edit without a version: bump (rules/036-skill-versioning.md); plus rules attestation — a missing or stale .rules-ack (run bin/ack-rules.sh), hash-based, skipped on merges, and a no-op where bin/ack-rules.sh is not installed.
pre-merge-commit The same privacy and skill-version gates applied to merge commits (git never runs pre-commit on automatic merges). Branch-protection and docs checks are skipped on merges — merging an approved branch into main is the sanctioned protocol step.
commit-msg AI co-authorship — ever. Any Co-Authored-By: <AI> trailer, a "Generated with <AI>" line, or a 🤖 marker in the message.

Don't want them? How to opt out

git commit --no-verify             # bypass for ONE commit (leaves a shell-history trace)
rm .git/hooks/commit-msg           # remove a single hook from this clone
rm .git/hooks/pre-commit
rm .git/hooks/pre-merge-commit
amir update-projects --no-hook     # sync the constitution WITHOUT (re)installing hooks

Removing a hook only affects that one clone; the templates and the rules stay intact, and a later amir update-projects reinstalls them unless you pass --no-hook.


📚 Documentation

⭐ Flagship Guide

🛠 Workflows

📝 Prompts

🧠 Skills (368 total)

Search this page (Ctrl+F) by keyword — every skill name, tool, and technology is listed below.

AI & Machine Learning (26 skills)
Skill Description
ai-logic-patterns Master prompting & agent orchestration rules
ai-regression-testing Automated regression suites for LLM outputs
ai-router Cost-aware model routing and fallback chains
ai-video-generation Gen-video with Runway, Kling, Luma, Veo
agentic-engineering Building robust agentic systems end-to-end
autonomous-loops Self-driving agent loops with quality gates
autonomous-agent-harness Production-ready autonomous agent scaffolding
continuous-learning Agents that improve from session observations
continuous-learning-v2 v2 learning pipeline with structured memory
eval-harness LLM evaluation framework & scoring pipelines
fal-ai-media fal.ai image & video generation API patterns
foundation-models-on-device On-device inference (MLX, llama.cpp, Core ML)
llm-ml-workflow Productionizing AI models end-to-end
llm-trading-agent-security Security patterns for LLM-driven trading agents
ml-adoption-playbook Organizational ML rollout & change management
multi-rag-orchestration Stateful multi-step RAG with lexical tracking
prompt-engineering Advanced system prompts, personas & few-shot
prompt-optimizer Systematic prompt scoring and iteration
pytorch-patterns PyTorch training loops, custom datasets, hooks
python-pytorch-sklearn Sklearn pipelines with PyTorch models
r-lang-guide targets pipelines & renv practices
ragas-evaluation RAG evaluation with RAGAS metrics
regex-vs-llm-structured-text When to use regex vs LLM for text extraction
reinforcement-learning Gymnasium envs & Stable-Baselines3 training
recsys-pipeline-architect Recommendation system pipeline design
token-budget-advisor Context budget management & cost optimization
Agent Systems & Orchestration (22 skills)
Skill Description
agent-architecture-audit 12-layer agent stack diagnostic & audit
agent-eval Agent performance evaluation frameworks
agent-harness-construction Building production agent harnesses
agent-introspection-debugging Debug agent behavior & silent failures
agent-self-evaluation Agents that score their own outputs
agentic-os Operating-system-level agent coordination
continuous-agent-loop CI/PR-integrated continuous agent loops
context-budget Token budget tracking and context hygiene
cost-tracking Per-session and per-task cost instrumentation
cost-aware-llm-pipeline Build pipelines that stay within cost targets
intent-driven-development Acceptance criteria before implementation
moltbot-orchestration Multi-agent video factory architecture
orch-pipeline Full orchestration pipeline from plan to deploy
orch-build-mvp Orchestrated MVP build workflow
orch-add-feature Orchestrated feature addition workflow
orch-change-feature Orchestrated feature change workflow
orch-fix-defect Orchestrated defect fix workflow
orch-refine-code Orchestrated code refinement workflow
parallel-execution-optimizer Maximize parallelism in multi-agent runs
plan-orchestrate Plan-then-orchestrate multi-step execution
recursive-decision-ledger Decision audit trail for autonomous agents
team-agent-orchestration Coordinate teams of specialized agents
Video & Media Production (28 skills)
Skill Description
auto-editor Automated silence removal & jump-cut editing
blender-motion-state-inspection Debug Blender animation state machines
davinci-resolve-scripting DaVinci Resolve Python API & timeline automation
fal-ai-media fal.ai image/video generation (FLUX, Kling, Veo)
ffmpeg-recipes Copy-pasteable FFmpeg commands for video automation
ffmpeg-reference Codec ops, metadata, filters & flag reference
manim-video Manim scene patterns & network graph explainers
motion-advanced Advanced motion design principles & techniques
motion-foundations Core motion design theory & easing
motion-patterns Reusable motion design patterns
motion-ui UI motion & micro-interaction design
obs-studio OBS automation, scenes, and streaming setup
remotion-video-creation Programmatic video with React + Remotion
taste Creative direction layer for music videos & edits
video-blender-automation Blender bpy API & Geometry Nodes scripting
video-editing Professional video editing workflows & tools
video-effects-transitions VFX, transitions & compositing techniques
video-manim-math Manim math animations: OpenGL, plugins, shaders
video-production-automation Full Python pipeline: Manim, MoviePy, OpenCV
video-remotion-react React-based programmatic video creation
video-resolve-editing DaVinci Resolve post-production & color grading
video-stick-figure 2D stick figure animation & physics
videodb VideoDB vector search & scene understanding
visual-ai-cinematography Gen-video cinematography (Runway, Kling, Luma)
visual-character-consistency Identity preservation across frames (ComfyUI, LoRA)
visual-director-procedural Blender & Manim semantic visual direction
visual-thumbnail-psychology CTR-optimized thumbnail design psychology
comfyui-stable-diffusion ComfyUI workflows & Stable Diffusion nodes
Voice, Audio & TTS (17 skills)
Skill Description
ai-dubbing-localization Automated dubbing & tone-preserving localization
ai-sfx-generation Latent diffusion for sound design & SFX
audio-processing Neural denoising & EBU R128 normalization
fish-speech Fish Speech TTS model setup & fine-tuning
gpt-sovits GPT-SoVITS voice cloning & training
heygen-api HeyGen avatar video generation API
huggingface-tts HuggingFace TTS model catalog & inference
mlx-whisper Apple Silicon Whisper transcription via mlx-whisper
music-generation AI music generation (Suno, Udio, MusicGen)
opensource-tts Open-source TTS stack comparison & setup
persian-tts-training Persian-language TTS fine-tuning pipeline
storytelling-tts-m4-system End-to-end TTS storytelling on Apple Silicon
subtitle-generator Professional subtitles with cinematic typography
voice-ai-cloning-finetuning Multilingual voice cloning & emotional synthesis
voice-dialogue-tts Multi-speaker turn-taking & emotional prosody
voice-emotional-acting One-person multi-character production
voice-orchestration-multi-model Multi-model TTS pipelines (Fish, Dia, Bark, Parler)
voice-synthesis-multilingual SOTA multilingual TTS & cross-lingual cloning
xtts-v2 XTTS-v2 fine-tuning & streaming inference
Content, YouTube & Marketing (21 skills)
Skill Description
article-writing Long-form article structure & SEO writing
brand-discovery Brand positioning & identity research
brand-voice Consistent brand voice modeling & guidelines
competitive-platform-analysis Systematic competitor platform teardown
competitive-report-structure Competitive intelligence report templates
content-engine Automated content production pipelines
copywriting Conversion-focused copy & persuasion logic
crosspost Cross-platform content distribution automation
marketing-campaign Campaign planning, execution & measurement
screenwriting-automated 100% automated script production pipeline
screenwriting-frameworks 3-Act, Hero's Journey, beat sheets
screenwriting-youtube High-retention YouTube hooks & psychology
seo Technical SEO, on-page optimization & audits
social-graph-ranker Social network analysis & influence ranking
social-publisher Scheduled multi-platform social publishing
storytelling-clil-education Educational storytelling & Leitner SRS
storytelling-narrative-frameworks Save the Cat, Story Circle & advanced structures
x-api X/Twitter API v2 patterns & automation
youtube-analytics YouTube Data API analytics & reporting
youtube-automation-pipeline End-to-end YouTube publishing automation
youtube-data-api YouTube Data API v3 — uploads, playlists, captions
youtube-dlp-web-download yt-dlp: Cloudflare bypass, stream selection
youtube-seo Titles, thumbnails, retention & channel growth
Research & Science (12 skills)
Skill Description
deep-research Systematic multi-source research protocols
exa-search Exa semantic search API integration
market-research Primary & secondary market research methods
ml-adoption-playbook Enterprise ML adoption & stakeholder alignment
prediction-market-oracle-research Prediction market data sourcing & analysis
prediction-market-risk-review Risk assessment for prediction market positions
research-ops Research workflow automation & knowledge mgmt
scientific-db-pubmed-database PubMed API queries & literature retrieval
scientific-db-uspto-database USPTO patent search & analysis
scientific-pkg-gget gget for genomics data retrieval
scientific-thinking-literature-review Systematic literature review methodology
scientific-thinking-scholar-evaluation Academic paper quality evaluation
Python (8 skills)
Skill Description
python-core-standards Project structure, uv, typing & conventions
python-containerization Docker: Slim vs Alpine, multi-stage builds
python-github-setup GitHub Actions, templates & semantic release
python-pandas-sklearn Method chaining, pipelines & ColumnTransformer
python-patterns Idiomatic Python patterns & anti-patterns
python-pytorch-sklearn Sklearn data pipelines with PyTorch models
python-testing pytest, fixtures, parametrize & coverage
generating-python-installer Build distributable Python installer packages
Web & Frontend (24 skills)
Skill Description
angular-developer Angular architecture, RxJS & state management
bun-runtime Bun runtime setup, bundling & testing
chrome-extension-best-practices MV3 extensions, UI & Shadow DOM
design-system Design tokens, component libraries & theming
fastapi-best-practices FastAPI: Pydantic v2, lifespan, background tasks
fastapi-patterns FastAPI project structure, auth, DI & testing
flask-json-guide Robust Flask API structure & error handling
frontend-a11y Web accessibility (WCAG, ARIA, screen readers)
frontend-design-direction Visual direction & design review for UIs
frontend-patterns Cross-framework frontend architecture patterns
frontend-slides Browser-based presentation & slide tooling
js-ts-code-quality Strict TypeScript, Biome/ESLint & Vitest
liquid-glass-design iOS 26 liquid glass UI design patterns
make-interfaces-feel-better Micro-interactions & polish for any UI
modern-web-ui Vanilla HTML/CSS/JS best practices
nextjs-turbopack Next.js App Router & Turbopack setup
nuxt4-patterns Nuxt 4 architecture & composables
react-patterns React component patterns & hooks
react-performance React rendering optimization & profiling
react-testing Testing Library, MSW & Vitest for React
ui-demo Interactive demo & prototype patterns
vite-patterns Vite config, plugins & build optimization
vue-patterns Vue 3 Composition API & ecosystem patterns
ui-to-vue Migrating UI components to Vue 3
Backend (40 skills)
Skill Description
backend-patterns Cross-language backend architecture patterns
cpp-coding-standards Modern C++20/23 standards & best practices
cpp-testing Catch2, GoogleTest & CMake testing
csharp-testing xUnit, Moq & .NET testing patterns
django-celery Celery task queues with Django
django-patterns Django project structure & ORM patterns
django-security Django security hardening & OWASP
django-tdd TDD with Django & pytest-django
django-verification Django deployment verification checklists
dotnet-patterns .NET 8+ architecture & dependency injection
error-handling Structured error handling across languages
flask-json-guide Flask JSON API patterns & error handling
fsharp-testing F# testing with Expecto & FsCheck
golang-patterns Go idioms, concurrency & project layout
golang-testing Go testing: table tests, benchmarks, fuzz
hexagonal-architecture Ports & adapters pattern implementation
java-coding-standards Java 21+ records, sealed types & patterns
jpa-patterns JPA/Hibernate patterns & query optimization
kotlin-coroutines-flows Kotlin coroutines, Flows & structured concurrency
kotlin-exposed-patterns Kotlin Exposed ORM patterns
kotlin-ktor-patterns Ktor server patterns & plugin architecture
kotlin-patterns Kotlin idiomatic patterns & conventions
kotlin-testing Kotlin testing with Kotest & MockK
laravel-patterns Laravel architecture & Eloquent patterns
laravel-plugin-discovery Laravel package & plugin discovery
laravel-security Laravel security & authorization patterns
laravel-tdd TDD with Laravel & Pest
laravel-verification Laravel deployment verification
nestjs-patterns NestJS modules, providers & interceptors
perl-patterns Modern Perl idioms & CPAN usage
perl-security Perl security: taint mode & injection prevention
perl-testing Perl testing with Test::More & prove
quarkus-patterns Quarkus CDI, Panache & REST patterns
quarkus-security Quarkus OIDC & security hardening
quarkus-tdd TDD with Quarkus & QuarkusTest
quarkus-verification Quarkus native build verification
rust-patterns Rust ownership, traits & async patterns
rust-testing Rust testing: unit, integration & cargo nextest
springboot-patterns Spring Boot architecture & Spring Data
springboot-security Spring Security & OAuth2 patterns
springboot-tdd TDD with Spring Boot & Testcontainers
springboot-verification Spring Boot production readiness checks
tinystruct-patterns tinystruct Java framework patterns
Mobile (12 skills)
Skill Description
android-clean-architecture Android Clean Architecture & MVVM
compose-multiplatform-patterns Kotlin Multiplatform + Compose patterns
dart-flutter-patterns Flutter architecture & Dart patterns
flutter-dart-code-review Flutter code review checklist
ios-icon-gen iOS app icon generation & asset catalogs
jetpack-compose-guidelines Android declarative UI & permissions
kotlin-patterns Kotlin Android idioms & Coroutines
swift-actor-persistence Swift actors & SwiftData persistence
swift-concurrency-6-2 Swift 6.2 strict concurrency model
swift-protocol-di-testing Swift protocol-based DI & testability
swiftui-guidelines SwiftUI modern architecture & audio
swiftui-patterns SwiftUI component patterns & state
Database (6 skills)
Skill Description
clickhouse-io ClickHouse OLAP queries & ingestion patterns
database-migrations Safe schema migrations across databases
mysql-patterns MySQL indexing, query optimization & replication
postgres-patterns PostgreSQL: JSONB, CTEs, partitioning & RLS
prisma-patterns Prisma ORM schema design & migrations
redis-patterns Redis data structures, caching & pub/sub
DevOps & Infrastructure (17 skills)
Skill Description
canary-watch Canary deployment monitoring & rollback
config-gc Garbage-collect stale config & dead flags
deployment-patterns Blue/green, canary & rolling deploy patterns
docker-patterns Dockerfile best practices & multi-stage builds
flox-environments Flox reproducible dev environments
git-workflow Git branching, rebase & PR workflow standards
github-code-quality GitHub Actions CI, PR templates & code owners
github-ops GitHub API, releases & repository automation
kubernetes-docs K8s best practices & MkDocs integration
kubernetes-patterns K8s manifests, Helm charts & operator patterns
latency-critical-systems Sub-millisecond latency design & profiling
linux-cuda-python HPC setup, PyTorch CUDA & GPU profiling
ops-automation CI/CD, Docker & experiment tracking automation
production-audit Pre-launch production readiness audit
python-containerization Python Docker: Slim vs Alpine, multi-stage
uncloud Cloud cost reduction & simplification patterns
data-throughput-accelerator High-throughput data pipeline optimization
Network & NetDevOps (10 skills)
Skill Description
cisco-ios-patterns Cisco IOS/IOS-XE config & automation patterns
homelab-network-readiness Homelab pre-deployment network checklist
homelab-network-setup Homelab network design & VLAN architecture
homelab-pihole-dns Pi-hole DNS-level ad blocking setup
homelab-vlan-segmentation VLAN design & 802.1Q trunk configuration
homelab-wireguard-vpn WireGuard VPN setup & peer management
netmiko-ssh-automation Netmiko SSH automation for network devices
network-bgp-diagnostics BGP troubleshooting & route analysis
network-config-validation Network config diff & compliance validation
network-interface-health Interface health monitoring & alerting
Web3 & Blockchain (7 skills)
Skill Description
defi-amm-security AMM security: reentrancy, flash loans, MEV
evm-token-decimals EVM token decimal handling & precision
llm-trading-agent-security Security for LLM-driven on-chain agents
nodejs-keccak256 keccak256 hashing in Node.js
web3-react-dapps Wagmi, Viem & dApp architecture
web3-solidity-foundry Foundry: Rust-based Solidity testing & fuzzing
web3-solidity-hardhat Hardhat JS/TS ecosystem & tooling
Testing & QA (10 skills)
Skill Description
ai-regression-testing Automated regression for LLM outputs
benchmark Performance benchmarking methodology
benchmark-methodology Rigorous benchmark design & statistical analysis
benchmark-optimization-loop Iterative benchmark-driven optimization
browser-qa Browser automation & visual regression testing
e2e-testing End-to-end testing with Playwright & Cypress
ragas-evaluation RAG pipeline evaluation with RAGAS
tdd-workflow TDD: RED/GREEN/refactor + evidence reports
verification-loop Automated verification gate patterns
windows-desktop-e2e Windows desktop app E2E testing
Security (9 skills)
Skill Description
django-security Django security hardening & OWASP top 10
gateguard Pre-edit investigation gate for critical files
healthcare-phi-compliance HIPAA PHI handling & de-identification
hipaa-compliance HIPAA technical & administrative safeguards
laravel-security Laravel security & XSS/CSRF prevention
safety-guard Agent output safety filtering & guardrails
security-bounty-hunter Bug bounty methodology & vulnerability research
security-review Code security review checklist & SAST
security-scan Automated dependency & secret scanning
Claude Code & Agent Harness (18 skills)
Skill Description
agent-sort Agent task routing & priority sorting
canary-watch Deployment canary monitoring
claude-code-integration Claude Code CLI, hooks, MCP & agentic patterns
claude-devfleet Claude Code fleet management & parallelism
codehealth-mcp MCP-driven code health metrics & alerts
configure-ecc ECC harness configuration & setup
context-budget Token budget tracking & context hygiene
cost-tracking Per-session LLM cost instrumentation
dynamic-workflow-mode Switch agent workflow modes at runtime
ecc-guide ECC harness user guide & patterns
ecc-tools-cost-audit Audit ECC tool usage & cost attribution
hookify-rules Claude Code hook authoring & management
nanoclaw-repl REPL-based agent session persistence
repo-scan Repository structure & health scanning
rules-distill Distill project rules from code patterns
skill-comply Enforce skill usage compliance in agent runs
skill-scout Discover missing skills from agent behavior
skill-stocktake Audit & deduplicate skill catalog
token-budget-advisor Context budget management strategies
Scripting & Automation (10 skills)
Skill Description
automation-audit-ops Audit & optimize automation pipelines
rtl-persian-app-patching Force Persian/RTL into Electron & web apps you don't own
cli-table-alignment Pixel-perfect ASCII tables with emoji support
dmux-workflows tmux/dmux session & pane automation
hookify-rules Claude Code hooks authoring & lifecycle
macos-automation macOS Python/Zsh desktop automation scripts
terminal-ops Terminal productivity & shell tooling
zsh-completion Robust zsh autocomplete without pitfalls
zsh-scripting-advanced SIGINT traps, option parsing & shell patterns
generating-python-installer Build distributable Python installer packages
Business & Operations (20 skills)
Skill Description
carrier-relationship-management Logistics carrier relationship & SLA management
customer-billing-ops Billing automation & subscription ops
customs-trade-compliance Import/export compliance & HS code classification
email-ops Email automation, filtering & CRM integration
energy-procurement Energy market procurement & contract analysis
enterprise-agent-ops Enterprise-scale agent deployment & governance
finance-billing-ops Finance billing pipeline & reconciliation
google-workspace-ops Google Workspace (Docs, Sheets, Drive) automation
healthcare-cdss-patterns Clinical decision support system patterns
healthcare-emr-patterns Electronic medical records integration
healthcare-eval-harness Healthcare AI evaluation & safety harness
inventory-demand-planning Demand forecasting & inventory optimization
investor-materials Pitch decks, one-pagers & investor data rooms
investor-outreach Investor outreach sequencing & CRM
jira-integration Jira API automation & project management
knowledge-ops Knowledge base management & retrieval ops
lead-intelligence Lead enrichment & sales intelligence automation
logistics-exception-management Logistics exception detection & resolution
messages-ops Messaging platform automation (Slack, Teams)
product-capability Product capability mapping & gap analysis
product-lens Product strategy analysis framework
production-scheduling Manufacturing & production schedule optimization
project-flow-ops Project management workflow automation
quality-nonconformance Quality NCR tracking & corrective actions
returns-reverse-logistics Returns management & reverse logistics
strategic-compact Strategy documents & executive briefings
Specialty & Misc (18 skills)
Skill Description
ascii-game-dev ECS architecture & terminal rendering
blueprint Project blueprint & scaffolding templates
cv-latex-workspace Multi-template CV with pdflatex/xelatex
data-science-workflow Reproducible data science project structure
data-visualization Publication-quality plots with Scipy/Seaborn
desktop-gui-dev Python GUIs with CustomTkinter & PyQt6
episode-structure-45min 45-min 3-part episode format & pacing
financial-data-science OpenBB, Pandas-TA & QuantStats stack
howto-documentation Diátaxis framework & technical writing
image-enhancement Neural upscaling, denoising & post-processing
imagemagick-reference ImageMagick input normalization & operations
imagemagick-technical PDF conversion, color space & FX operator
method-of-loci Spatial memory & Blender loci construction
nutrient-document-processing Document AI & structured data extraction
pdf-form-filling Automated PDF form filling & generation
pdf-rendering-engines PDF rendering stack comparison & selection
storytelling-clil-education CLIL educational storytelling & Leitner SRS
visa-doc-translate Official document translation for visa applications

🤖 MCP Server Integration

Connect this knowledge base to any MCP-compatible AI assistant. Two transports available — stdio (Claude Code CLI) and HTTP (everything else).

One-time HTTP server setup

cp bin/mcp-server/com.agent-constitution.mcp.plist ~/Library/LaunchAgents/
launchctl load ~/Library/LaunchAgents/com.agent-constitution.mcp.plist
curl http://localhost:8765/health  # → {"status":"ok","skills":343}

Connect your tool

Tool Config
Claude Code CLI Zero config — stdio works out of the box
Cursor ~/.cursor/mcp.json"url": "http://localhost:8765/sse"
VS Code Continue.dev extension → ~/.continue/config.json
Antigravity IDE Continue.dev extension → same ~/.continue/config.json
JetBrains Continue plugin → same ~/.continue/config.json
Gemini CLI ~/.gemini/settings.json"httpUrl": "http://localhost:8765/mcp"

Available Tools

Tool Description
list_skills List all 343 skill names
get_skill Read any skill — e.g. get_skill("fastapi-best-practices")
get_rules Get global repository rules
run_<workflow> Execute a workflow

See MCP Server README for full per-IDE setup instructions.


Acknowledgements

This repository's skill catalog includes content adapted from ECC — Everything Claude Code by affaan-m (MIT). If a skill isn't found here, ECC is a good next place to look.


Built with strict adherence to the Prompt-Driven Development methodology.

About

A validated Context Architecture and strict Governance Protocol for AI Agents (Claude, AntiGravity, Cursor, Windsurf, Copilot). Forces structure, prevents hallucinations and ensures file safety.

Resources

Contributing

Stars

2 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages