The Age-old Resistance to Generated Code
“AI-generated code is making me a worse developer.”
“GitHub Copilot code is riddled with bugs.”
“Generated code is way less efficient than something I wrote myself.”
Developers are right. AI-generated code isn’t as good as something you or I could write. It has bugs, often hard to find because we are giving up some of our control. Even if it’s the correct implementation, it’s one of the slower implementations. But it’s important to remember: these were the same arguments made in the 1950s through 1970s about compilers vs. assemblers.
Compilers took up more space, produced less efficient code, and added a layer of misdirection between programmers and the machine code. They weren’t seen as serious tools for developers. Ironically, it limited the types of hardware to which you could deploy your software — not all machines had the space or memory for a compiler.
Grace Hopper wrote one of the first compilers, “A-0,” on UNIVAC in 1952 (today, it would be considered a linker rather than a compiler). But Hopper was one of the loudest advocates for high-level (i.e., not assembly) programming, primarily via languages like COBOL. Developers (and academics) thought COBOL wasn’t a serious language because it was closer to English than machine code (how far we’ve come).
When FORTRAN was released, there was intense skepticism about the usefulness of high-level languages because of inefficient transforms. John Backus and his team worked hard on optimizations so that the FORTRAN compiled code would be faster than the average developer. His work paid off: the FORTRAN compiler found commercial success because of this selling point.
Unix was originally written in assembly language. In 1973, Unix Version 4 was rewritten in C. This was controversial. Most operating system kernels were written in assembly for performance. Writing in a high-level language was instrumental to Unix’s success (portability, developer velocity, readability, etc.)
Even in the 1980s, applications like Lotus 1-2-3 were written in assembly for performance and targeted specific hardware, like the IBM PC. Assembly was still seen as the go-to layer for performance-critical code.
Today, high-level (this time, meaning no manual memory management or GC) code still gets a bad rap. Terminals, frontend bundlers, and more are getting rewritten in Rust. Developers are right — code written in Rust, Zig, or another performance-focused language is usually much faster than programs written in (something like) JavaScript.
Five years from now, we might not care. We might have LLMs automatically rewrite the performance-critical sections of our code in lower-level language. We might even have LLMs identify our code's performance-critical sections. It’s a delicate balance between creating higher-level abstractions so developers can focus more on the logic and creating escape hatches to go one level deeper.
If you use the first thing it spits out and don't try to insertand it, it won't work.
Most code I get from AI i out it in a 5 question loop, improving, understanding, using the experiencia and concepts from 13 years and I know the final output is goood!
Tricks:
1- small operations per interaction
2- variations and reflection, give me n ways to do it with prod and cons what's wrong with this code, your code
3- explain it to me, explain the concepto
4- What about x, you can use your knowledge or even Googled things You barely understand
5- give me an example hardcoded or simplified
When AI generated code gives you great code for your specific scenario it will still be límites by people not being able to describe the need accurately in words, it will substitute mid level devs.
AI Will still require to figure out solutions to problems with context, or even figure out problems and manipulate at the problem (requirement) level to negotiate, simplify and reduce.
Today you still need a good and fast supervisor to iterate quickly and generate good AI code. It's awesome for pair programming, but obviously it's the cheap replacement to a real incredible and knowledgeable engineer who's familiar with your context, not every company nor project have that.
If you got this far, Matt's content is great, keep reading his stuff
Great analogy and callout: this rhymes with the past in so many ways.
Also: I love hearing Grace Hopper's name.