The student in the room
We do not believe AI-assisted development is wrong. We believe it has been deployed as a substitute for understanding instead of an amplifier of it. The result is a generation of engineers fluent in prompting and illiterate in principles — capable of producing code they cannot defend, debug, or evolve.
daitai is, in part, a textbook disguised as a framework. The language has no null because nullability is a billion-dollar mistake. It has no exceptions because non-local control flow is how production systems become unreasonable. It has bra-ket primitives because quantum reasoning is not exotic — it is a clean algebra that every student deserves access to. Every choice in the language is a quiet argument for why.
If a single university course adopts daitai and a hundred students learn to think in State × Event → State instead of useState, that is worth more to us than any market share.
Three commitments
- Rigor
- Every primitive is defined by an algebraic law. Every state transition is a pure function. Every component file is structured by separation of concerns enforced at the file level, not by convention. We do not ask you to trust us — we ask you to verify.
- Determinism
- Same input, same output. Always. Across runs, across machines, across years. This is not a performance optimization. It is the precondition for software you can audit, prove, ship to a regulator, run inside a hospital, or trust with money. The world's hardest problems run on deterministic systems. The rest is convenience.
- Responsibility
- When code makes a decision that affects a human life — a diagnosis, a loan, a sentencing recommendation, an aircraft control surface — the people responsible for that code must be able to show their work. CGF, our compliance graph format, makes that showing cryptographic. Sign your compliance the way you sign your code.
What this is not
This is not an attack on React, on TypeScript, on AI coding assistants, or on any other tool. Most of us use them. They are remarkable. They are also, in their current form, an answer to the wrong question — how do I produce code faster? — when the harder and more honest question is how do I produce code that I can defend?
This is not a manifesto written from the comfort of an academic chair. The same algebra that defines Step(q, L, η) runs inside a working IDE, a working language, and a working compliance pipeline today. The point of daitai is not to argue. The point is to demonstrate.
What this is
daitai is an example. A working one. A claim, made in running code, that you can have determinism and developer ergonomics, mathematical rigor and a beautiful editor, formal compliance and shipping velocity. That you do not have to choose between speed and seriousness.
If we are right, the next decade of software in medicine, finance, infrastructure, and AI safety will look less like glorified Stack Overflow and more like engineering. We would like to be a small part of why.
Where algebra meets alignment.