AI, Velocity, and Trust
On AI velocity, losing the plot, and the trust levels I am using to earn back my own codebase.
Like many developers, I’ve been struggling with the best way to use LLMs. On one hand, I truly believe that the best developers’ skill sets never lay in their ability to type keywords into a text editor. On the other hand, the farther I get away from the code, the less I feel attached to, or even understand, what’s going on under the hood.
I’ve been working on what is now called Bytes and Brains for several years, off and on. It’s seen many iterations, some of which had friends working beside me who have since moved on. I get busy with work, other projects, and real life, and the idea and codebase get sidelined. My day job at a large unnamed tech company has been forcing us to use these tools. I work in system-level software as part of my day job and was skeptical at first of these tools’ abilities to grasp concepts like memory hierarchy, threading models, computer architecture, lower-level networking concepts, etc. However, if I watched it closely, shoved my OCD for code style way down (I mean really way down), and helped it along with the system architecture, it seemed to be doing things well. As Mrs. Nancy used to say, this was the gateway drug. Every PR accelerated my adoption and comfort with the idea of, “Hey, why waste time?” and it was addictive. There is something so satisfying about being able to see something that would have taken me months before to code across multiple SoCs with different runtime environments, integrate with a cloud service, integrate with the NDK, and see it all coming together so quickly (at least on the surface). In my mind, it seems to induce a kind of mania. I.e., everything seems like a good idea, I can do it quickly, no one can tell me I can’t, I have the resources, I have the time. But… take a pause, slow down, look at the code underneath. Perhaps that OCD that was developed over years was there for a reason. Did it really implement what you think it did? How can you know?
During the ramp-up of this induced mania, I finished another project, which I hope to share soon. Thankfully, that was taken on and all the core software was meticulously designed, crafted, and then refined through strict performance requirements, but it led immediately into this, what is now Bytes and Brains. This was the logical progression for me, as the two ideas fit naturally together, and I already knew exactly what I wanted to build. From all the previous attempts over the last three years of picking this project up, I had the architecture. I’ve read most of the literature up to 2025 and can start to pick it back up. All I need to do is hand this over to Claude, right? I was off to the races. I made the core code, I made docs, I was planning expansions before the core was even stable. Documentation wasn’t rotting before it even saw a published version. But it looked like it was working. FINALLY, this thing that I wanted so badly for myself. I want to be able to take these papers, see them work on devices, and try them quickly. It always felt just out of reach for me.
Then I posted on Reddit. r/rust. Reality set in. Don’t get me wrong, they are a bit o a cult, really all of reddit (I guess that makes me a willing member). If LLMs are involved, they will detest what you are making. That is not my position. However, their ruthlessness, calling my baby, the thing I had wanted to make for years, “slop.” hurt. I had to step away from my computer for a day or two. I texted one of the guys that was working on it with me years ago, and while much more sympathetic than Reddit, he echoed a thought.
“How much did you use it?”
“Everything you offload, you lose control over.”
He was trying to let me down easy, I suppose.
So now I’m here. I’m now working on the 0.4.0 release. I’m calling it the great cleanup. I turned my OCD back on and revisited the code. Muddled abstractions. Dependency inversions. It seems that at some point the plot was lost, but I was too obsessed with seeing it done that I forgot to see it done right. My focus in the coming weeks is to revise the core framework, ensure that the core data structures and abstractions are there, and that the core of the framework is clean, well thought out, and easy to reason about, with each part being logical. I.e., my philosophy is that you should be able to look at a module and say, “This does this,” and with sufficient knowledge of the project, that feels like the natural way to do it, with clean ownership of an abstraction or job. This is, of course, subjective, but it will be to my subjectivity rather than Claude’s.
Finally, this is not me swearing off LLMs. The website is pure vibes with feedback. The patch notes mostly vibes from git log: I don’t want to deal with that. I want to reel in the “AI psychosis.” Once the core is stable and settled, building things around this with AI makes perfect sense. Moving forward, what I’m going to do is mark modules with trust levels.
- T0: meaning zero AI was used here.
- the kernel, core abstractions, and compiler
- T1: AI was used with heavy supervision or as a reference.
- T2: AI was used, and every line of code was reviewed.
- T3: I give it a vision, and I let it run.