10h (edited) • 📚 Resources & Finds
Final journey update part 3 peace out ✌️
BuilderCore Journey Update
Over the last few weeks, something interesting happened.
We weren’t just building an AI development platform.
We were discovering what an AI software factory actually needs before it can be trusted.
One of the biggest lessons was this:
Governance is more important than autonomy.
Everyone is racing to make AI agents that can do more.
We’re trying to make AI systems that can be trusted to do more.
Those are very different goals.
The first goal isn’t autonomy. It’s predictability.
Our first milestone wasn’t:
- autonomous coding
- autonomous deployment
- autonomous GitHub actions
It was proving that every stage of software delivery could be controlled, audited, replayed and stopped.
That meant proving things like:
- controlled apply
- replay workspaces
- validation
- queue promotion
- queue completion
before even thinking about autonomous execution.
That order matters.
We stopped treating AI like one assistant.
Instead, we started treating it like an organisation.
Not one intelligence.
A collection of specialised roles.
For example:
- Planner
- Hardener
- Researcher
- Implementer
- Reviewer
- Judge
- Operator
That immediately changed how we think about AI.
One of the strongest doctrines we’ve adopted:
The same AI should never judge its own work.
That now applies to:
- reviews
- validation
- judgement
If one model creates something…
A different one should evaluate it.
That’s closer to how healthy engineering teams actually work.
Roles are permanent. Models are replaceable.
This became one of the biggest architectural shifts.
Instead of designing around:
- GPT
- Claude
- Codex
- Perplexity
we design around roles.
Today GPT might be the planner.
Tomorrow another model might be better.
The workflow shouldn’t have to change because the underlying model changes.
We discovered evidence should change roadmaps.
Not doctrine.
This thread completely changed our roadmap.
Originally we planned to test vague briefs next.
Then we realised…
BuilderCore doesn’t yet formally know what workers exist.
So we changed the order.
Not because someone had a better opinion.
Because the evidence said another dependency came first.
That might sound small.
But it’s actually how engineering should work.
BuilderCore is becoming an operating system.
It isn’t just coordinating tickets anymore.
It’s gradually becoming responsible for:
- workflow
- governance
- routing
- validation
- evidence
- scheduling
- eventually resource allocation
The AI isn’t the operating system.
BuilderCore is.
The models become interchangeable components inside it.
ProductOpsCore taught us something important.
Ironically…
The product we spent weeks building isn’t the valuable part.
ProductOpsCore was a disposable test vehicle.
BuilderCore is the real product.
That mindset stopped us becoming attached to test projects.
Sometimes you build something valuable…
only to prove the system that built it.
Another principle emerged:
Move knowledge out of people’s heads and into the system.
If BuilderCore only knows which worker should review something because I remember…
Then BuilderCore doesn’t actually know.
That’s why the next dependency isn’t another experiment.
It’s a Worker Registry.
The system needs to understand:
- who can do what
- who cannot review whom
- fallback workers
- constraints
- routing rules
Only then is orchestration real.
The biggest lesson
Building AI isn’t the difficult part anymore.
Building trustworthy AI systems is.
Anyone can wire together models.
The harder problem is building a system where you can answer questions like:
- Why did this decision happen?
- Who reviewed it?
- What evidence exists?
- Can it be replayed?
- Can it be rolled back?
- Did the right AI make this decision?
That’s where I think the next generation of AI products will differentiate themselves.
Where we’re heading
The vision hasn’t changed.
BuilderCore isn’t being built to replace software engineers.
It’s being built to coordinate specialised AI workers under human governance.
The goal isn’t “AI builds software.”
The goal is:
An AI engineering organisation that behaves more like a disciplined software company than a collection of chatbots.
That’s the direction we’re continuing to prove, one capability at a time.
9
6 comments
Final journey update part 3 peace out ✌️
skool.com/cliefnotes
What we give away free beats most paid courses. Build durable AI systems with a Marine vet and Edinburgh researcher. 40+ lessons, growing.
Leaderboard (30-day)
1
🔥
+1729
2
🔥
+1649
3
+1325
4
+923
5
+613
Powered by