Coding agents – A new era in software development

A developer is faced with a difficult problem. Instead of searching the internet for similar problems in order to develop a solution, he asks his coding agent, who gets to work. The developer gets up and calmly fetches a coffee from the kitchen. When he returns to his workstation, the problem has been solved.

This is not science fiction; by early 2026, it will already be a common reality. Can we still call this programming?

The path to autonomous coding agents

Just a few years ago, auto-completion was a major advance. For each line of code, users received suggestions for how this and the following lines could look. Later, inline completion made it possible to revise the code for multiple lines. Today’s coding agent systems can understand and revise the entire code base.

Figure 1: Evolution of coding agents

Coding agents are AI systems that can independently write, debug, and rewrite (refactor) code. They can not only write individual lines, but also implement entire features. To do this, they use access to the entire code base and not just the current cursor context.

Specialised systems are aimed at different users

Coding agents can be divided into different types of systems. Some are explicitly aimed at non-programmers and can be operated purely via the browser. With Replit [1] or Lovable [2], for example, you can create programmes using pure prompting.

Junie [3] and Jules [4] work in a similar way. In both cases, you can integrate a GitHub repository and the systems create program code directly in the repository.

Agents that are directly embedded in the integrated programming interface (such as Cursor [5] , Google’s Antigravity [6], or Windsurf [7]). However, you do not have to commit to specific programming interfaces, but can run Claude Code [8], Gemini CLI [9] or OpenAI Codex [10] via the command line.

Where does this development come from, and will programming become obsolete?

This development is, of course, closely linked to the breakthrough of large language models such as Claude Open 4.5, OpenAI GPT-5, and Google’s Gemini 3. These systems have shown a dramatic increase in their understanding and generation of code and can now be used by anyone.

For developers, this means that a paradigm shift is taking place with so-called ‘vibe coding’. Away from writing individual lines of code and instead towards orchestrating code as it is embedded in an overall system. Classic programmers should still know the syntax and understand and check the code in its entirety instead of adopting it unseen.

However, the trend is moving towards architects who have an overview of the entire system. Programmes are built using natural language instead of just programming language. A democratisation process is taking place, as it is not only a small tech elite who are able to write code, but also non-developers.

Where are we now, and what can we expect in the future?

• As long as they could only provide code snippets, coding agents offered only minor time savings but did not pose a serious threat to developers.
• In the past two years, however, the possibilities have improved so much that most junior developers can no longer keep up, significantly reducing their chances of getting a job.
• And now, at the beginning of 2026, the systems have evolved to such an extent that they often outperform even senior developers. And it is unlikely that coding agents will stop evolving.

Figure 2: Programming skills of developers and coding agents

The landscape of coding agents

If you take a look at the landscape of coding agents, you will see three different architectural paradigms, each of which addresses different use cases and offers different trade-offs between control, complexity and autonomy:

Figure 3: Different agentic coding approaches

The classic approach remains direct dialogue between the developer and a single coding agent. Tools such as GitHub Copilot, Cursor or Claude Code can be used for this purpose. The developer enters a prompt, whereupon the agent generates code, which the developer then reviews and either accepts or rejects.

This architecture dominates everyday use because it is simple, transparent and relatively deterministic. The developer retains full control, can follow every step and then decides for themselves whether to integrate the code. The disadvantage of this approach is that it quickly becomes repetitive for complex tasks, i.e. the developer has to guide the agent through each sub-step. With this approach, it feels as if the (senior) developer is guiding the junior developer (coding agent) under close supervision.

The next generation uses specialised sub-agents that perform different subtasks in parallel or sequentially. Here, the user no longer orchestrates a single all-purpose coding agent, but directs a group of experts. For example, one sub-agent can focus on backend logic, while another concentrates on frontend logic. The advantage lies in specialisation. Each sub-agent uses its own context for its area, which increases code quality.

The latest approach is multi-agent teams with a hierarchical structure. The developer interacts with the team lead agent, who breaks down the requirements into subtasks and then delegates them to specialised sub-agents. These can also communicate with each other and review each other’s results.

This architecture promises maximum productivity. The developer no longer orchestrates code, but more general requirements. However, the approach is not without risk, because the overall picture also includes the fact that AI-generated code often contains security vulnerabilities. [14] There is therefore no way around reviewing the code generated by AI.

In reality, hybrid approaches are often used, with simple coding agents for routine tasks, sub-agents for the structured individual development of features, and agent teams for the simultaneous development of multiple features.

Conclusion

Coding agents have entered the mainstream, but they are not a panacea. They can generate a lot of code in a short time, but in doing so they can inadvertently introduce security vulnerabilities, overlook edge cases or undermine existing architectural principles. Clear quality mechanisms are required here. Those who use coding agents must treat them like very fast but not error-free colleagues: critically review results, question assumptions, and keep changes traceable.

Those who take this to heart will gain more than just speed. Coding agents create space for truly valuable tasks, shifting the role of developers: less typing, more orchestration, and more responsibility for quality and impact.

I can only urge any developer who has not yet gained experience with such systems to look into them. Because just as with AI, the same applies here: they are here to stay and will fundamentally change the field. Those who learn early on how to use them sensibly and safely will not only become more productive, but will also remain connected in a software world where ‘programming’ increasingly means controlling results rather than just writing code.

Notes:

If you would like to discuss the future of code agents with Bert Gollnick, simply write to him on LinkedIn. And if you are interested in his AI training courses, take a look at his website.

[1] Replit
[2] Lovable
[3] Junie
[4] Jules
[5] Cursor
[6] Antigravity
[7] Windsurf
[8] Claude Code
[9] Gemeni CLI
[10] OpenAI Codex
[11] Vercel
[12] Netlify
[13] Fortune: Top engineers at Anthropic, OpenAI say AI now writes 100% of their code – with big implications for the future of software development jobs
[14] The overall picture also includes the fact that there are now various studies suggesting a decline in efficiency.

Would you like to discuss code agents as a multiplier or opinion leader? Then share this post in your networks.

Here you will find more content from Bert Gollnick on the t2informatik Blog: