Dieser Blogpost ist auch auf Deutsch verfügbar
The world of AI is changing rapidly. It seems every day some tool with some snazzy name has broken some new record and become the new thing people are talking about… until the next record is broken 25 minutes from now and the news cycle continues.
Hype? No, thanks.
I am allergic to hype. As soon as some marketer starts to spew a strung together list of buzzword bingo to convince me that THIS thing is actually the silver bullet that will solve all of my problems, my gut instinct is to nod politely and secretly plot all of the ways I will be perfectly fine without it. The benefits of this approach is that when technologies are being hyped which are useless (I’m looking at you blockchain!), I don’t waste any of my precious time and energy on them.
Finding real value
Once a topic has stuck around long enough, I get curious and begin to sift through the noise to try to find the kernel of value that might be contained therein. That’s what this post is about — an attempt to peel back the layers of the hyped AI buzzwords to see where we can find value for us as software developers today.
In my personal experience, AI has made a huge difference in two different categories: software architecture and requirement engineering (including documentation) and agentic software development.
Chatbots like ChatGPT and Claude AI don’t only do an excellent job of summarizing, formatting and translating requirements, they also provide a sounding board for bouncing ideas around. The programming adage “rubber duck debugging”, where we explain our code to an inanimate object in order to better understand it ourself works here too — but it is actually more effective when the inanimate object is a Chatbot who can keep track of your train of thought and provide suggestions of existing solutions or methods which could be relevant for solving your problem.
I believe this is the most valuable code competency we can develop as software developers: the ability to figure out what the actual problem is, think through solutions to that problem, and (where necessary) implement and create software that solves the problem and finds value.
Automating routine steps with agents
That last step of creating the software to solve the problem is where agentic software development can come in: instead of having to write my own code with a lot of boilerplate and copy/paste work, I can delegate that task to a programming agent who will do the heavy lifting for me and produce a decent result in minutes instead of the hours that it would take me.
This frees up my brain for real world problems like understanding my customer’s business model and figuring out how to improve the accessibility and usability for end users. You know… the interesting stuff. 😉
I am a full-stack developer with a special love for HTML, CSS and accessibility. Recently I have been working on a server-side rendered Spring Boot application with a customized Bootstrap pattern library and custom Thymeleaf templates for UI fields which hook into the default Spring validation mechanism to provide field validation (and ensure field accessibility).
I use test-driven-development when developing the UI. My approach is usually as follows:
- write one UI test to test the happy path for my form validation
- assert that the form exists and has proper methods and actions
- assert that form fields exist with proper labels
- assert that submitting the form will be successful and do what I want it to do
- implement the controller code
- implement the UI template
- debug and tweak until the test passes
- repeat steps 1–4 to test and implement form validation for that endpoint
The agent I am using is Claude Code. With Claude Code, I can pretty much automate steps 2–4 of my process. I always need to tweak the UI a bit, but usually just a few details. I can also throw in prompts like “please look at templates X and Y because the UI components I want to use are similar” which can improve the result.
Then once I’ve tweaked the UI, I can usually add a prompt “please implement tests for the form validation of the endpoint” and the AI will generate the missing tests.
I then do a code review of my own code and tweak a few things if I am not satisfied with it.
Then I’m done.
Still software development
I usually check the code a few more times just to make sure that everything is really there and ok because it subjectively still FEELS way too fast. It feels too fast. But do you know what it doesn’t feel like?
Magic.
When we first began to hear about AI, we were hearing things like “just you wait… this technology is going to revolutionize software development! Nobody is going to need to program anymore”, etc.
The tooling has shifted and changed. We no longer need to spend hours doing routine work when we can ask an AI agent to do it for us in minutes. But do you know what formulating a request to ask a computer to do something is called?
Software Development.
How about iterating on that result in order to optimize or add features?
Also Software Development.
Even if we are no longer required to type the keys in order to write the lines of code anymore.
We still need to generate ideas about what the actual problem is that we need to solve (here is where sparring with a Chatbot can be helpful). We still need to have an idea about what we want to build. We still need to iterate on our results until they solve the actual problems. And perhaps even more important now, we need to ensure that the code that we produce is understandable, readable and thereby maintainable.
These have always been the core competencies of a software developer and that hasn’t changed.
In a rare moment of honesty (following an explicit prompt on my part), an AI chatbot told me that my workflow example here is too mundane because I am describing glorified code generation which is not exactly groundbreaking stuff.
I agree. It absolutely is not groundbreaking, yet it is still completely and totally useful.
So many of the tasks that we have to do as software developers are pretty much solved problems. Yet the true value that we can deliver to our customers is not the code that we write, but making sure we are building the right thing.
I’ve also used the same AI agent to generate more complex code with good results. We are working on a distribution algorithm for a customer and I was able to generate variants of the algorithm using different approaches in order to test something. Those experiments probably would have taken me a couple of days were I to have written it myself, but an agent was able to generate a new algorithm for me in 15 minutes. We aren’t using that code in production, but we were able to use those algorithms to understand the data better and improve the existing code base so it was definitely a success in that sense. Fast feature development allows faster feedback loops. It allows us to iterate faster.
Here I want to note that the code quality of the project in question really improved the quality of the results that the AI was able to produce. We have an extensive test suite which tests that the business requirements are met, so in developing the new algorithm, the agent was able to use the existing tests in its feedback loop to ensure a correct implementation.
This goes back to my point about core competencies for a software developer: we still need to be able to write good tests (and read any tests than an agent generates for us) in order to verify that the software does what it needs to do.
Limitations
I fear that my genuine enthusiasm for the new agentic programming model in this post could well be misconstrued as the marketing “blah blah blah” that I so detest. In an attempt to rectify that misconception, I would like to also add a word about where I believe we need to exercise caution with AI. I think it’s crucial to understand hallucinations: that AI models are not able to easily recognize where they do not have sufficient information to provide a good solution. I’ve asked ChatGPT to draw me a picture of a nightlight and it was unable to do so because it didn’t understand the concept (it now can do so, but couldn’t at the time when I asked). I asked a chatbot to fact check something I read in a book, only to have it try to convince me that there was no evidence of that fact so it must not exist.
This is one of the benefits of working with agents: an agent can check the output of an LLM against a real world system to verify that the result is valid and discard any hallucinations as they happen.
Nevertheless, we currently still need to keep our thinking hats on and critically evaluate any output that is produced by AI. It doesn’t know what it doesn’t know.
This is the future that I envisage when working with AI: new tools and methods will support us, but humans will continue to provide the guidance and oversight to ensure that the right problems get solved. I also consider it our responsibility to continue providing that guidance and oversight, because I remain skeptical that an AI without a conscience should make final decisions.
In our professional careers, I remain optimistic that we will remain busy building software that provides value for our end users. The core competencies of software development are still crucial, they have just taken on a different flavor now.
We do need to keep our skeptic’s glasses on to try to see past any hype or buzzwords and identify where issues (like hallucinations) are actually present, but we shouldn’t dismiss useful technological advances without giving them a chance.
Let’s give AI a fair chance — accepting neither overinflated promises nor unsubstantiated skepticism.