The Starting Point
A solo-built computer algebra system, developed with AI agents
Gauss is a computer algebra system — symbolic integration, number theory, PDEs, statistics, optimization and roughly 45 more mathematical domains — that I built solo by orchestrating AI coding agents. I wrote almost none of the implementation by hand: about 2,563 commits were authored by agents against about 330 by me, roughly 1,721 of them in a single 60-day stretch. The agents did the typing; my job was everything else. This case study is deliberately not a success story about AI writing software. It is a record of what agent orchestration produces at this scale — including the wrong answers that shipped with passing tests, and what it took to catch them.
Proof
The verified figures
It genuinely works, verified in a live REPL: symbolic integration with real Risch and Meijer-G machinery (∫eˣ/x = Ei(x), ∫e^(−x²) = ½√π·erf(x)), symbolic summation (Σ1/k² → π²/6), Gruntz limits, and exact radical solutions (x²−2 solves to √2, not a float). Don't take my word for it — the demo is the actual system, running live.
Human Contribution
What the agents could not supply
- Architecture: I set the global structure, module boundaries and cross-cutting conventions — agents implement within an architecture, they don't create or defend one.
- Scope: I decided what not to build and which technical debt to take on deliberately — and when to pay it back.
- Agent coordination: I ran the agents across sessions and models, routing each problem to the system best suited to it.
- Verification: I built the external verification harness and ran the soundness sweeps that caught the failures below.
- Integration: I kept ~50 domains coherent as one system — resolving collisions, consolidating duplication, defending the boundaries.
Where It Broke
Three documented failure cases — shipped, tested, wrong
Soundness sweeps repeatedly found wrong-answer bugs in code that was shipped and had passing tests. These three are documented in detail because they show how agent-written code fails: plausibly, quietly, and with the test suite agreeing.
The agents implemented SDIRK and ESDIRK ODE solvers whose Butcher tableaux violated a basic consistency condition: the weights did not sum to 1. The solvers ran without complaint and returned results that were 25–44% off. The code was shipped with passing tests. A soundness sweep checking the tableaux directly against the consistency condition caught it — the tests never had.
The coding-theory module shipped decoders that never actually corrected errors — the one thing an error-correcting decoder exists to do. The APIs looked complete and the accompanying tests passed, because nothing in them exercised the error-correction path. Every surface signal said "done"; the core behavior was absent.
Behind both cases sits the same pattern: many agent-written tests asserted structure rather than values — that a result came back with the right shape, not that it was correct. Tests like that pass around a bug. Breadth outran verification: agents added new domains faster than the checks could keep up. The fix was an external, self-built differential-fuzz harness that checks results independently instead of trusting a module's own tests.
Transferable Lessons
What this means for your team
- Agent velocity creates big-team problems without the team. Agentic coding gave one person a big-team-sized codebase overnight — and the build, test and coherence problems that normally come with a big team.
- Architecture is the layer you must supply and defend. Agents implement within a structure but can't create one; relax your guard and entropy wins faster than in a human team, because the velocity is higher.
- Verification must be independent of the agents. Don't let agent-written tests establish correctness — they tend to assert structure, not values. Correctness needs an external check the agents can't satisfy by accident.
Next Step
Talk About Your Agentic Engineering Setup
Working with AI agents at scale — or trying to introduce them safely? Let's examine where architecture, verification, and workflow controls are currently limiting your team.