I spent my Sunday not writing a single line of code.
It was the most productive day I've had in months.
A bit of honest backstory
I am not a programmer. I'm more of an architect. Maybe a philosopher who ended up with a codebase.
I built CORE because I got angry. Angry at LLMs that hallucinate. Angry at context drift. Angry at tools that produce output nobody can defend. I wasn't trying to disrupt an industry — I was trying to solve my own problem.
I built it for myself. On a server called lira. In Antwerp. With PostgreSQL and local embeddings because I couldn't afford to throw GPU clusters at the problem.
Necessity is the best creativity source. Eastern Europe will teach you that.
Somewhere along the way the thing I built for myself started looking like something real. Something that might matter beyond my own island.
But today I realised something uncomfortable.
CORE demands something from every project it touches
CORE has a rule. Actually, it's stronger than a rule — it's a constitutional requirement:
Constitution before code. Always.
When CORE encounters a repository — whether it's a half-finished mess or a five-million line enterprise codebase — it doesn't start writing. It starts understanding. It maps. It asks. It surfaces contradictions. It refuses to proceed on guesswork.
And before any implementation begins, CORE produces a constitution for the target system. A .intent/ directory. A set of requirements. A statement of what the software must do and why.
CORE will not write a single line until that exists.
I wrote this rule. I enforce this rule. I believe in this rule deeply enough to build an entire governance system around it.
So guess what I had never written for CORE itself.
Yeah.
CORE had a NorthStar document — a philosophical manifesto about why it exists, what it believes, what it will never do. Beautiful document. I'm proud of it.
But a User Requirements document? Stating concretely what CORE must deliver to a user?
Not written.
I had been violating my own constitution. Quietly. For months.
How I finally got there
It didn't happen the way I expected.
I wasn't sitting at a desk with a blank document thinking "right, requirements time." I was having a conversation. A rambling, honest, philosophical Sunday conversation about CORE, about the industry, about building things on a shoestring from Eastern Europe, about my mother telling me decades ago that she couldn't follow what I was thinking.
And somewhere in that conversation, someone asked: "If a stranger landed on your GitHub right now, what would they understand in three seconds?"
I had to think about it.
The answer, when it came, was embarrassingly simple:
A thing that uses AI to write perfect applications.
Seven words. Obvious. To me. Completely invisible to everyone else because I had been leading with the architecture instead of the purpose.
My mother would have told you the same thing. She did, in fact. Many times.
Writing the requirements properly
Once I started actually articulating requirements — not philosophy, not principles, but obligations — eight of them emerged:
UR-01: Universal Input Acceptance
CORE accepts anything. Conversation. Spec. Single file. Enormous repository. No assumptions about quality or structure.
UR-02: Comprehension Before Action
CORE must be able to say "I know what this does and I understand it" — backed by evidence — before taking any action. Not assumed. Earned and declared.
UR-03: Gap and Contradiction Reporting
CORE asks when things are missing. CORE stops when things contradict. CORE never guesses.
UR-04: Constitution Before Code
The target system's .intent/ is CORE's first deliverable. Not a byproduct. A precondition. Implementation without an established constitution is malpractice.
UR-05: Output is Working Software
Working means: satisfies the stated requirements. Stack is the user's choice. Perfection is a quality indicator, not a deliverable. Correctness against declared intent is the only measure.
UR-06: Continuous Constitutional Governance
CORE does not distinguish between "build" and "maintain." That's an industry distinction — two teams, two budgets, two problems. CORE asks one question continuously: does this satisfy what you said you wanted?
UR-07: Defensibility is Non-Negotiable
Every output traces to a requirement, a rule, or an explicit human decision. If none exist, CORE stops and asks. CORE never produces software it cannot defend — technically, legally, epistemically, historically.
UR-08: Judgement Belongs to the Human
CORE enforces coherence, not morality. What the software is for is the user's responsibility. CORE flags contradictions. CORE surfaces missing decisions. CORE does not judge purpose.
Where does the document live?
This is the part that made me genuinely happy.
The answer was obvious. It could only go in one place: .intent/northstar/
Not constitution/ — it's not a foundational principle.
Not papers/ — it's not philosophy.
Not rules/ — it's not enforcement law.
northstar/ — because the User Requirements document is the NorthStar made concrete. Same authority. Same scope. Same rule: human-authored, runtime-immutable. CORE can read it. Reason from it. Vector-search it for context. Never touch it.
When your architecture tells you where something belongs without you having to think about it — that's good constitutional design.
The irony isn't lost on me
CORE demands constitution before code from every project it touches.
Today its own author finally wrote the requirements document that should have anchored CORE's own constitution from the beginning.
I was the user. The conversation was CORE. Messy, human, philosophical input went in. Precise, defensible, constitutionally-placed output came out.
No code written. Real progress made.
The governing invariant
All eight requirements trace back to one line, declared in the NorthStar:
CORE must never produce software it cannot defend.
Not defend emotionally. Not defend rhetorically.
Defend technically, legally, epistemically, and historically.
Everything else is a consequence of that one sentence.
If any of this resonates — or if you want to tell me I'm doing it wrong — the repo is at github.com/DariuszNewecki/CORE.
CORE is picky. CORE is honest. CORE is written to survive audits, post-mortems, and time.
If that makes it unsuitable for most people, so be it.
I did not build CORE to be liked. I built it to be right.
Top comments (0)