A portable, provider-agnostic configuration system for AI coding agents — 12 agents, 159 skills, 79 rules, and 35 hooks that install into any supported CLI tool.
.
├── agents/ # 12 agent definitions (10 core + 2 AutoResearch)
│ ├── cards/ # A2A Agent Card JSON files (10 cards)
│ └── MIGRATION.md # Legacy agent → core agent mapping
├── hooks/ # Shell scripts for lifecycle hooks
├── plugins/ # Plugin install manifest
├── rules/ # Global coding convention rules
├── skills/ # 139 skills (63 workflow + 71 domain)
├── providers/ # Provider mapping files and routing profiles
├── specs/ # Spec-driven development (SPEC-001 through SPEC-093)
├── AGENTS.md # Cross-provider agent behavior contract
├── SPEC.md # Project manifest
├── CHANGELOG.md # Version history
├── settings.json # Main settings (permissions, hooks, env, plugins)
├── settings.local.json # Machine-local settings overrides
├── mcp.json # MCP server manifest (8 core + 4 authenticated + 4 optional)
├── install-mcp.sh # MCP server installer
└── install.sh # Symlink installer
settings.json— Permissions (auto-allow all tools + MCP), hook wiring, env vars (CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS), and plugins (rust-analyzer LSP). Includes$schemafor editor autocomplete.settings.local.json— Machine-specific overrides (currently allows thebrowseskill).plugins/installed_plugins.json— Plugin install manifest for reproducibility. The installer printsclaude plugin installcommands for each plugin.
Pre-configured Model Context Protocol servers organized in three tiers:
Core (no auth, install and go):
| Server | What it does |
|---|---|
context7 |
Up-to-date library docs and code examples (prevents hallucinated APIs) |
sequential-thinking |
Structured reasoning for complex multi-step problems |
fetch |
Fetch URLs and convert HTML to Markdown |
memory |
Persistent knowledge graph across sessions |
playwright |
Browser automation (navigate, interact, screenshot) |
git |
Git operations (status, diff, log, commit, branch, blame) |
kubernetes |
Kubernetes cluster management |
docker |
Docker container management |
Authenticated (require API keys):
| Server | What it does | Auth |
|---|---|---|
github |
GitHub API (repos, issues, PRs, code search) | GITHUB_TOKEN |
gitlab |
GitLab API (projects, MRs, issues, pipelines) | GITLAB_TOKEN |
brave-search |
Web search via Brave (2,000 free queries/month) | BRAVE_API_KEY |
grafana |
Dashboards, Prometheus, Loki, alerting | GRAFANA_URL + GRAFANA_TOKEN |
Optional (project-specific):
| Server | What it does |
|---|---|
postgres |
PostgreSQL schema inspection and queries |
surrealdb |
SurrealDB schema management and SurrealQL |
semgrep |
Static analysis security scanning (OWASP Top 10) |
sqlite |
SQLite database queries |
63 coding convention rules, automatically applied based on file path patterns:
Languages:
| Rule | Scope |
|---|---|
go.md |
Go — structured logging, error wrapping, table-driven tests, context-first |
rust.md |
Rust — ownership, error handling (thiserror/anyhow), tracing, unsafe auditing |
python.md |
Python — type annotations, Pydantic v2, asyncio, pytest, ruff/mypy |
typescript.md |
TypeScript — strict mode, discriminated unions, Zod, vitest |
java.md |
Java 17-21+ — records, sealed classes, Spring Boot 3.x, virtual threads |
svelte.md |
SvelteKit 5 — runes, props, Tailwind, TypeScript |
react.md |
React 18/19 — Server Components, concurrent rendering, TanStack Query |
Domains:
| Rule | Scope |
|---|---|
api.md |
API — REST, GraphQL, gRPC, event-driven, middleware order |
frontend.md |
Frontend — layout, semantic HTML, accessibility, performance |
security.md |
Security — OWASP Top 10, auth, crypto, secrets, web security |
testing.md |
Testing — table-driven, AAA pattern, coverage targets, E2E |
database.md |
Database — queries, schema, migrations, PostgreSQL, SurrealDB |
documentation.md |
Documentation — Diataxis framework, ADRs, API docs, code examples |
observability.md |
Observability — structured logging, metrics, traces, SLOs, dashboards |
infrastructure.md |
Infrastructure — containers, Kubernetes, Helm, CI/CD, secrets |
k8s.md |
Kubernetes/Flux — GPU strategy, image tags, GitOps, storage |
compliance.md |
Compliance — data classification, PII, NIST, GDPR, HIPAA, SOC 2 |
Systems & Process:
| Rule | Scope |
|---|---|
linux.md |
Linux — systemd units, udev, packaging, desktop integration |
desktop-gui.md |
Desktop GUI — Qt6/QML, GTK4/libadwaita, accessibility, Wayland |
shell.md |
Shell scripts — safety (set -euo pipefail), variables, error handling |
quality.md |
Code quality — function design, complexity, naming, review checklist |
git.md |
Git — commit messages, branching, PR conventions, history |
Shell scripts wired into Claude Code lifecycle events:
| Hook | Event | Purpose |
|---|---|---|
guard-bash.sh |
PreToolUse (Bash) | Blocks catastrophic commands (rm -rf /, force push main, DROP DATABASE, etc.) |
guard-files.sh |
PreToolUse (Edit/Write) | Blocks edits to sensitive files (.env, credentials, keys, kubeconfig) |
autoformat.sh |
PostToolUse (Edit/Write) | Auto-formats files by extension (gofmt, prettier, black, rustfmt) |
guard-commit.sh |
PostToolUse (Bash) | Warns about --no-verify and missing issue references in commits |
notify.sh |
Notification | Desktop notification via notify-send when Claude needs attention |
post-compact.sh |
SessionStart (compact) | Re-injects engineering discipline reminders after context compaction |
track-tokens.sh |
SessionStart | Logs session starts for usage tracking |
12 agent definitions following a core-agent-plus-skills architecture. Each core agent covers a broad role and loads domain-specific skills on demand. See AGENTS.md for the cross-provider behavior contract and agents/cards/ for machine-readable A2A Agent Cards.
| Agent | Tier | Domains |
|---|---|---|
developer |
sonnet | Code implementation across all languages/frameworks, UI/UX, databases, debugging |
reviewer |
sonnet | Code review, doc review, accessibility audit, performance review |
architect |
opus | System, infrastructure, data, network, agent, and swarm architecture |
tester |
sonnet | Unit, integration, e2e, and performance test authoring |
security-analyst |
opus | Threat modeling, pentesting, AppSec, supply chain, LLM/agent security |
operations |
sonnet | Deployment, SRE, observability, containers, incident response, Linux |
compliance |
sonnet | RMF, STIG, FedRAMP, privacy, control mapping, evidence, SBOM |
researcher |
sonnet | Web research, market/competitive/customer/product analysis |
writer |
sonnet | Technical docs, API docs, architecture docs, diagrams |
planner |
opus | Project planning, requirements, migration, release, GTM strategy |
research-orchestrator |
opus | AutoResearch improvement loop (SPEC-078) |
eval-runner |
sonnet | Mechanical evaluation harness for AutoResearch (SPEC-078) |
139 skills in two categories:
63 workflow skills — slash-command invokable with /<skill-name>:
/accessibility-audit /agent-design /agent-eval /agent-security-audit /agent-security-design /api /api-docs /architecture-design /architecture-docs /brand /browse /bug-fix /changelog /ci-cd /cleanup /code-review /competitive-analysis /customer-research /database-migration /dependency-audit /deployment /discipline /documentation-review /e2e-test /evaluate-model /feature-development /finetune /gtm-plan /inline-comments /integration-test /issues /kickstart /llm-security-audit /monitoring-setup /mutation-testing /ops /performance-review /pricing-strategy /product-review /project /provenance-audit /quantize /readme-generation /red-team /release /requirements-analysis /risk-assessment /rmf /route /sdlc /secret-detection /security-review /seo-audit /spec /structure /swarm-design /task-breakdown /test-coverage-analysis /threat-modeling /timeline-estimation /ui-component /unit-test-writing /vulnerability-scan
71 domain skills — loaded by core agents when task context matches:
Domain skills provide focused expertise (Go conventions, Kubernetes security, STRIDE threat modeling, etc.) without procedural steps. Core agents select them via the skill routing convention in rules/skill-routing.md.
git clone https://github.com/iannelsondev/adc.git
cd adcPick your CLI tool and install. You can install into one or all of them — each gets its own translated agent library.
# Install into all your CLI tools at once
./install.sh --multi-provider claude,codex,copilot,gemini
# Install MCP servers
./install-mcp.shThis installs ADC's agents, rules, hooks, and skills into each CLI's config directory and creates a route table for multi-provider routing.
Other orchestrators like opencode can also consume the provider mappings and routing profiles in the same manner.
./install.sh
./install-mcp.shSymlinks agents, rules, hooks, skills, and settings into ~/.claude/. Updates are automatic — git pull and changes are live.
- Auth: Log in with
claude(Anthropic subscription — Max, Team, or Enterprise) - Models: Opus, Sonnet, Haiku
- Agents: Full support — 12 core agents with native tool names (
Read,Write,Edit,Bash,Glob,Grep,Agent) - Skills: Full support — 139 skills (63 workflow + 71 domain)
- Hooks: Full support — 7 lifecycle hooks (guard, autoformat, notifications)
- Test:
claude -p "hello" --model haiku
./install.sh --provider codexTranslates agents into Codex format and installs into ~/.codex/. Generates config.toml with permissions.
- Auth: Log in with
codex login(ChatGPT Plus/Pro/Team account) - Models: GPT-5.4, GPT-5.1-codex, GPT-5-mini
- Agents: Translated — tool names mapped (
read_file,write_file,edit_file,bash), model tiers mapped to GPT equivalents - Skills: Not directly supported — use agent prompts instead
- Hooks: Not supported (Codex has its own sandbox model)
- Test:
codex exec -m gpt-5.4 "hello" --full-auto
./install.sh --provider copilotTranslates agents into Copilot format and installs into ~/.copilot/.
- Auth: Log in with
copilotorgh auth login(GitHub Copilot subscription) - Models: Claude Opus 4.6, Claude Sonnet 4.6, Claude Haiku 4.5, GPT-5.2, Gemini 3 Pro (Copilot routes internally)
- Agents: Translated — same interface as Claude Code (
-p,--agent,--model) - Skills: Not directly supported — use agent prompts instead
- Hooks: Not supported
- Test:
copilot -p "hello" --allow-all-tools
./install.sh --provider geminiTranslates agents into Gemini format and installs into ~/.gemini/.
- Auth: Set
GEMINI_API_KEYor configure~/.gemini/settings.json(Google AI Studio or Vertex AI) - Models: Gemini 2.5 Pro, Gemini 2.5 Flash, Gemini 2.0 Flash Lite
- Agents: Translated — tool names mapped (
read_file,write_file,edit_file,shell), model tiers mapped to Gemini equivalents - Skills: Not directly supported — use agent prompts instead
- Hooks: Not supported
- Context window: 1M tokens (largest of any provider)
- Test:
gemini -p "hello"
The installer reads the provider's mapping file (providers/<provider>.json) and translates ADC's portable agent definitions — tool names, model tiers, hook events — into the format each CLI expects:
| Provider | Config directory | Tool mapping | Model mapping |
|---|---|---|---|
claude |
~/.claude/ |
Read, Write, Edit, Bash, Glob, Grep |
opus, sonnet, haiku |
codex |
~/.codex/ |
read_file, write_file, edit_file, bash |
gpt-5.4, gpt-5.1-codex, gpt-5-mini |
copilot |
~/.copilot/ |
read_file, write_file, edit_file, bash |
claude-opus-4.6, claude-sonnet-4.6, claude-haiku-4.5 |
gemini |
~/.gemini/ |
read_file, write_file, edit_file, shell |
gemini-2.5-pro, gemini-2.5-flash, gemini-2.0-flash-lite |
# Core MCP servers (no auth required)
./install-mcp.sh
# Everything including authenticated servers
export GITHUB_TOKEN=ghp_...
export GITLAB_TOKEN=glpat-...
export BRAVE_API_KEY=BSA...
./install-mcp.sh --alljq— required by hook scripts and the installer for JSON parsingnotify-send— optional, for desktop notifications (Linux only)- Language formatters (optional, for auto-format hook):
gofmt,goimports,prettier,black,rustfmt
cd /path/to/adc
git pull
# Claude: symlinks mean changes are already active — no reinstall needed
# Codex/Gemini/Copilot: re-run ./install.sh --provider <name> to pick up changes
# Multi-provider: re-run ./install.sh --multi-provider <list> to pick up changesADC improves itself based on real-world usage. When agents give wrong guidance, users correct them. Those corrections accumulate as feedback memories. The AutoResearch system transforms those corrections into configuration improvements — automatically.
User corrects agent → Feedback memory stored → Corrections aggregate
↓ ↓
(tagged with artifact path, (3+ corrections on same artifact
correction type, content) triggers improvement proposal)
↓
/autoresearch plan --from-feedback
↓
Assertions generated from corrections
↓
/autoresearch run (on branch)
↓
Convergence chain + PR for review
Project-local: Corrections from your project improve your local configuration. Overrides go to .claude/skills/ and .claude/rules/, taking precedence over global ADC config for your project only.
ADC-global: When the same correction appears across multiple projects (3+ corrections, 2+ projects), it signals a systemic issue. The ADC maintainer runs /autoresearch run --global to improve the canonical configuration. Changes land on an autoresearch/ branch for human review — no autonomous merge.
- Mechanical evaluation only — binary assertions, no LLM-as-judge
- Oscillation detection — strategy categories exhausted after 3 consecutive failures
- Guard command — structural validation before every commit (mandatory for all targets)
- Convergence chain — auditable record linking each improvement to its metric delta and feedback sources
- No autonomous merge — improvement branches require human review
- Test case immutability — the loop cannot modify its own evaluation criteria
- Provenance — every change attributed to the model that produced it via
Co-Authored-By
# Plan an improvement from user feedback (requires surrealmemory)
/autoresearch plan --from-feedback skills/go/SKILL.md
# Or plan manually with custom assertions
/autoresearch plan
# Run the loop
/autoresearch run
# Check progress
/autoresearch status
# Generate improvement report (for PR description)
/autoresearch reportSee SPEC-077 (types), SPEC-079 (skill), SPEC-094 (enforcement), and SPEC-095 (feedback pipeline) for details.
ADC specs can be indexed into a SurrealDB graph for queryable relationships, coherence scoring, and Mermaid diagram export via surrealmemory (sm).
This is optional — the base spec system works entirely with flat Markdown files. The graph backend adds:
- Spec dependency traversal and coherence scoring
- Memory graph with GraphRAG context assembly
- MCP server exposing 16 tools to Claude Code agents
- Work path DAG for causal reasoning
# Install sm (Arch Linux)
paru -S surrealmemory # or download from GitHub releases
# Initialize and sync ADC specs into the graph
sm init
sm sync --specs-dir specs/
sm spec coherence
See SPEC-019 (Spec Graph) and SPEC-024 (Graph Memory) for details.