One month without AI

Oof reading this was definitely a punch in the gut. I've had the same feeling myself, but kept shuffling along because I thought I needed to in order to keep up with my peers. Then someone mentioned the slop I had been producing in a more direct way and that I need not feel so rushed. Since then I've been slowly trying to do an AI detox (still ask AI questions when I get stuck, but write the code myself).

The loudest voices in the tech discourse right now generally argue for software engineering to be either dead or have mutated to something completely different where almost none of the old skills transfers, because now you have to be a designer and the small details don't matter anymore.

Except that every designer worth their salt knows that understanding the small details is a necessary step towards mastering the big picture, and in fact this part is often left unspecified by the techfluencers (how do you become good at design in the first place? certainly not by delegating most decision-making to an LLM).

The big picture (i.e. making software you can love) is what we've been always after in the Zig community, which is why we do things like https://kristoff.it/blog/the-zig-journey/.

In other words my point is that trying to stay one month without AI can do you some good, but IMO the best approach is to have a holistic view of your learning process that doesn't put learning entirely on pause until you take another break from LLMs.

This was always important, but it's even more important now because the software engineering "middle-class" is shrinking and if you don't gain any special insight on how to make excellent quality software, then you are more likely to land in the meat proxy job bucket, from which is going to be increasingly harder to get out as the job market adapts.

A piece of advice Say no to drugs. Kind of a metaphor, but not quite.

I was reaching for the same metaphor, but for a different reason. Certain types of people definitely should not do drugs, because they will do them to excess once they start, going past any lines they would have initially set themselves. Similarly it seems like this person found LLM usage addictive, and went past lines they would have initially set for themselves. If that's you, abstinence is absolutely the right approach.

But I don't actually think that experience is universal. Like:

Of course, I didn’t write the commits or the PR descriptions myself (what is this, 2024??), AI was doing it for me, and it made sure there was a 7-paragraph description in the PR, explaining what it had done. I stopped reading those descriptions, like, I told it what to do, I assume it did what I said. The description is for others. Because there has to be a description, right? AI is so fucking good as sounding professional, that you relax and let it be. It’s not that I actually thought the code was good, but you get convinced over time, you get lazy, you become complacent. You stop questioning, and start accepting as good some code you would have never accepted, just because you cannot tell why it’s bad. You have lost control. Most AI developers will deny it, but deep inside, they know it’s true. Just don’t want to face it.

This does not describe my experience. I have never had an AI write a commit message for code I was submitting to someone else. I have never had an AI write a PR description even for code where I'm the sole maintainer. It is not inevitable that you lower your standards and cross your own lines. You have agency here.

This reads a little bit like a former alcoholic explaining how you should avoid drinking because you inevitably start blacking out and driving home drunk. Certainly that does happen, and is very bad, and is something you should be aware of before you start. But it's not actually an inevitable consequence of having a drink.

(It's not a perfect metaphor for obvious reasons.)

I went back to TDD, to my PRs with just 5 files changed. To my 2-line PR descriptions that were straight to the point. I went back to understanding what I was doing, to deploying with confidence, to being ready for a detailed code review, because I knew what the changes were doing, and I could justify every line of code. I went back to enjoying human code reviews (not AI-ones, I still hate those. Even more humans that paste AI reviews pretending they are their own), to learning from them. I started asking about architectural decisions, why things were a certain way.

The loss of all this is a common theme I'm seeing in the industry and one I am grateful my team has not lost. We use AI to output the code (with human adjustments here and there, but we mostly steer). We have empathy for the human reviewer on the other side and deliver well thought out PRs. We use LLMs to further enhance the PR descriptions with Mermaid diagrams demonstrating the place of that component in the architecture or a flow, but otherwise write every commit message ourselves. We use AI review to catch security concerns and the edge cases humans typically seem to omit, but we still have humans reading each line of code and questioning the bigger architectural understanding. All of our specifications are human written. Most importantly, we all understand the code we're shipping and we feel a strong accountability to it.

I feel we've hit the sweet spot where we're leveraging LLMs to deliver more robust software. Yeah, we're still tired just as everyone in this industry is (no more quiet days crafting code; always focusing on the hard problems), but I'm grateful we have a team that understands that humans still matter.

the descriped journey of coding with ai and finally the decision to not use ai at all are so stereotypical/extreme/final, it sounds like the guy i make up in my head, when i try to describe what happens when you vibecode do agentic development.

it did, however nicely encapsulate the entire experiance and was easily digestible, so props.

What I loved about this article was that it didn't declare a war against anything modern, which many similarly-titled posts do. The invitation worked better than any aggressive conclusion IMO.

However, I'm not sure if I've felt all of this myself. I use AI for certain projects (those that I hate interacting with, e.g. anything with JS), agents do suck. But I can feel they're getting better (at least for now), and I've always managed to get the work done.

Maybe I haven't reached the overdose level yet, I don't know. I like the idea of such arguments, but I've failed to establish a meaningful relationship with them yet.