The Claude Council

████████╗██╗  ██╗███████╗     ██████╗██╗      █████╗ ██╗   ██╗██████╗ ███████╗
╚══██╔══╝██║  ██║██╔════╝    ██╔════╝██║     ██╔══██╗██║   ██║██╔══██╗██╔════╝
   ██║   ███████║█████╗      ██║     ██║     ███████║██║   ██║██║  ██║█████╗
   ██║   ██╔══██║██╔══╝      ██║     ██║     ██╔══██║██║   ██║██║  ██║██╔══╝
   ██║   ██║  ██║███████╗    ╚██████╗███████╗██║  ██║╚██████╔╝██████╔╝███████╗
   ╚═╝   ╚═╝  ╚═╝╚══════╝     ╚═════╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝

                    ██████╗ ██████╗ ██╗   ██╗███╗   ██╗ ██████╗██╗██╗
                   ██╔════╝██╔═══██╗██║   ██║████╗  ██║██╔════╝██║██║
                   ██║     ██║   ██║██║   ██║██╔██╗ ██║██║     ██║██║
                   ██║     ██║   ██║██║   ██║██║╚██╗██║██║     ██║██║
                   ╚██████╗╚██████╔╝╚██████╔╝██║ ╚████║╚██████╗██║███████╗
                    ╚═════╝ ╚═════╝  ╚═════╝ ╚═╝  ╚═══╝ ╚═════╝╚═╝╚══════╝

"Every plan or piece of work routed through Claude should shock the world."

— The user directive that drove the v1.0.0 build

Why this exists

Out of the box, Claude Code is a powerful generalist. The Claude
Council turns it into a 16-division multi-agent Council
operating at principal-engineer level across the entire stack:
architecture, security, compliance, ops, data, finance, risk,
strategy, people, ESG, ethics, comms, plus the five core technical
divisions.

This repo is the complete config surface — 15 Floor rules
(always-loaded, ~224 KB) + 160 Library rules (lazy-loaded via
skill triggers, ~1.6 MB), 121 principal-level skills, 32
specialist agents, 33 commands, a strict Council protocol,
14 hook-enforced quality gates, and project-scoped artifact
bootstrap. The dual-surface design keeps every session's eager
cold-load budget around ~240 KB (Floor + CLAUDE.md, down from
the ~1.7 MB monolith) while preserving every rule's full content
for on-demand reference via skill paths: triggers.

For anyone, on any project. No org-dependency, no SaaS, no
telemetry.

What you get after install:

┌────────────────────────────────────────────────────────────────────┐
│                                                                    │
│   Every prompt        ●  29-question task intake (mandatory)       │
│   ────────────►       ●  16 divisions speak (5 always + 11 auto)   │
│   in every project    ●  Standards-cited research                  │
│                       ●  Verify-before-claim discipline            │
│                       ●  Project-scoped .claude/ scaffold          │
│                       ●  Continuous learning loop                  │
│                                                                    │
└────────────────────────────────────────────────────────────────────┘

Three-minute install

# Public repo — no auth required for clone.
# `gh repo clone Nmor/the-claude-council` also works.
git clone https://github.com/Nmor/the-claude-council.git
cd the-claude-council
./bootstrap/install.sh
./bootstrap/verify.sh

# Public repo — no auth required for clone.
# `gh repo clone Nmor/the-claude-council` also works.
git clone https://github.com/Nmor/the-claude-council.git
Set-Location the-claude-council
Set-ExecutionPolicy -Scope Process Bypass
.\bootstrap\install.ps1
.\bootstrap\verify.ps1

Both flows are fully native to their host platform — Windows
users do not need WSL2 or Git Bash. The installer is
idempotent: any existing ~/.claude/ is moved aside to a
timestamped backup before the new one lands. Pass --dry-run
(-DryRun on PowerShell) to preview, --force (-Force) to
skip the backup, --no-ide (-NoIde) to skip IDE integration.
Full options + per-IDE walkthroughs in INSTALL.md.

After install, open any project in any Claude Code-compatible
IDE — the Council fires on the next prompt.

The Council in 5 paragraphs

1. Always-on, never bypassed

Every prompt routes through Council Phase 0 (deep research
plus 29-question intake) → Phase 1 (5 core divisions speak,
11 extended divisions auto-fire on triggers) → Phase 2
(consensus + named tiebreakers) → Phase 3 (implementation plus
post-write verification). Abbreviated mode is a speed knob, not
a skip switch. Bypass attempts are audit-logged.

2. Five core divisions, eleven extended

