AI Will Make You Dumber (if You Let It)

It’s commonly agreed upon that you can’t unlearn swimming or riding a bicycle. Once learned, the movements are burned deep into the muscle memory.

That’s not entirely true for skills that are “brain heavy” with little muscle movement involved. Learning languages is such a skill. If you don’t practice speaking a language you learned, you’ll lose it.

Skills aren’t forever

I experienced this when we planned to take our little ones to Corsica for vacation. Having learned French at school as the second language (besides English), I thought, “well, I’ll buy a refresher course that will bring me back into the language quickly.” A beginners course deemed utterly boring. Boy, was I wrong! I put the CD into the player (yes, in the 2000s, these discs were quite popular), started listening to the first lesson… and I didn’t understand anything. Instantly, I realized I bought the wrong course, and I got one of those beginners courses that teach you enough broken French to get you through your visit. (If the phrase “pardon my French” wasn’t already taken, I would have said it before every French sentence I had to utter.)

The saying is so true: Use it or lose it.

Now transpose this to even more abstract skills like software development. Not only do you have to be fluent in at least one programming language; you also need to understand, and be able to apply, wagonloads of computer science’s theories: algorithms, data structures, relational databases, graph databases, Big-O, P versus NP, numerical mathematics, various models of concurrent and distributed programming, and so on and so forth.

If you’re an experienced developer, you probably have nodded along when reading this list. (If you’re just starting into software development, that’s a glimpse of what you’ll be learning along your journey.) Software development done right requires having a broad range of skills and the ability to apply them in the right way.

And you have to keep your skills active. Even if you’re a senior developer who delegates tasks to juniors, you still have to review their PRs, judge their work, and help them in becoming better. Only those who change into management can afford to gradually lose their technical abilities: They aren’t required anymore to know all the details about the software being produced; their job is to support those who do.

And now comes AI

As LLMs are getting better and better at writing software, it’s like everyone has now a tireless junior programmer at their disposal. Delegating the boring parts to a bot can feel liberating (believe me, I’ve tried it): You just need to explain what you want to have, and the bot goes pottering around for a few minutes and delivers a ready-to-merge PR. You can review it or have another bot review it for you. The amount of PRs an AI is able to produce within a short time may push you towards the latter, sooner or later.

And suddenly, your brain is no longer involved in the part of the development process.

Like a developer who got promoted into management, your programming skills slowly degrade. You mutate from an active developer to a mere bystander.

Train your brain

I want to be clear: If your plan is to do less development and more planning, managing, or customer communication, letting some skills fade away is a legitimate way to open your brain to acquire new skills. As I said earlier, it can be liberating to boss the clankers around. But remember you still own the outcome. If you want to remain able to reason about LLM-generated code and steer LLM output into the right directions, honing your development skills pays off.

How to fight brain rot? By training, of course. As with fitness training, you have to block time to work on code without AI.

Here are some tips to get started:

Structure your project work into “heavy” and “volume” days

Extract the difficult parts of the project and assign them to yourself. Work on them without AI help, or let the AI in only after you’re finished. Wrap your brains around the problem until you have understood it well, then come up with, and implement, the solution. These are the “hard” days, and they are intentionally hard to have a learning effect. After all, you don’t go to the gym and let a bot lift the weights for you, do you?

During the “volume” days, let the bots crunch through the boring parts. Throughput is relevant for every project, after all. Letting the bots do the easy, boring parts saves time and bears less risk of receiving bad bot code. (Bad code costs more time than the bots save while producing it.)

Shift your skills

Become brutally good at writing precise requirements and interface contracts. Draft designs and discuss them with your peers and the AI.

Write the tests yourself (and a bit more)

Establish Test-Driven Development (TDD) where writing tests stays with you. Tests in TDD are the bridge from specification to implementation. They allow you to think through each decision made in the spec and design the module, package, and function layout. Another plus: LLMs may write tests that describe technical details. What you want are tests that describe the behavior intended by the spec.

You can even go one step further and write out all types and function signatures. Filling the function bodies remains the only part left to the bot. Prompt it to not create any new function or type without your consent. This way, you can do all the thinking except for the actual function implementation. Moreover, the bot has little room for causing code bloat or diluting your design.

Do coding exercises (and have some fun)

Pick a topic you always wanted to explore deeper. Start a side project and code away. This could be a specialized tool for your workflow, a TinyGo program for a microcontroller-based tool or interactive artwork, or how about reimplementing a small thing from the standard library? Try a sync.Pool() or a new Hash implementation. Or pick a coding kata. Whatever you feel like doing.

Stay sharp!

Even in times of AI, there are ways of keeping your skills, or at least find new skills to replace fading ones. Above are but a few tips. The next article in this series is about increasing your code ownership and will contain a few more thoughts in this direction.