- Doug Rattman in Portal
I was listening to SE Radio 625: Jonathan Schneider on Automated Refactoring with OpenRewrite (I highly recommend it) and at one point Jonathan talks about AI:
We ourselves are avid users of Copilot inside of our company. So I see the primary use of AI in code as in authorship experience that’s accelerating this trend that has existed for some time in the increase in the volume of code under management, already.
First implication is that AI, or to be more precise GPTs, are code generators. As their name implies, they are in fact nothing but generators: there is no reasoning, there is no memory, there is no learning, there is nothing but generating token after token. Which means that, not in some future, but right now, developers all over the world are generating humongous amounts of code using GPTs and just pasting all that stuff into editors until it works. Btw, I do this myself all the time and I am a huge proponent of leveraging GPTs.
Here I’m reminded of a colleague from many years ago, who could not figure out how to make optional conditions in WHERE
statement in a large query, so he just copied it 17 times between different IF
s, ending with 18 almost exactly the same query and thousands of line of SQL code inside of a stored procedure. That is the problem that we are facing rather than the use of GPTs: unthinking use of ~copy-paste~ GPTs. The good news is that the tools built to tackle existing code bases can help us with this deluge of code, no matter who or what wrote it.
Second implication is that we have reached the top of the “abstraction cake”. You know: the one that is built out of abstraction layers, like a layer cake. The implication is that there will be no more abstraction layers to add on top because AI are just going to generate all that code at the current abstraction layers. I agree that this is the current experience but I believe it will not stay that way. I consider that the current practice of checking in GPT generated code, is akin to something like say checking in assembly code generated out by the compiler rather than the higher abstraction source code that we actually wrote.
This is not a new problem: code generators are (and I truly think this) wonderful but the problem with them was always that they asymmetrically raise the abstraction layer. You get an awesome authorship experience but much worse debugging, reading and maintenance experience. Only once that side catches up and you can constantly work on the higher abstraction layer, rather than switching back and forth, do you really start to see productivity gains.
And so that’s what I’m thinking about… what does a modern developer experience look like, one that is built from the first principles, today, with GPTs and LLMs in mind and everything else that we have at our fingertips.
Last modified on 2024-07-27