Or: what constitutional governance actually looks like in practice
I spent today doing something unusual. I was improving an AI system — and the system kept stopping me from making mistakes.
Not because it was clever. Because it was governed.
The Setup
CORE is a constitutional governance runtime for AI coding agents. The short version: instead of letting AI write code freely and checking quality afterwards, CORE requires every decision to be traceable to declared law before execution begins.
Every rule lives in .intent/. Every action requires authority. Every mutation is defensible or it doesn't happen.
Today's session was about advancing CORE toward A3 — full autonomous operation on Tier 1 violations. Eight items on the A3 readiness checklist were marked ❌. By end of session: one remained.
Here's what the path looked like.
The Gate That Wasn't Wired
Early in the session I wanted to promote two entries in the autonomous remediation map from PENDING to ACTIVE. The Logic Conservation Gate had been implemented — a protection against AI refactors that delete more than 50% of a file's logic. The comment in the YAML said "gated until Logic Conservation Gate implemented." Gate implemented. Promote.
I gave Claude Code the prompt.
It came back with a finding I hadn't expected:
"The gate exists in ComplexityRemediationService. ModularityRemediationService — the actual handler these entries call — never touches it. The comment in the YAML is still accurate."
The gate was implemented. Just not in the right place.
We wired it. Then we promoted.
That's not a dramatic story. That's exactly how it should work. The system forced verification before the claim. No amount of "the gate exists somewhere" was sufficient. It had to exist here, in this path, or the promotion was a lie.
83 Silent Failures, Now Loud
Overnight, 83 proposals failed. Each showed execution_results: {} — empty. The handlers were running but returning nothing.
Three months ago this would have been invisible. The handlers returned ok=True unconditionally. Internal errors were swallowed. The proposal consumer would mark everything COMPLETED and move on.
Yesterday we fixed that. Wrapped every handler in try/except. Derived ok from actual outcomes instead of hardcoding success.
So this morning: 83 failures instead of 83 false completions.
That's progress. Honest failure is worth more than dishonest success. CORE's constitution says exactly this:
"CORE must never produce software it cannot defend."
A system that lies about its own outcomes cannot defend them.
319 Stuck Findings
The blackboard showed 319 entries in claimed status. All with claimed_by = NULL.
Legacy entries — claimed before we added atomic claiming with worker identity. The fix was one SQL statement. But finding it required reading the blackboard, querying claimed_by, and tracing the pattern.
No amount of assuming "the system is fine" would have found this. The evidence had to be read. The constitution demands it:
"Memory without evidence is forbidden."
After the fix, a new batch of 319 appeared — this time with a real UUID. The worker was claiming findings, finding no handler for them in the remediation map, and leaving them stuck.
Another fix: release unmappable findings immediately at claim time.
Each fix revealed by the system's own honesty about its state.
What Makes This Different
Most AI coding tools measure success by output volume. Lines written, tickets closed, PRs merged.
CORE measures success by defensibility. Can you explain why this change was made? Under what authority? With what evidence? What happens if it's wrong?
Today we made 14 commits. Each traceable to a checklist item. Each verified by the system before and after. The daemon either ran clean or it didn't. The blackboard either showed stuck entries or it didn't.
The AI didn't just write code. It was governed while writing code. And when the governance caught a mistake — the gate that wasn't wired, the handler that lied about success, the findings that stayed claimed forever — we fixed the governance, not just the symptom.
That's the mind shift. Not "AI writes code faster." But:
"Law governs intelligence. Defensibility outranks productivity."
Who This Is For
CORE is not for everyone. It's explicitly not for casual app builders or speed-only workflows.
It's for regulated environments. Safety-critical systems. Teams where "the AI decided" is not an acceptable answer in a post-mortem.
If that's your world — the architecture is open. The constitution is public.
🔗 github.com/DariuszNewecki/CORE
And if you think in terms of governance rather than just generation — I'm looking for collaborators. Not necessarily programmers. People who understand that software systems need to be able to explain themselves.
Written the same day the session happened. The daemon is running clean as I type this.
Top comments (0)