┌─ CORE FIVE ─ always engage on every task ─────────────────────┐
│                                                               │
│   1. Architecture & Planning   │   architect, planner          │
│   2. Implementation & Build    │   build-resolvers, refactor   │
│   3. Quality & Review          │   code-reviewer, lang-revs    │
│   4. Security                  │   security-reviewer           │
│   5. Testing & QA              │   tdd-guide, e2e-runner       │
│                                                               │
└───────────────────────────────────────────────────────────────┘

┌─ EXTENDED ELEVEN ─ auto-fire on trigger rulesets ─────────────┐
│                                                               │
│    6. Compliance & Legal       │  PII, GDPR, CCPA, HIPAA, PCI │
│    7. Product, UX & CX         │  UI files, copy, a11y, i18n  │
│    8. Operations & Reliability │  runbooks, SLO, deploy, IaC  │
│    9. Data & Analytics         │  schema, events, ETL, PII    │
│   10. Finance & FinOps         │  pricing, cloud cost, ROI    │
│   11. Risk Management          │  blast radius, DR, destruct  │
│   12. Strategy & Innovation    │  new features, ADRs, vendors │
│   13. People & Culture         │  CODEOWNERS, onboarding, DX  │
│   14. Sustainability & ESG     │  carbon, supplier ethics     │
│   15. Ethics & Responsible AI  │  ML, LLM, bias, fairness     │
│   16. Communications & Docs    │  README, CHANGELOG, API docs │
│                                                               │
└───────────────────────────────────────────────────────────────┘

3. Veto authority is explicit

4. Verify-before-claim is the law

Every "done" / "shipped" / "complete" / "100%" phrase
MUST be preceded — in the same turn — by a verification action
that produced the evidence. The verification block IS the proof.
Claims without proof are downgraded to "implemented —
verification deferred to X" with a named unblock task.

5. Continuous learning is mandatory

Every Council-mediated task emits a learning candidate to
~/.claude/audits/learning-events.jsonl. Candidates that appear
in 2+ workspaces are eligible for promotion to global. Rules
contradicted ≥5 times in 30 days are flagged for refresh. The
system improves itself with every interaction.

What's in the box

Documentation map

Pick where to start based on what you want to do:

Cross-IDE support

The configuration is IDE-agnostic at the ~/.claude/ layer.
Bootstrap scripts auto-detect installed IDEs and provide opt-in
integration templates.

Per-IDE walkthroughs live in INSTALL.md.

With vs without

Verification status

═══════════════════════════════════════════════════════════════
       THE CLAUDE COUNCIL  ·  v1.1.0  ·  VERIFICATION BLOCK
═══════════════════════════════════════════════════════════════

  Floor rules ............................... 15 / 15    PASS
  Library rules (lazy-loaded) ............... 160 / 160  PASS
  Skills with paths: triggers ............... 36 / 121   ROUTED
  Skills (slash-command / by-name) .......... 85         PASS
  Skill -> rules-library cross-refs ......... 116 / 116  PASS
  Agents with complete frontmatter .......... 32 / 32    PASS
  Slash commands ............................ 33         PASS
  Hook scripts wired in settings.json ....... 14 / 14    PASS
  Broken cross-references ................... 0          PASS
  Workspace contamination in global ......... 0          PASS
  Council divisions ......................... 5 core + 11 extended

  Cold-load budget (Floor + CLAUDE.md) ...... ~240 KB    (was ~1.7 MB)
  Lazy-load surface (Library + Skills) ...... ~5.4 MB    on demand

═══════════════════════════════════════════════════════════════

Re-run any time with ./bootstrap/verify.sh --verbose.

Contributing

This repo is configuration for your Claude Code. Treat your
local clone as the source of truth, send PRs upstream when you
discover patterns worth sharing.

Adding a rule / skill / agent:

1. Read docs/CONTRIBUTING.md.
2. Author against the principal-level template.
3. Cite ≥3 standards matching the audit regex
   (RFC [0-9]+|ISO/IEC|NIST|OWASP|WCAG|W3C|§|PEP [0-9]+|SLSA|CWE|JEP|SE-[0-9]).
4. Add anti-patterns table + cross-references + verification checklist.
5. Run tests/verify-standards-citations.sh locally.
6. Send a PR — CI runs the three safety nets automatically.

The rule placement decision (global vs project) lives in
rules/common/rule-authoring-global-vs-project.md.

License and acknowledgements

Released under MIT. Use it personally, share with
your team, fork it for your org — no restrictions.

Built on top of Anthropic's Claude
Code. The Council protocol,
principal-level mandate, 16-division structure, and continuous
learning loop are documented in docs/ARCHITECTURE.md
and docs/COUNCIL.md.

The rules and skills cite primary-source standards from OWASP,
NIST, ISO, IEC, IEEE, W3C, IETF (RFCs), IFRS, FASB, ITIL, and
others — which remain the property of their respective standards
bodies. This repo is a configuration layer; it does not
redistribute or modify any standard.