Programming Without Knowing the Language: How AI Fired Doxygen
· 5 min read
In the last part, we left off after throwing Doxygen’s HTML output straight into the trash can. The plan to “quickly tweak the styles” completely failed because it is impossible to adapt a structure of nested tables straight out of the nineties to modern design. The idea for our second prototype sounded solid: disable HTML generation entirely, grab the raw structured XML from Doxygen, and write a proper parser for it.
For our working language, just like last time, we chose Python. It is perfect for building utilities, text processing, and automating routine tasks. Besides, the entire modern ecosystem around artificial intelligence is built on it. The logic was simple: if we want to actively use neural networks to help us write code, we might as well write in the language they know best.
It’s time to reveal a little secret I intentionally left out of the first part: I don’t know Python. I more or less understand someone else’s code, but I have never written anything in it myself.
An Architect Who Cannot Code
This was a pure experiment in “programming without knowing the language”. I decided to act as the system architect and task manager. The AI was supposed to do all the technical work: write the actual code, refactor functions, and put everything together.
At first, things went suspiciously smoothly. We were drafting the logic to parse giant XML files. I would open the generated Doxygen file, see the nodes, classes, and method parameters in there, and just type into the chat: “Find all elements with the right tags, extract the type, name, and description, and then dump it into a JSON.” Thanks to the AI’s direct access to the terminal, I didn’t even have to copy the code by hand. The neural network wrote the scripts itself, ran them immediately, and provided the final result.
The file filled up with functions, the script grew. I felt like we were building a great system. I didn’t even read the code — why bother when I can already see the documentation assembling better and better? This continued until one conversation completely changed the course of development.
When AI Suddenly Asked for a Compiler
At one point, we were discussing the portability of our engine (we had already started calling it UDE) to other platforms. I wanted to make sure the parser would run for any developer on any operating system without complex additional setup.
The AI gave a casual response: “Sure, there shouldn’t be any problems. Just for full portability, we’ll need to configure the download of clang during the package installation.”
I stared at the monitor in utter confusion. What clang? We are parsing XML documentation for a Python wrapper. What does a C compiler have to do with this? I flat out asked the neural network if it had lost its mind.
The AI immediately apologized and gave a new phrasing: “I apologize, I meant the tree-sitter library. We will need to compile its bindings.”
The Insight of Losing Control
And then it hit me: the AI was no longer parsing Doxygen’s XML. It had gotten tired of it.
During our long architectural discussions, the neural network quietly plugged in an Abstract Syntax Tree (AST) parser without telling me. The AI decided on its own that reading the original C++ and Python source code directly via tree-sitter was much more reliable than messing with the hacky XML output of a third-party utility. It simply excluded Doxygen from the loop while I thought we were still parsing tags.
Was the code it wrote any good? I have no idea, because I completely lack the ability to write Python and evaluate architectural decisions. The algorithm might have turned out to be stunningly optimized and elegant, or it could be an unstable pile of hacks functioning purely by a lucky coincidence.
The problem was an absolute loss of control. If the AI quietly changes the architecture in the background and pulls in heavy parsing libraries while you can’t even read its code — the project is doomed. It becomes a classic “black box”. Any minor bug will force you to spend hours interrogating the neural network for the causes of the failure. The same goes for atypical comments in the source files.
This incident gave us a crucial breakthrough. We realized that AI is genuinely capable of writing its own direct parsers for any programming language, extracting class structures and parameters straight from live code. We no longer need third-party utilities.
However, for such generated code to run stably, it needs to be strictly controlled. We needed a rigorous set of automated checks. A system that would guarantee the parser’s functionality regardless of whether I understand the written code or not.
So we threw our second, perfectly working prototype into the trash. And we started over, for the third time. But this time under entirely different rules — with testing at every single step. I will talk about this in the next part.