Current Thoughts on LLMs

Over the last little while, I’ve been wondering: what even is the point of remaining a software developer if [insert large language model here] can do a decent job in a profession that I’ve been doing for the last decade? Frankly, am I cooked?

Note: While many people are using “AI” to refer to this new technology, I think it’s preferable to use a more concrete description of the exact technology in use; a large language model (“model”), an agentic coding workflow or tool like Claude Code or OpenCode. When I use “AI”, I will put it in quotes, like here.

Long-Term Viability

What makes software engineering a viable long-term career if this is the pace at which various agentic solutions are increasingly capable of doing my job?

While my input is currently necessary, will that still be the case in the future? It’s a concern that should be weighed seriously, and a bleak outlook worth examining.

I find it a difficult prospect, and this has turned into a bit of an existential question. Software development as I’ve done it for the majority of my career is significantly impacted by the rise of this new technology.

I understand that in the future, we will probably still need developers. Will we need as many as we used to, though? More importantly, am I a good enough developer to actually make the cut and not become totally irrelevant?

Also, what’s even the point if I don’t enjoy the delegating and reviewing that these new agentic coding systems require? If I want to be able to deliver a product that I actually believe in and fully understand, I usually need to work on things incrementally.

There are different ways to think about this, but often this involves grasping the domain knowledge, and using your own experience to create or improve a system tailored to the domain knowledge in question. It’s creating something of value, using my personal expertise, creativity, instinct, and such.

But these things are now increasingly less valuable, with LLMs being able to handle part of the heavy lifting here. So, what am I bringing to the table, again?

There is a trade-off, however. It’s an easy one to understand, but we should acknowledge it and be honest about it: the quality of the generated output will, in certain cases, not be good enough compared to when a person would actually do the work themselves, and this matters for foundational work.¹

Some of this, what I would call “proper work”, is now heavily discouraged. Understandably so, when you can just tell the system to get to work and get things done in an instant.

This is possible because these days, the output is usually “good enough”, even without deep understanding or a comprehensive amount of context on the LLM’s side.

Favouring Builders

Maybe I’m just very peculiar about understanding what I am working on, and feeling a sort of disconnect here. Maybe I’m still adapting to the new way things can be done. To me, though, it seems as though there are two kinds of people who are now responding to this new technology.

First, you have people who enjoy programming on a language level, tinkerers. They are slow, but deep workers.

They enjoy a particular syntax, and they enjoy writing code and thinking through problems while coming up with solutions in an elegant and reusable way. Their ability to fully grasp how everything works (in detail) makes them truly remarkable and the people best suited to making certain technical decisions.

These people are not happy that the thing they enjoy the most about programming is now quickly becoming obsolete.

On the other side of the spectrum you have people who primarily enjoy building things, in a more broad sense.

Those people, comparatively, seem to fully embrace this new technology and are finding themselves no longer burdened by the chains of “bothersome” details. They’re fine giving up some control because the productivity boost is making the thing they enjoy the most more enjoyable. They can ship things faster than ever, and they absolutely love it. They feel a lot more productive because they are no longer wasting energy on certain decisions that come up when programming.²

Both sides are, unequivocally, right to feel the way they feel about things. However, one side will certainly find their careers threatened, and the other side will be able to truly capitalize on current developments.

Vibe Coding Evolved

Last year, I wrote about the implications of having these systems run the show in my blog post on vibe coding, as we become increasingly reliant on a service we rent, which could lead to us becoming lazy and certainly dependent on a third party if we want certain work to be done:

Our bodies will adapt if we choose a lazy, sedentary, non-thinking lifestyle where no thought is needed at all. […] This way we are closer than ever to becoming slaves to our machines, if we aren’t already there.

Something I didn’t note but we should also consider is that there’s only a handful of big companies with the GPU resources to keep evolving and serving this technology to the broader public. I’ll discuss this later in this post.

In last year’s blog post, I also made the point that doing the hard work and thinking for ourselves is valuable:

Like going to the gym, I think there’s value in doing the hard work by actually thinking through things and training our brain, in order to remain sharp.

I remain convinced this is still the case, and I will explain why. All of this despite the fact that the models have improved significantly.

Time is Money

Let’s be real. Like with the industrial revolution, all of this is (mostly) about time savings. Because time is money, baby.

Another fair criticism I can levy at this particular technology is that we are now creating more low-quality things (crap?) that we perhaps otherwise would not have, simply because it’s easy. We have already got new vocabulary to talk about this kind of thing. Clanker and AI slop have entered the vernacular as a result.

Even Microsoft, after shipping a bunch of horrible updates to Windows, is increasingly referred to as “Microslop” with their push for Copilot and AI technologies. Copilot is damn near everywhere, and it isn’t what everyone wants deeply integrated into their operating system.³

