Abstractions are distractions to an AI-assisted programmer
Hypothesis: In a world of AI programming assistants, there will be less need for high-level software languages & frameworks.
Right now, we human programmers like higher-level libraries because they save us keystrokes, and perhaps they’re more powerful. All other things being equal, fewer keystrokes means we can write code more quickly, with fewer bugs.
But all other things are not equal, because cognitive load matters a lot. For humans, there is a complicated relationship between cognitive load and abstraction. Too low-level is bad - it’s almost always harder to write software if we have to manage our own memory, implement all our own data structures from scratch, or indeed type out our code in binary. But at the same time there are costs to writing at a higher-level - at the very least, we have to worry about leaky abstractions, and the effort to learn them.
But my topic here is not the ideal level of abstraction for human programmers, but rather for AI programmers (being supervised by humans).
Imagine you have a friend who can type 100 times faster than you, and can recite most of the code from GitHub from memory. Your friend is really good at assembling well-understood building blocks, especially if there’s a commonly-used pattern.
Well in that case, your friend may be better off relying on less abstract, and less leaky libraries, even if it means writing lots of almost-copied-and-pasted boilerplate code. Especially if those libraries are very popular, well-documented, robust, slowly-changing, and there's lots of public code with common patterns to crib from.
But your friend’s code, written with less powerful abstractions, is harder to extend and modify, you say? Well, your friend types so fast that when the needs of the software change, they just throw a bunch of their defunct code out and rewrite it from scratch. (And they might even benefit from typing more keystrokes. This reminds me a little of how AI fighter pilots might be at an advantage by being more willing to play chicken than human pilots.)
This may be the situation we find ourselves in with AI assistants.
This whole post grew out of a throwaway comment from Andy Hunt on the CoRecursive podcast. He laughingly said that this is the slowest the rate of change will ever be, with reference to new JavaScript frameworks. While it is certainly true that this is the youngest you will ever be, maybe maybe in a world filled with AI assistants, there will be reduced pressure and incentive to seek new and better abstractions. So maybe today is, in fact, the fastest the rate of change will ever be for software frameworks.