Not long ago, working life in software development looked something like this: Start a new task, think about the best solution, write code, test the code, improve the code, and finally deliver the solution. In between, code from other developers on the team also had to be reviewed, and various coordination efforts have always been part of the process.
Every task is important, but writing code was at the heart of the job description, partly because this step typically took a lot of time and effort. Finding the best solution has probably always been the most challenging step, but translating it into high-quality code also required expertise and experience.
This already hints that something has changed, and artificial intelligence (AI) is playing a crucial role in this. As early as 2023, our Xperts noted in a Blog Post The following was noted: “As impressive as AI tools may be, these models do not yet have the ability to examine causal relationships and ensure the accuracy or functionality of the output. In the foreseeable future, however, it is very likely that AI tools will be developed that can automatically execute and test the generated code.”
That foreseeable future is here now, and we now refer to AI tools with these capabilities as agents—agents that can do much more than just generate code.
Agents as Game Changers
Anthropic, the company behind the most capable AI models in software development today, succinctly defines agents as „LLMs calling tools in a loop.“ This short sentence encapsulates two important aspects:
- Tools: While large language models (LLMs) only generate text, agents can take action. They can launch applications, run tests, conduct web searches, and much more.
- Loops: Agents operate across many steps and can respond to what has happened previously. They can make plans and then carry them out step by step.
This is nothing less than a paradigm shift. One of the key factors is the agents’ ability to actually verify whether the generated code works as intended. Agents can detect errors—ranging from syntax errors to overlooked edge cases—on their own and respond by refining the generated code until it works. Alongside increasingly capable AI models, this feedback mechanism is a major reason why software development is shifting from direct implementation to orchestration by agents.
Agent Orchestration as a New Core Competency
At first glance, this sounds abstract, but it’s very concrete in everyday life. It is not enough for AI tools to have agentic capabilities; these capabilities must also be effectively utilized. When modern agents such as Claude Code, Cursor, or Codex work on development tasks today, a vague task description is rarely sufficient to produce high-quality results. The art of working with agents lies in precisely defining the requirements, specifying constraints, clarifying architecture and quality goals, defining acceptance criteria, and providing the right tools and information sources. Just because AI understands our language doesn’t mean it’s always easy to describe a problem in a way that ultimately leads an agent to implement the best solution. But that also doesn’t mean that development teams today consist solely of „prompting wizards.“.
Rather, the focus should be on leveraging existing expertise in software development to design systems:
- Define the context and guidelines: What is the goal? What does the codebase look like? What standards apply?
- Break tasks down clearly: Large, vague projects must be broken down into verifiable subtasks.
- Integrating Tools Effectively: Agents become powerful when they not only generate text but also run tests, read files, use browsers and terminals, and employ structured approaches.
- Define guardrails: What can happen automatically, and what cannot? Where are approvals required? What must be validated before execution?
- Operationalizing quality: „Good“ must not remain a matter of personal preference. Good teams make quality machine-readable: tests, rules, DoDs, policies, checklists.
The job description is thus shifting toward a blend of architecture, translation, review, quality engineering, and orchestration.
The New Development Process: Plan, Delegate, Review
The human contribution now focuses more strongly on three phases:
1. Planning
This is where decisions are made about what should actually be built and why. These decisions are not made by AI; rather, humans remain responsible for them, with AI providing maximum support.
- Which problem is truly relevant?
- What are the constraints?
- Which solution makes the most technical sense?
- Which risks are unacceptable?
2. Delegation and Implementation
In this phase, the agent operates—not in a vacuum, but within a clear framework that software developers, with their expertise, are best suited to define:
- with rules and conventions
- with repository context
- with tests, linting, and build processes
- using approved tools and interfaces
3. Review and Verification
Ultimately, it is the responsibility of the development teams to ensure that the solution they produce is functionally correct, technically sound, and maintainable over the long term. There are now also specialized systems for code reviews, but even these should not lead to blind trust. It can easily happen that the volume of code produced grows faster than the teams’ ability to evaluate it thoroughly. Software development therefore needs automated verification mechanisms more than ever—such as static code analysis, security checks, clearly defined approval processes, traceable logs, and, ultimately, of course, human review decisions at critical points.
What Companies Need to Learn Now
For companies, the most important lesson may be an uncomfortable one: You can’t simply “buy” agent-based software development by paying for Claude Code licenses. If you want to make an impact, you have to adapt your working methods. This starts with requirements gathering, which needs to become faster and more structured. It continues with the need to systematize valuable context. Knowledge about the codebase, architecture, builds, tests, security rules, and conventions should not exist solely in individual minds or scattered documents. Workflows and knowledge packages for agents must be developed and systematically shared. When a job role changes so radically, we must also consider how this affects those involved. For those who have always wanted above all to solve problems, the challenges in this new world are likely to be fewer than for developers who, until now, have enjoyed writing code the most. In short: Software developers are spending less time writing code and more time managing complex systems. This calls for finding solutions, organizing training programs, and accepting that the transition won’t happen at the same pace for everyone. Reviews need to be reimagined. As more code is produced in less time, the review process must evolve accordingly. In-depth human review will, at best, become more selective, structured, and supported by automated processes. Furthermore, it is essential to incorporate a security architecture for agent-based development early on. AI systems not only increase productivity but also the attack surface. Tools adopted without proper review can send code to third parties or embed malware. In the future, modern software developers will spend less time typing code and more time managing a system of rules, tools, and agents in such a way that high-quality software is ultimately produced. This is precisely where the real shift in the job profile lies. And that is why it is worth viewing this development not merely as a productivity gimmick, but as a fundamental reorganization of software development.
For companies, this also means strategically repositioning themselves. The transformation toward an „AI-ready“ organization affects not only development itself but also related areas such as architecture, knowledge management, security, and process design. This is exactly where IT Sonix comes in: With consulting services that go beyond traditional software development, our Xperts help design structures, workflows, and governance in a way that ensures the use of AI and agent-based systems has a lasting impact. The goal is not merely to introduce new tools, but to holistically align the organization with the requirements of modern, AI-driven software development.