Either way, there’s a strong push from corporations who would love nothing more than to drive the labour cost down for programmers and software development. It’s working. They’re winning, too.

We are becoming increasingly reliant on this new agentic technology that we cannot reliably run locally due to context window limitations.

Iteration Speed

One of the most frustrating trends over the last decade that I’ve noticed is that the speed at which things new things are being invented is steadily increasing. There’s constantly new stuff to get informed about, because new technology keeps getting invented. In a way, LLMs and agentic coding are being touted as an antidote to this problem.

While that may be the case (it is easier to keep up with a tool that can help you keep up), I know LLMs are also accelerating the “iterative development speed” in general substantially, further increasing the pressure on software developers to build things faster than ever, without thinking about what it is exactly that they are building.

There are two problems with this:

1. The speed at which we work now increases, but our work hours remain the same.
2. We are now dependent on LLMs in order to “keep up”.

Here’s another thought.

If you’ve ever learned anything about scams, you may have found out that scammers who want to misdirect generally love putting time pressure on individuals. Why? Putting time pressure on people forces them to act without thought.

I think we can take that school of thought and translate it to the current vibe I’m getting from the industry, and point out that: the faster the iteration time becomes, the less likely someone is to ask: “hey, should we even be building this, at all?” or, alternatively, “is this an ethical thing to do?”

The Good Part

It would also be unfair to completely dismiss this revolutionary technology. LLMs definitely are useful for summarizing information, or querying information using natural language.

Depending on how the models were trained and what they were trained on, of course – assuming that the well isn’t being poisoned with misinformation and lies. It’s a shame there isn’t more transparency about what models are trained on.

Anyway, here’s a few positive things I’ve found to be true about programming with the aid of LLMs and agentic systems:

• It is now much easier to get unstuck when programming.
• It is now much easier to find information about any given subject.
• It is now much easier to automate certain tasks.
• You can talk with what resembles an intelligent system and reason about code using natural language.
• Certain frustrating and repetitive tasks are now a thing of the past.
• Getting stuck and losing an entire day to a silly issue is also super uncommon these days, as the LLM will likely be able to identify the issue immediately.
• It is much easier to quickly iterate on a particular idea without losing a lot of time.

All of these things I’ve just mentioned are genuinely great.

Degrading Attention Span

However, there are also a few caveats. The more you delegate, the shorter your attention span becomes. I can feel this happening to me in real time, the more I let agentic coding tools do the work for me.

The more I let work be done for me in larger chunks, the stronger the friction I feel when I do have some manual work or dive into the details.

Sometimes, I lack the information to keep up, too, and things are going too quickly.

At that point, there’s a big risk of becoming lazy. Yup, I mentioned this in my previous post about vibe coding, too.

Using AI reminds me of this. I can feel myself becoming lazier, the same kind of laziness that prevented me from properly studying. I thought my grasp on things was “good enough”, but the truth is – it wasn’t.

Similarly, my coding discipline isn’t where I want it to be with this new technology. “Well, what’s being generated is good enough,” I can hear myself think, sometimes. I have to fight this laziness, because the temptation is there. It’s all part of the human condition, too – it’s a universal thing. If we can avoid the work, we will avoid it.

This is where discipline is so very important, too.

As soon as a moment comes when I let my guard down, I’m letting the overall quality of what I work on and ship slide, and that’s not okay.

Perhaps I did not properly check if all of the tests are solid, perhaps I relented on a particular implementation. Perhaps I skimmed over some architectural details that will seriously be an issue down the line.

Maybe it’s not a big deal. Maybe I can tell the agent to fix it when it becomes an issue. Sure, perhaps that’s true. But I don’t think that’s a good thing, especially when it comes to foundational stuff that you might be building.

(Foundations, as they are, should be laid in such a way that there is no doubt about the quality of what we are building upon.)

As long as I keep asking the right questions, I can avoid these various pitfalls, it’s true. But are these agentic systems good enough, even if we keep ourselves in check? I think a bunch of people have decided that, yes, they are.

I mostly agree, I think. But at the same time, I think it’s still a topic that’s being widely discussed because the degree to which we trust these agents definitely depends. For some, it’s mostly about productivity. For others, like me, it also becomes more existential, since a computer now competes with me for my expertise.

I think that’s the argument that people are now trying to have. “Is the randomized, unpredictable but mostly correct generated code good enough to ship? Should I even be programming?”

Knowledge Erosion

Despite the objective reality we live in, I have, as you can probably tell, various broad concerns.

I suspect that continued usage of LLMs and agentic coding will likely lead to problems down the line, when we don’t properly understand the consequences of cutting corners.

What I don’t want to do is just hand-wave that we no longer need to properly understand our own projects; because, let’s be real, I think that’s the direction we are going. I think we are genuinely at risk of losing people who actually know what they are doing.

