On Coding Agents

2026.05.25

To elaborate on that title a bit, I want to focus on how coding agents affect software engineering long-term, a lot of what I write here is based on my personal experience of using Claude Code and Cursor since around October 2025. I've used agents prior to that too, but not to any meaningful capactiy.

As I was adopting LLMs more and more into my workflow, I found myself somewhat lost in whether what I was doing was actually correct or meangingful. In the latter months I've made some revelations, which intend to share here. I don't expect these thoughts to resonate with everyone, but for those who do - I hope it will prove useful.

AI will replace all

If you are reading this expecting bold predictions about where AI and coding will be in 6 months, then unfortunately this is not the place to find such information. I also don't gain anything from pressuring you into purchasing a product - that's a job for tech CEOs on Twitter (formly known as X). They seem very eager to promise us a certain future, I wonder why?

Okay-okay, let's get back on track, and with that, let me pose a question that is also conveniently the heading for the next paragraph:

Why do we trust our judgment?

To me, the answer seems rather obvious and there isn't really any need to waste time on trying to guess;

Good judgment comes from experience.

That is, if you fail to acquire new experiences from your work, you fail to gain judgment, or even more broadly speaking, you fail to learn. By adopting methods which optimize parts of your workflow to make less decisions, you potentially risk compromising your judgment and opportunity to learn or reason. Abuse it too much, and you might just start losing touch with what you had gained before.

For software engineering, experience mostly boils down to making decisions while writing software. Yes there are also decisions that are made infront of a whiteboard, but they are only validated during implementation. Well, that used to be the case, as today it is possible to create software with little to no writing, and like with any form of abstraction, good or bad, using coding agents reduces the number of decisions that are possible to be made by the one using them.However, unlike languages or frameworks, coding agents as an abstraction don't have a set boundary of where the abstraction can end.

Writing specs does not substitute logical thinking and problem solving

On paper, it makese sense. We supply all important engineering decisions in plain english to the LLM and let it implement. This allows the engineer to still remain "in-control" on the high level, while skipping the annoying part of writing code and helping to create a boundary for the abstraction. This prompt goes by a variety of different names: plan, spec, ADR, but they are all essentially just markdown with different of levels of detail.

This is approach is not a solution, I personally see it as nothing more than a cope.

The reason I call it that is because this is not what problem solving looks like, especially when creating software. All experience is based on feedback from your actions - but writing plans like that provides almost no immediate feedback. In fact, you only further postpone the evaluation of the solution to some other point in time. Maybe that point comes when you or your peer manually reviews it. If all you get is a "LGTM", then the validation will come in in production.

Hoping to address all important factors in a spec before implementation is the equivalent of trying to answer a question before hearing it. Perhaps it is a question you've heard a 100 times before, and in that case, you will know what you are doing. But what is the strategy for problems you are not familiar with?

Stop and think

You can anticipate significantly more of these gaps in a potential implementation based on your prior judgement, this ends up playing into how engineers with more experience end up being better at utilizing coding agents.

Unfourtenately, coding agents are not marketed towards only senior engineers, and the way that they end up affecting mid-level and especially junior engineers is rather grim. The use of agents is easily promoted to them under the guise of reducing their time to outcome, while robbing them from their opportunity to acquire any sort of deeper understanding on the project they are working on. I see this as incredibly terrible place to be in, you barely understand the outcome of your work, you do not learn anything from it and yet despite both you and your peers using the same agent, those who had years of experience will still produce better code faster. If a less-experienced engineer pushes their use of LLMs beyond what they themselves are capable of, then the only choice of how to improve the work they produce stops being about trying to understand their work more, but rather to optimize more of their agentic workflow. Maybe this manifests as waiting for a bigger model to drop or compensating for lack of decisivness with the amount of code produced.

Getting to the point of exceeding beyond your own capabilities is deceptively easy.

The arguments that I made are actually not limited to just people early in their career, but to an extent, nearly every engineer can end up in the position of a novice given an unfamiliar enough topic. The spec driven development approach really only really works for solving familiar problems. Try asking the agent to use a framework or language you are not familiar with, or worse, try doing it in an unfamiliar domain entirely. It will be literally impossible to tell whether the output is valid or not. When you are making less decisions, or decisions which are irrelevant, the agent is filling in more gaps and likely making poor decisions left and right - and you wouldn't know why it even matters. It doesn't help that misuse of frameworks and tools is one of the easiest ways to speedrun acquisition of redicilious amounts of technical debt. This is not something that test coverage alone can solve.

When was the last time you learned a new framework or language?

It is so easy now to start contributing to a project without actually bothering trying to understand it. I swear, I am not saying this because I wish Rust was more popular, this same logic applies when joining a new company or team and beginning work on a codebase that is old enough to go to school.

If the only path to building new things or using new technologies is through relying on coding agents and SKILLS.md, instead of taking the time to learn them, then thats just pathetic. We go from developers being people who used to be ones that create and build, to ones more and more in the role of an addicted consumer of whatever is the status quo.

How do you plan to get better as an engineer?

Writing code, is much like playing a guitar, it is a skill that fades if you do not practice it. Not to mention that being capable of "learning" is a skill in-an-of-itself, you can get better at learning, but once you stop learning and get used to the routine - it gets progressively harder and harder as time goes on to learn anything new.

On the other hand, using coding agents is addictively easy. Literally anyone can use Claude Code, even non-technical people can make decent looking useless throw-away proof-of-concept single page web apps that will impress someone. To an engineer, there is almost nothing to extract from vibe-coding on its own as an experience. Sure, you might ship something, but no persisting learning occurs from that interaction. When you close that claude code session, both you and your LLM buddy will completely lose all relevant technical context.

There are definitely cases where the choice to generate code using agents is still very valid.That decision, however, should always be made with the opportunity cost in mind. Is it worth the short-term time saved, in exchange for your opportunity to learn something from it, to deepen ones understanding? Is spending less time thinking through a solution even a benefit?

If you are convinced that for the work that you are regularly tasked with there is truly absolutely nothing new to extract from it, then I would honestly run from there.

The value of you and your software

The nature of software is that it continuously evolves - the value of software greatly depends on how well the people working on it understand it and continue to maintain it. To be able to reason about it - with certainty and intent behind each design decision, is the foundation on top of which you continue to build it. This relationship between software and the engineer is bi-directional, as the value of an engineer is also proportional to their capability to argue about new decisions and know how to direct it's development.

Long term commitments and deeper understanding only become more and more relevant as it evolves and accumulates more historic debt, with less and less of it fitting into a context window. There is almost no major systems that is still in use and has stopped changing. Once you start seeing the value of intent and responsibiltiy that exists behind every line of code, generating code with coding agents stops being about boosting productivity and instead becomes about trading understanding for time, and quality for quantity. Code for which internal understanding is lacking, is always going to end up as a liability.

The more an engineer relies on coding agents the less value from their work is produced by them, and more by their agent. When that ratio is sufficiently low, what point is there to keep those engineers around?