Exploring Generative AI

Newest Memo: The function of developer expertise in agentic coding

25 March 2025

As agentic coding assistants grow to be extra succesful, reactions range broadly. Some extrapolate from current developments and declare, “In a yr, we received’t want builders anymore.” Others elevate considerations in regards to the high quality of AI-generated code and the challenges of making ready junior builders for this altering panorama.

Up to now few months, I’ve repeatedly used the agentic modes in Cursor, Windsurf and Cline, nearly solely for altering present codebases (versus creating Tic Tac Toe from scratch). I’m total very impressed by the current progress in IDE integration and the way these integrations massively enhance the best way wherein the instruments can help me. They

• execute checks and different improvement duties, and attempt to instantly repair the errors that happen
• routinely choose up on and attempt to repair linting and compile errors
• can do net analysis
• some even have browser preview integration, to choose up on console errors or examine DOM parts

All of this has led to spectacular collaboration classes with AI, and typically helps me construct options and work out issues in report time.

Nevertheless.

Even in these profitable classes, I intervened, corrected and steered on a regular basis. And infrequently I made a decision to not even commit the adjustments. On this memo, I’ll checklist concrete examples of that steering, as an instance what function the expertise and expertise of a developer play on this “supervised agent” mode. These examples present that whereas the developments have been spectacular, we’re nonetheless distant from AI writing code autonomously for non-trivial duties. In addition they give concepts of the sorts of expertise that builders will nonetheless have to use for the foreseeable future. These are the abilities now we have to protect and prepare for.

The place I’ve needed to steer

I need to preface this by saying that AI instruments are categorically and at all times unhealthy on the issues that I’m itemizing. Among the examples may even be simply mitigated with further prompting or customized guidelines. Mitigated, however not totally managed: LLMs continuously don’t take heed to the letter of the immediate. The longer a coding session will get, the extra hit-and-miss it turns into. So the issues I’m itemizing completely have a non-negligible chance of taking place, whatever the rigor in prompting, or the variety of context suppliers built-in into the coding assistant.

I’m categorising my examples into 3 sorts of affect radius, AI missteps that:

a. slowed down my velocity of improvement and time to commit as an alternative of rushing it up (in comparison with unassisted coding), or
b. create friction for the group movement in that iteration, or
c. negatively affect long-term maintainability of the code.

The larger the affect radius, the longer the suggestions loop for a group to catch these points.

Influence radius: Time to commit

These are the instances the place AI hindered me greater than it helped. That is truly the least problematic affect radius, as a result of it’s the obvious failure mode, and the adjustments likely is not going to even make it right into a commit.

No working code

At occasions my intervention was essential to make the code work, plain and easy. So my expertise both got here into play as a result of I may shortly right the place it went unsuitable, or as a result of I knew early when to surrender, and both begin a brand new session with AI or work on the issue myself.

Misdiagnosis of issues

AI goes down rabbit holes fairly continuously when it misdiagnoses an issue. Lots of these occasions I can pull the device again from the sting of these rabbit holes based mostly on my earlier expertise with these issues.

Instance: It assumed a Docker construct challenge was attributable to structure settings for that Docker construct and adjusted these settings based mostly on that assumption — when in actuality, the difficulty stemmed from copying node_modules constructed for the unsuitable structure. As that may be a typical downside I’ve come throughout many occasions, I may shortly catch it and redirect.

Influence radius: Staff movement within the iteration

This class is about instances the place a scarcity of assessment and intervention results in friction on the group throughout that supply iteration. My expertise of engaged on many supply groups helps me right these earlier than committing, as I’ve run into these second order results many occasions. I think about that even with AI, new builders will be taught this by falling into these pitfalls and studying from them, the identical manner I did. The query is that if the elevated coding throughput with AI exacerbates this to some extent the place a group can not soak up this sustainably.

An excessive amount of up-front work

AI typically goes broad as an alternative of incrementally implementing working slices of performance. This dangers losing massive upfront work earlier than realizing a expertise selection isn’t viable, or a practical requirement was misunderstood.

Instance: Throughout a frontend tech stack migration activity, it tried changing all UI parts without delay somewhat than beginning with one part and a vertical slice that integrates with the backend.

Brute-force fixes as an alternative of root trigger evaluation

AI typically took brute-force approaches to unravel points somewhat than diagnosing what truly precipitated them. This delays the underlying downside to a later stage, and to different group members who then must analyse with out the context of the unique change.

Instance: When encountering a reminiscence error throughout a Docker construct, it elevated the reminiscence settings somewhat than questioning why a lot reminiscence was used within the first place.

Complicating the developer workflow

In a single case, AI generated construct workflows that create a nasty developer expertise. Pushing these adjustments nearly instantly would have an effect on different group members’ improvement workflows.

Instance: Introducing two instructions to run an utility’s frontend and backend, as an alternative of 1.

Instance: Failing to make sure sizzling reload works.

Instance: Sophisticated construct setups that confused each me and the AI itself.

Instance: Dealing with errors in Docker builds with out contemplating how these errors may very well be caught earlier within the construct course of.

Misunderstood or incomplete necessities

Generally once I don’t give an in depth description of the practical necessities, AI jumps to the unsuitable conclusions. Catching this and redirecting the agent doesn’t essentially want particular improvement expertise, simply consideration. Nevertheless, it occurred to me continuously, and is an instance of how totally autonomous brokers can fail once they don’t have a developer watching them work and intervening at the start, somewhat than on the finish. In both case, be it the developer who doesn’t suppose alongside, or an agent who’s totally autonomous, this misunderstanding might be caught later within the story lifecycle, and it’ll trigger a bunch of forwards and backwards to right the work.

