I have no programming background. I've never written production code. I am, by training and profession, a Quality Manager — someone who thinks in terms of rules, audits, violations, and the gap between what a system is supposed to do and what it actually does.
Last week I checked the CORE repository: 1,022 source files. A constitutional governance runtime for autonomous AI systems — audit engines, remediation workers, a blackboard communication layer, a constitutional rule enforcement pipeline, a sandboxed execution environment. Running in production. Governing itself.
I wrote none of it. Not a single line of code. Not a single governance file. Not a single architectural document.
My only tool was questions.
Here's what I want to be careful about: this is not a productivity story. I'm not going to tell you "I used AI to write code faster." That's true but it's the least interesting thing about what happened.
The interesting thing is what had to exist before the AI could write anything trustworthy at all.
The question nobody was asking
When everyone started talking about AI-assisted development, the conversation was about speed. How fast can it generate? How much context can it hold? How good is the autocomplete?
I came at it from a different angle, because I don't think about speed. I think about correctness, traceability, and what happens when something goes wrong.
My question wasn't "can AI write code?" Code generation is solved. The models are good enough. My question was: who decides what's correct?
In a traditional development team, that accountability is distributed across code review, tests, CI, and the implicit knowledge of the developers themselves. When an AI generates the code, that entire structure has to be redesigned from scratch. The AI doesn't know what's correct — it knows what's plausible. Those are dangerously different things.
What I actually contributed before any code existed
A concept. Held precisely enough, questioned relentlessly enough, that the AI could translate it into architecture.
CORE has a directory called .intent/ — governance law as data. YAML and JSON files defining constitutional rules, enforcement policies, worker schedules, authority chains. I didn't write those files. The AI did. What I contributed was the thinking behind them: asking what "correct" meant, what "violation" meant, what the system must never be able to do — and pushing until the answers were exact enough to become rules.
The AI cannot touch .intent/. Not by convention or request. By architectural invariant. The execution arm implements what the constitution says. The governor — me — holds the concept. The AI translates it into every artifact: the code, the governance files, the architectural documents. Everything.
That separation is what made trustworthy software possible without any traditional authorship. Not because AI got smarter. Because the architecture was designed so the AI's job was clearly bounded: implement what the concept specifies, surface violations rather than hiding them, and never touch the layer that defines what correct means.
The pattern: governor and execution arm
What I stumbled into, and then deliberately designed, is a split that I think applies to anyone building with AI:
The governor writes the rules. The execution arm implements them. The execution arm cannot modify the rules.
This sounds obvious until you realize almost nobody enforces it structurally. Most AI-assisted development setups let the AI propose anything — including changes to the constraints themselves. That's a governance failure waiting to happen, not because the AI is malicious, but because an agent that can rewrite the rules it's evaluated against can always pass. The violation simply disappears from the record.
In CORE, the constitutional layer is outside the AI's mutation surface. The AI proposes changes to src/. It cannot propose changes to .intent/. The governor reviews and applies intent changes. The AI implements. Violations surface to a blackboard. Workers remediate. The cycle runs autonomously, but within a frame the AI cannot reshape.
What changed when I stopped thinking about code
Here's the shift that made this possible without a programming background:
I stopped asking "how do I write this?" and started asking "how do I specify what correct looks like?"
Those are completely different questions, and the second one is the one I was trained to answer. Quality management is the discipline of defining correctness before production, detecting deviation in real time, and closing the gap systematically. Constitutional AI governance is the same discipline applied to a different domain. The vocabulary changed. The thinking didn't.
I didn't need to write the rules. I needed to know them well enough that an AI could write them correctly and I could tell when it hadn't. That's a different skill — and it turns out it's the scarce one.
The code is the easy part now. Models can write code. What they can't do is define what the code is supposed to achieve, decide which violations are blocking versus advisory, or make judgment calls about scope and consequence that the architecture depends on. That's the governor's job. That's the human's job.
What this means if you can code
If you're a developer building AI-assisted systems, I think there's a useful reframe here.
Your value is no longer in the typing. It was never really in the typing, but now that's undeniable. Your value is in the specification — in writing the constitution so precisely that the AI's implementation can be evaluated against it.
The developers I've seen struggle with AI-assisted development are trying to use AI as a faster version of themselves: same workflow, same thinking, just with autocomplete. The ones who find real leverage write the spec clearly enough that the AI can implement it correctly, and build the evaluation layer that catches it when it doesn't.
Governance expertise is the bottleneck. Not code generation.
The receipts
CORE is open source. The constitutional rules, enforcement invariants, and governance architecture all live in the repo. The audit engine governs itself. The autonomous daemon runs in production, proposes fixes, executes them under human review — and cannot touch the constitution that defines what correct means.
Built by a Quality Manager who didn't write the code, didn't write the governance files, didn't write the architectural documents. Asked questions until the answers were precise enough to become a system.
If you're building AI systems and haven't drawn the line yet — the line the AI must never be able to cross — this is one answer to what that looks like in practice.
github.com/DariuszNewecki/CORE
I am a Quality Manager building CORE, an open-source constitutional governance runtime for autonomous AI systems.
Top comments (0)