Goodbye, code

It started with a love for programming.

My career as a software engineer started with a desire to spend all my time programming. Not by the prospect of making a ton of money, not from the desire to build impressive software, and definitely not because computer science was my major in university. I simply enjoyed the feeling of typing out System.out.println, dreaming up the most beautiful abstraction possible for my game’s inventory system, and watching my code compile successfully.

At some point, I realised that I could make money with my programming skills. It turned out that software was incredibly valuable to people, and that they were willing to pay tons of money to develop it. The best of both worlds, and a dream career, hoping it would last forever.

But here I am, 12 years later, working at my first full-time job as a software engineer, but not having written a line of code myself for the past 6 months, having shifted entirely to vibe (or for the more serious folk, agentic) coding.

It feels surreal. For the past few months, I’ve straddled the line between trying to convince my friends that this is the way forward for software engineering, and trying to convince myself of the very same thing. AI seemed undecided too: there are days that I feel convinced we have achieved AGI, and yet there are days where my hour-long unsupervised task produced complete garbage.

But after recent advances introduced yet another step function improvement in the state-of-the-art, I think I’m finally convinced.

What I’m convinced of

On my more convinced days, which are thankfully highly correlated with the weekdays, here’s the phrase I annoy my friends with: code is the new assembly. And the corollary: LLMs are just compilers, from natural language to code.

Just as C is a high-level abstraction over assembly, natural language can be seen as a higher-level abstraction over (all, and any) code. And just as almost no one writes in assembly anymore, at some point most software engineers won’t be writing code anymore.

There is an argument to be had that LLMs are non-deterministic, and that means the behavior of the same “code” can differ if you “compile” it twice with an LLM. My counter is to examine this statement from the point of view of a compiler engineer.

1. The goal of building a compiler is to output a program that fulfills the specification (given as code) written by the programmer. It is not to produce the same code every time.

2. Modern compiler optimisations are incredibly complex. To the point where, I wager, even a C programmer from the “good ol’ days” can’t reasonably predict the assembly a modern C compiler will produce.

3. Due to the incentives to optimize performance and precision, coding LLMs of the future will probably be post-trained to the point where they will likely produce the equivalent code, the optimal solution, each time they attempt the same prompt.

There will be a tipping point where all software will be built by anyone rather than primarily by engineers, and I don’t think it is that far into the future.

Where to go from here

Future software will still be built incrementally, as a function of a prompt and an existing specification. Well, it technically already is, but it will become even more codified (pun intended) as such, with specifications being much more abstract than before. Soon, we will witness the creation of magical machines that take the specification of a current unit of software and some prompt, and spit out a new unit of software.

So where to? Honestly, I have zero clue where the industry will go from here, and I believe most of my peers don’t either.

There’s an argument here that software engineering isn’t just about programming. There’s the figuring out what to build, and the higher-level hows, like system design, rollout, and coordination, etc. The strange feeling is that, while I’ve always been okay with those parts, I never fully appreciated and enjoyed the challenges they bring. Maybe that’s why moving up the abstraction layer has made things less interesting to me than before.

Ironically I use this as justification to explain why I joined Greptile. If LLMs don’t get good enough to produce perfect software as described, there will be immense value in code validation, and so at Greptile we simply have to win that battle. If models do get good enough, then software is solved and I have to find a new career.

Having said all this, I haven’t lost my love for programming. I’m not going to stop writing code. And in some weird way, I’m glad that the industry has moved past writing code. I had always lamented how my hobby had become a job. But now it is back to purely being a hobby, and I can’t be more excited!

At the same time, I’m super keen to see where software goes. I do think we’ll get magical software-producing machines at some point. And I can’t wait to find out how we get there.