You Should Be Tired After Using Code Generation Tools, But Why?

The single sharpest fact is this: code generation tools can make developers feel like they're losing control over the code they write, and it's affecting how they work.

When you use these tools, you get all the outward signs of having written code, but none of the internal processes that happen when we write code by hand. The human brain has several types of memory: short-term, working, and long-term. Short-term memory gathers information temporarily and processes it quickly, like RAM. Long-term memory includes things you've learned previously and tucked away, like database storage. Working memory takes the information from short-term memory and long-term memory and combines them to synthesize, or process the information and come up with a solution.

Working memory is where we synthesize information to come up with a solution.

For instance, when we're working on code, all of these processes are going on in our brain simultaneously to try to help us make sense of the programming environment. But code generation, in its default mode, is antithetical to skill retention, particularly because its UX affordances are reminiscent of a slot machine's: you pull the lever, you get a reward (a solution to your coding problem). This can lead to a sense of dependence on the tool, rather than developing one's own skills. In some ways, we've replaced the social media feed with a stream of tokens, and I look forward to reading those papers in ten years.

This was revealed in a recent post by someone who feels like they've lost control over the code they write when they use these tools. The person, who hasn't disclosed their identity, feels like they're just generating answers and not truly writing code. Oz, someone they posted to, suggested rewriting portions of code themselves as a solution.

Inspired by that advice, the paper, thoughts on slowing down, and using AI to write better code more slowly, and Mitchell's adoption journey, I've been working on using the tool more deliberately and adding friction back into development. All of these actions have negated the supposed speed-up effects of LLM-generated code in the short-term by adding friction, and yet, in the longer term, make me better at using the tool, because they solidify my own foundation instead of the foundation models'. By using the tool more deliberately, I've been able to improve my skills and become more confident in my ability to write code.

Using these tools more deliberately means that instead of getting instant gratification, developers have to actually put in the effort to write the code themselves. It requires more time and concentration, but it also means that the developers are actually learning and retaining the skills. They're able to develop a deeper understanding of the code and the problem they're trying to solve.

This way, even when the tools are used, developers still feel like they're writing the code themselves, and not just relying on the tool for instant results.

The person also suggested slowing down and taking more time to think through the code, rather than relying on the tool to generate answers quickly. This means that developers have to be more patient and take more time to think through the code, but it also means that they're more likely to catch errors and write better code. By slowing down, developers can gain a better understanding of the code and the problem they're trying to solve.

It really does take extra concerted effort to move from just generating answers to using the tool deliberately. One thing Oz suggested when I posted on X that I felt like I came away from an agentic session with a brain fog was rewriting portions of code myself.

As for the person's adoption journey, it's a great example of how code generation can be used as a learning tool. By working on using the tool more deliberately, the person was able to improve their skills and become more confident in their ability to write code.

Overall, using code generation tools more deliberately means that developers have to be more patient and take more time to think through the code. It requires more effort, but it also means that developers are actually learning and retaining the skills. This is a crucial step in developing a deeper understanding of the code and the problem they're trying to solve.

The developer's post on X

I've been feeling like I'm losing control over the code I write when I use these tools. It's like I'm just generating answers and not truly writing code.

The solution is not to abandon code generation tools, but to use them more deliberately. Using these tools more deliberately means that instead of getting instant gratification, developers have to actually put in the effort to write the code themselves. It requires more time and concentration, but it also means that the developers are actually learning and retaining the skills.

Slowing down and taking more time to think through the code is another key aspect of using code generation tools more deliberately. This requires developers to be more patient and take more time to think through the code, but it also means that they're more likely to catch errors and write better code.

Learning and retaining skills is an essential part of using code generation tools more deliberately. It really does take extra concerted effort, but the payoff is well worth it. One thing Oz suggested was rewriting portions of code myself.