Thoughts on continuing to be fast

I recently read an article about why programmers should use LLMs less and write code more slowly.

The article isn’t unlike many other articles that are against using LLMs for coding, and I disagree with it. Let me tell you why…

Everything was always broken

The article claims that because code is being written by AI, we have more downtime in critical infrastructure such as AWS, and that Microsoft Windows is getting worse because of LLM generated code.

There could be a number of reasons for poor uptime these days, such as the economy being bad, and this causing employees to be less efficient at work.

And then, Windows 8 (or Vista) also wasn’t a good operating system, and there weren’t any LLMs back then. So, we can’t prove that Windows sucks today because of LLMs.

Then the author argues that companies who rely on LLMs will usually produce software that come with memory leaks, UI glitches, and crashes. But these bugs have always been present. We’re only noticing them more today because more code is being shipped.

So, we can’t blame LLMs for producing bugs because we humans have been producing them since programming was invented.

Use agents for production code

Then the author argues that Anthropic used agents to build a C compiler that doesn’t work, so we should all stop trying to write production-quality software with agents.

There’s simply no logic here, because compilers are incredibly hard to create. Most human programmers won’t even try to build one because there are ready-made ones you can use, and that fact that it might take a lifetime to build a compiler that works properly.

If most humans can’t create a compiler, why should agents be able to do it on first try? The goal of agents is to do what humans can do more quickly, not to do what humans can’t do.

The conclusion that if agents can’t write a compiler, then it’s no good for anything that goes in production is foolish.

Make more mistakes

Next, there’s the claim that since LLMs produce code at lightning speed, it will inevitable produce more bugs, so, we need to use agents less so that we produce less bugs.

This might be a good idea, but why are we so scared of making mistakes? The more mistakes we make, the more we learn.

I say, keep pumping out code, including bugs, and then learn to not produce them in the future.

Complexity is inevitable

If you tell an agent to architect your project, it will use industry best practices sold by gurus such as uncle Bob. After a while, you’ll realize that your project is super hard to make sense of.

But that’s not an LLM problem because humans have been introducing complexity in software projects since the beginning of time. Who invented complexity in the first place?

Instead of not using LLMs because “they might generate complex code”, accept the fact that code will become complex anyway. The great thing about LLMs is that you can simply delete a lot of code and have them be regenerated quickly.

Everyone has low recall

Have you ever worked on a huge codebase, and written duplicate functions or classes because you didn’t know such code already existed? Guess what, agents can do it too because they have limited memory.

Accept the fact that duplicate code will be written, and be happy that you can always refactor them out, like you’ve always done.

How we should work with agents

The best way to work with agents right now is by speeding up and relying on agent generated code most of the time. Don’t even worry about reviewing the code that the agent generates, instead, make sure that your integration tests (including others, such as security, etc) pass. If the feature works, nobody cares about the code behind it.

Only go and write code yourself if the agent isn’t able to do it on its own after a few failed attempts. And don’t listen to these dorks who claim that you should write more instructions or skills to guide the agent. You’ll just be overwhelming the agent, and make it suck even more.

I like to keep my agent instructions and skills as minimalistic as possible because I understand that agents can’t do everything properly. That’s why I’m here in the first place.

In conclusion, continue to use agents to generate massive amounts of code, and accept that the code won’t be perfect.