DeepOntology
If you are working in a domain of knowledge, how can you possibly operate without ontology?)
If you use an object-oriented programming language and create a class, you're doing ontology.
If you are using a relational database and you create a schema, you're doing ontology.
If you choose to use an object-oriented programming language or a functional programming language, you're doing ontology.
1. No pull requests 2. I have separate strategy, code-writing, and commit agents 3. A reader that never saw the builder's reasoning checks each fix first 4. Full test run must be green on the exact commit 5. Verification / feature walk on staging
On the app I'm building (and its platform dependencies) I've made it through ~1200 commits and ~300k LOC without more than an occasional trivial regression/having to roll back... so, I think my strategy is working.
There are many ways that I think what we are currently referring to as "AI" is disrupting existing relationships in society.
To the extent that that disruption is forced by external, pointed, injection of capital (e.g. russian bot farms, heritage foundation bots, etc.), it's pernicious. It has undoubtedly made those bad actors more powerful.
But, to the extent that that disruption is the result of asymmetrical power relationships (e.g. the outsized influence that publishers have), I think it's welcome.
I know who writes the things I read (because almost everything I read is over a thousand years old! but, that's beside the point...) because it's important to me to know who I am connecting to through the written word. I doubt my relationship to writing will ever be disrupted by AI because it's so important to me to know the history of the people whose ideas I'm consuming.
How do you keep your guidance tied to versions of your frameworks/dependencies?
0. Use Fable 5.2 on max (or whatever the most powerful model + effort you have access to) for all strategy, design, and planning (since good reasoning at higher levels of abstraction always pays off when it comes to implementation)
1. Use Opus 5.5 sub-agents for implementation, and have the Fable "drivers" break work into lanes.
2. Only build when there's an explicit "go" on a written plan.
3. About 1x/week do a broad, high-dimensional analysis of the codebase (tech debt, test coverage, security, performance, etc. etc.) and have judge agents vote on priority --> fix the P0s and P1s and a random small subset of P2s.
4. Test coverage > 90% and set up CI to reject changes which drop it below 90%.
5. Have every agent create a numbered guide for verification which you walk on staging (or locally, if early in your development process).
6. Antagonistic & hyper-critical agents -- whenever you make a change spin up a small number of Opus 5.5 agents to review everything from an antagonistic/hyper-critical lens -- this catches a lot.
7. Make a list of principles and make every agent read the principles before every change. Principles only get added + refined. Whenever an agent doesn't know what to do, ask if it can figure it out from the principles -- if not, walk the agent through it + then have it add the appropriate principle. This leads to convergent implementations at an abstract level, over time.
---
Using these tips I've developed bug-free code bases over 100k LOC in ~weeks.