Influence radius: Lengthy-term maintainability

That is essentially the most insidious affect radius as a result of it has the longest suggestions loop, these points may solely be caught weeks and months later. These are the sorts of instances the place the code will work effective for now, however might be tougher to alter sooner or later. Sadly, it’s additionally the class the place my 20+ years of programming expertise mattered essentially the most.

Verbose and redundant checks

Whereas AI will be improbable at producing checks, I continuously discover that it creates new take a look at capabilities as an alternative of including assertions to present ones, or that it provides too many assertions, i.e. some that have been already lined in different checks. Counterintuitively for much less skilled programmers, extra checks aren’t essentially higher. The extra checks and assertions get duplicated, the tougher they’re to take care of, and the extra brittle the checks get. This could result in a state the place at any time when a developer adjustments a part of the code, a number of checks fail, resulting in extra overhead and frustration. I’ve tried to mitigate this behaviour with customized directions, but it surely nonetheless occurs continuously.

Lack of reuse

AI-generated code typically lacks modularity, making it troublesome to use the identical strategy elsewhere within the utility.

Instance: Not realising {that a} UI part is already applied elsewhere, and due to this fact creating duplicate code.

Instance: Use of inline CSS types as an alternative of CSS courses and variables

Overly complicated or verbose code

Generally AI generates an excessive amount of code, requiring me to take away pointless parts manually. This could both be code that’s technically pointless and makes the code extra complicated, which is able to result in issues when altering the code sooner or later. Or it may be extra performance than I really want at that second, which might improve upkeep price for pointless traces of code.

Instance: Each time AI does CSS adjustments for me, I then go and take away typically huge quantities of redundant CSS types, one after the other.

Instance: AI generated a brand new net part that would dynamically show information inside a JSON object, and it constructed a really elaborate model that was not wanted at that cut-off date.

Instance: Throughout refactoring, it failed to acknowledge the prevailing dependency injection chain and launched pointless further parameters, making the design extra brittle and tougher to know. E.g., it launched a brand new parameter to a service constructor that was pointless, as a result of the dependency that offered the worth was already injected. (worth = service_a.get_value(); ServiceB(service_a, worth=worth))

Conclusions

These experiences imply that by no stretch of my private creativeness will now we have AI that writes 90% of our code autonomously in a yr. Will it help in writing 90% of the code? Perhaps. For some groups, and a few codebases. It assists me in 80% of the instances in the present day (in a reasonably complicated, comparatively small 15K LOC codebase).

What are you able to do to safeguard towards AI missteps?

So how do you safeguard your software program and group towards the capriciousness of LLM-backed instruments, to make the most of the advantages of AI coding assistants?

Particular person coder

• All the time rigorously assessment AI-generated code. It’s very uncommon that I do NOT discover one thing to repair or enhance.

• Cease AI coding classes once you really feel overwhelmed by what’s occurring. Both revise your immediate and begin a brand new session, or fall again to handbook implementation – “artisanal coding”, as my colleague Steve Upton calls it.

• Keep cautious of “adequate” options that have been miraculously created in a really quick period of time, however introduce long-term upkeep prices.

• Apply pair programming. 4 eyes catch greater than two, and two brains are much less complacent than one

Staff and group

• Good ol’ code high quality monitoring. For those who don’t have them already, arrange instruments like Sonarqube or Codescene to warn you about code smells. Whereas they’ll’t catch the whole lot, it’s a very good constructing block of your security web. Some code smells grow to be extra outstanding with AI instruments and needs to be extra intently monitored than earlier than, e.g. code duplication.

• Pre-commit hooks and IDE-integrated code assessment. Bear in mind to shift-left as a lot as attainable – there are numerous instruments that assessment, lint and security-check your code throughout a pull request, or within the pipeline. However the extra you’ll be able to catch immediately throughout improvement, the higher.

• Revisit good code high quality practices. In mild of the sorts of the pitfalls described right here, and different pitfalls a group experiences, create rituals that reiterate practices to mitigate the outer two affect radiuses. For instance, you could possibly hold a “Go-wrong” log of occasions the place AI-generated code led to friction on the group, or affected maintainability, and mirror on them as soon as per week.

• Make use of customized guidelines. Most coding assistants now assist the configuration of rule units or directions that might be despatched together with each immediate. You may make use of these as a group to iterate on a baseline of immediate directions to codify your good practices and mitigate a number of the missteps listed right here. Nevertheless, as talked about at the start, it’s under no circumstances assured that the AI will comply with them. The bigger a session and due to this fact a context window will get, the extra hit or miss it turns into.

• A tradition of belief and open communication. We’re in a transition section the place this expertise is severely disrupting our methods of working, and all people is a newbie and learner. Groups and organizations with a trustful tradition and open communication are higher geared up to be taught and cope with the vulnerability this creates. For instance, a company that places excessive strain on their groups to ship sooner “since you now have AI” is extra uncovered to the standard dangers talked about right here, as a result of builders may reduce corners to satisfy the expectations. And builders on groups with excessive belief and psychological security will discover it simpler to share their challenges with AI adoption, and assist the group be taught sooner to get essentially the most out of the instruments.

Because of Jim Gumbley, Karl Brown, Jörn Dinkla, Matteo Vaccari and Sarah Taraporewalla for his or her suggestions and enter.