Okay: perhaps not today, but a decade or two, three from now? It might be a problem, don’t you think so? It’s hard to guess when it will become an issue, too. It might be an issue half a decade from now, if a large percentage of developers get laid off.

One other particular immediate risk also exists: if we automate away many key skills, it is likely that developers will not learn as much as they used to; what they learn to do is rely on the machine to be productive.

A direct impact is that certain benefits to having this knowledge be “available” for direct use, are now no longer present. We will need to rely on automation even more. And so on. Our knowledge, and as such, agency, actually erodes away, like this.

Plus, in this scenario a couple of decades in the future, we might be totally reliant on this technology to get even the simplest things done.

Without all of the domain knowledge available, people will need the large language models and agentic systems to comprehensively be able to rationalize about a project. With potentially thousands of lines of code as part of a project, I’m unsure if these systems will be able to appropriately understand what’s going on with a limited context!

There’s a chance that domain knowledge experts are at risk of being laid off or fired, and once they’re gone, they take a certain amount of knowledge with them, and that is something which will cause problems down the line.

Perhaps this is a technological problem that can be solved by throwing more GPUs at the problem. Context windows are growing, after all.

Sovereignty & Independence

But that brings me to another major point of contention for me – at some point we will be completely reliant on a third-party system that we cannot control, unless we can do some of this locally.

(I’ve tried, agentic work isn’t possible locally right now, as system memory is a strong limiter when it comes to handling longer context windows.)

I know this is a non-issue for many people who do not lack the funds to finance the many thousands of tokens they are using up to build the thing they’ve been aching to build, but for some, it is an issue. Folks who don’t have hundreds of dollars to throw at a problem when it comes to building their hobbyist project.

Also, especially lately, the idea of sovereignty has been very much on my mind. As a European citizen, after all, I am not blind to the technological and geopolitical shift that is currently occurring.

A question I ask myself very frequently now is: do I want to be dependent on [insert technology or company here]? If a technology is open source, that concern is minimal, but key software we use… isn’t.

This is a concern because on the geopolitical stage, things are not the way they used to be. That much has become abundantly clear this month. I am also deeply saddened by the many quality control issues in software recently, which has led me to examining alternatives to much of the software I use on a daily basis.⁴

The big elephant in the room (to be) is the big “AI” companies. OpenAI, Anthropic, xAI… their impact is enormous, and 100% American. So a question that plagues my mind is this: how reliant do I want to be on these American technology companies that are effectively leasing “programmer productivity” to us?⁵

It’s not just the “AI” companies, either. Apple, Microsoft, Google… the companies who maintain the operating systems on virtually all computing hardware used for productivity and communication – do we trust them to make the right decisions?

From what I can tell, many of the founders of these big corporations seem perfectly happy to cozy up to a government and president who seem to be isolating their country on the world stage.

If that’s how things are, isn’t being reliant on technology, whether it’s an operating system or an LLM or an agentic coding tool, a substantial risk for non-Americans, if they continue to isolate themselves from the international stage?

From what I can tell, America is certainly going through some turbulent times and certain platforms seem to be leaning very much in a direction that we would consider extremist here in Europe, with what used to be Twitter being a really great example.

(I don’t use the platform anymore because it has gotten worse, plus, I’m frankly super tired of the “AI push” that is super common on the platform.)

Conclusion

Being able to do the work myself without assistance definitely makes me a better developer, so I think it is important to be careful about these new tools.

My personal priorities regarding are as such:

• I should keep up-to-date with recent developments. LLMs and agentic tooling are very useful.
• If possible, I should be able to run the majority of my workflows locally. (I might be able to build tooling to assist with local development? Running proper workflows locally is very difficult with limited hardware, however.)
• I should make sure I do not rely on these tools too much, or become lazy.
• I should focus on doing proper documentation when it comes to prompts, best practices, guidelines, etc.

My nuanced takeaway is as such:

• Yes, LLMs and agentic workflows can be really useful. They can help us clear roadblocks and get informed faster than ever.
• Because LLMs are trained on existing code, it is easier than ever to reproduce existing code. As such, “template code” will be easier to produce.
• That does not mean we should be afraid to “get our hands dirty” and do some boring work ourselves. This is also part of what makes working on a project more personal. You have your own idea of what to do (and not to do) and how to do it. You can make technical and practical considerations and you own them, which makes what you craft unique to you.⁶
• This new interaction paradigm offers various benefits, some of which we have not grasped yet and will no doubt delight and frighten us.
• We should be careful about how we use this new technology and how much we rely on it, and where we source our compute. (For example: running models offline, locally, is the safest for our personal data, especially because of potential prompt injection attacks. We should be very careful about what data we expose to these models, and what access we grant them.)

So, in short: there’s a lot to be careful about, but the benefits of using these systems are probably here to stay, and they are very much real. But since I care about my work, I will be very careful about how I use these new technologies.