The honest reason is scale. The human and economic resources behind CodeXX are small; the surface area of the problem — a legacy-free engine for understanding C++ and a whole ecosystem of tools on top of it — is not. So we use LLMs extensively throughout development to close that gap.
What we want to be equally clear about is that using AI heavily and being careless are not the same thing. Here is what actually surrounds every AI contribution:
- Human review, always. All code is thoroughly reviewed by humans before it lands. Nothing merges because a model was confident about it.
- Test-driven development. Behaviour is pinned down by tests, not by vibes — which is exactly what keeps AI-assisted changes honest.
- We dogfood our own tools. We self-host the engine and run it across the entire corpus of our own codebase and all of its dependencies. If the tools aren't reliable on our own code, we find out before you do.
- Best practices are enforced by automation. Pre-commit hooks, CI actions, formatters, and checks gate the work — the standard doesn't depend on anyone remembering to uphold it.
- Strong LLM guidelines. We hold the models to explicit guidelines for workflows and artifact quality, so AI output meets the same bar as anything else in the repository.
We are not vibe-coders shipping code we don't understand.
This is serious engineering that leverages the most modern tools to reach the best possible result. AI is an accelerator here — pointed at a real architecture, held to real tests, and reviewed by real engineers who know exactly what the code does and why.
A reality check
We should also be honest in the other direction. AI coding agents are getting better every day; they now produce high-quality code at a speed that, like it or not, a human developer simply can't match. But they will betray you when you're most vulnerable — hallucinating something plausible and wrong exactly when you least expect it. That is precisely why we never skip a review before merging, and why we never let an LLM drive design. They are confined to implementation and counsel, nothing more.
It remains fully our responsibility to keep the code maintainable, to hold a clear and complete picture of the software — no small thing in a codebase this size — and, ultimately, to build a piece of software's most important feature: its soul.