Software That Builds Itself

1 month ago 1

I have built a lot of software in my life.

Some of it more successfully. Some less so. Some of my work was just my own, but some was deployed across several countries in multi-hundred-billion-dollar businesses.

Over the last weeks and months, gradually but surely, code-generating agents have entered my software life cycle. And I think that once I have fully autonomous agents that act, negotiate, and collaborate through code and APIs, they, again, will bring my work to a whole new level by fundamentally transforming both the speed and quality of my Software Development Life Cycle.

But not by any means.

In this post, I aim to give you an overview of my thoughts on some hopefully interesting findings to demonstrate how Agentic AI solutions automate, optimize, and reshape each SDLC stage, and how the paradigm of “code as interface” that I wrote before will already enable highly effective agent-to-agent workflows.

Please like, share, subscribe.

If you are building software just for yourself, then obviously, a lot of the steps in the software development life cycle are done by yourself. In larger organizations, however, these steps are usually distributed across a large number of people covering a mix of in-house and external resources.

I won’t explain the different stages; I think the chart and source article do that reasonably well.

source

That said, I have formed the opinion that the complexity and dynamism of modern software delivery will benefit greatly from agentic AI. At least my workflow demands more than incremental automation; it requires a system that can reason which code segments to pick, plan how to adjust them, write test cases (unit-tests, SITs, etc), and then act with minimal human intervention, only changing the pieces that would be affected by the change and iterate on error logs.

Classical automation doesn’t cut it anymore.

Across all steps of the software development, this will influence all steps that rely on automation, like rule-based scripts and CI/CD pipelines that break down in the face of changing requirements, unforeseen dependencies, or the need for continuous adaptation.

Thus, agentic AI, by acting as a persistent collaborator (Microsoft calls it CoPilot) that communicates via code and machine-readable protocols, introduces the necessary flexibility, resilience, and intelligence for next-generation software engineering.

But how exactly will that work?

Here are some of my ideas.

Requirements engineering has traditionally posed a bottleneck for SDLC efficiency and accuracy. Business people sit together quabbling around how the software should work, but don’t understand how their ideas fit into the system. If they lack imagination or experience, they miscommunicate intentions and ambiguous specifications, which then frequently lead to costly rewrites.

But that is the past.

Agents should be good enough to now parse natural language stakeholder input like meeting minutes, include legacy documentation (as long as it’s in digital form), and other documentation like policy requirements reliably to derive actionable software requirements. This helps to properly contextualize and refine requirements. I noticed that it helps if my agent proactively queries back to me to clarify a misunderstanding or patch a missing detail. The biggest impact I see here is that now specs are becoming even more living design documents that are constantly updated as information evolves, ensuring alignment from project inception. This means that the boundaries between living specs and agent context blur, but that also it will be incredibly difficult to control the document, and by extension the context, so it doesn’t go completely off the rails.

This problem is amplified by platforms that convert mixed human prompts, living specs, and data artifacts into structured, testable user stories and technical requirements. The solution here is that we need to maintain a clear goal document, maybe in the form of an agents.md file.

Manus’s engineering team has a great write-up.

Design is the creative and technical nucleus of modern software, encompassing everything from system architecture to API definitions. Yet, increasingly, automated systems are generating and refining these blueprints in real time, turning design into a dynamic, adaptive process. Examples are GitHub’s Copilot or AWS Well-Architected Tool. I think this shift enables architectures that evolve alongside product requirements, rather than being locked into static early-stage decisions.

So what does agentic AI bring to the discussion?

Agentic AI can independently propose architecture patterns, leveraging patterns from large-scale code corpora, industrial best practices, and regulatory requirements. It can also generate, on demand, up-to-date UML diagrams, sequence flows, and modular blueprints from requirements. And it might suggest distributed designs optimized for scalability, security, or compliance—all grounded in domain-specific contextual understanding.

Such agents would then not only accelerate the design phase, but they also proactively identify design risks and present alternative architectures for review. In my mind, the iterative process remains, though, as feedback between design agents and human teams allows for faster convergence on robust system blueprints.

While requirements gathering and design phases will increase in importance and time spent, actual implementation time should decrease, driven by coding agents like Claude Code or OpenAI’s Codex.

Implementation is still the core task, though. The core of Agentic AI’s change is, in my opinion, not entirely limited to autonomous code generation and maintenance. Earlier code-generation tools that simply scaffolded boilerplate, modern development agents have been doing this for a long time already.

I think the benefit of implementation is also in turning requirements and blueprints directly into code, selecting appropriate frameworks, libraries, and architectural paradigms. Then to write features and full modules with integrated documentation and inline test suites. And finally, being able to refactor legacy code (and that is a moving target) for maintainability, migrate APIs, and address code smells without manual prompting.

In multi-agent scenarios, specialized performance agents may further scrutinize and optimize database queries, server configurations, and application bottlenecks, traditionally tasks left for more specialized engineers and time-constrained performance reviews.

I never met a person who likes bug-testing. Yet the more the upstream pipeline of the SDLC is automated, the more we rely on proper testing to ensure that the features we have implemented do not wreck the entire code base and we generate a technical debt or, even more importantly, a security hole we can’t close. What is needed here are, in my opinion, unsupervised verification (in the mathematical sense), and structured and well-defined software testing policies that can be executed well by AI Agents, leading to a more effective quality assurance.

So, instead of relying solely on manually designed tests, these agents generate comprehensive unit, integration, and vulnerability tests for both new and legacy code. They independently run simulations, load tests, and security scans to uncover hidden edge cases and vulnerabilities long before deployment. When tests fail, repair agents attempt automated bug fixes and remediation, dramatically reducing backlog churn and time-to-resolution. This closes the feedback loop: once a defect is surfaced, it is immediately analyzed, repaired, and re-tested in a continuous cycle until resolved or escalated.

That does mean we are ushering in an era of self-correcting systems.

Quite an interesting proposition, and brings up the question of what constitutes a bug.

The new software begins its life with deployment.

Already now, tools like Jenkins allow for efficient CI/CD. Post-development, Agentic AI systems would enable continuous and adaptive deployment and maintenance without manual oversight. Here, maybe specialized agents that provision infrastructure (platform as a service), manage cloud deployments and optimize costs, orchestrate containers, and configure environments autonomously could be value drivers. When anomalies occur, self-healing capabilities may detect, diagnose, and remediate incidents, sometimes reverting systems to stable states in seconds. Proactive monitoring agents correlate metrics and detect early warning signals, proposing long-term system improvements and optimizations.

The outcome could be near-zero downtime, leading to greater operational resilience and the ability to dynamically scale system resources in real time, aligning performance with demand. While that sounds like overkill, think what this means for robotics.

One bottleneck between the steps of the SDLC is media breaks. Interfaces from requirements to design and from design to implementation, and so forth, are not that straightforward to automate.

What if these interfaces are also code?

One of the most profound shifts I see when entering the agentic era is the adoption of code as the primary interface. Instead of exchanging vague instructions in natural language, AI agents communicate through well-defined code artifacts, such as standardized scripts, protocol messages, and serialized code objects. Using negotiation and delegation protocols such as Smolagents, Google’s Agent2Agent (A2A), or AG-UI, they then could dynamically coordinate responsibilities, clarify intents, and divide labor across distributed systems. In my opinion, this transforms the Software Development Life Cycle into a multi-agent ecosystem where each agent understands and builds upon the work of others. The result would pave the trail towards true autonomy → agents can evolve codebases continuously, combined with security and traceability, as every transaction is logged and auditable.

This model then also ensures seamless interoperability across human engineers, vendor systems, and in-house automation frameworks.

The key problem here is then “reduced” to orchestration.

And I plan to be writing about OpenAI’s Agentkit, Power Automate, and N8N rather sooner than later.

However, the key showstopper is still:

As SDLC processes increase in autonomy, oversight, and governance have to take center stage.

Every agent interaction needs to be logged, auditable, and designed for compliance with stringent industry standards. Security-focused agents continuously monitor for policy violations, anomalous behavior, or non-compliant actions, intervening and documenting their actions in real time. This embedded auditability ensures that agentic systems meet regulatory frameworks such as GDPR, SOX, and HIPAA, making them viable even in highly regulated industries. By merging intelligence with transparency, these systems bring both innovation and accountability to the core of software operations.

The adoption of agentic AI redefines both organizational dynamics and the developer role itself. Developers evolve from coders into supervisors, validators, and collaborators—guiding digital teammates rather than micromanaging syntax. Organizations benefit from accelerated delivery cycles, shorter release cadences, and fewer manual handoffs across the SDLC. The result is higher-quality software, fewer post-deployment incidents, and systems that continuously adapt to changing requirements, regulations, and market forces. Agentic AI thus doesn’t just optimize how software is built—it transforms who builds it, turning software development into a collaborative dialogue between humans and machines.

Agentic AI has moved beyond theoretical promise to demonstrable value across every SDLC phase. By automating task orchestration, enforcing rigorous testing and remediation, and enabling code-native, protocol-driven collaboration, Agentic AI fundamentally reshapes both the productivity and resilience of software delivery.

The rise of code as interface means that agents can now negotiate, delegate, and iterate as code-aware collaborators—a leap forward that promises massive efficiency gains, greater innovation, and secure, compliant software systems that evolve as rapidly as the markets they serve.

As multi-agent protocols mature and adoption grows, Agentic AI will shift the role of human developers and architects toward higher-order strategic and creative tasks, heralding a new era of intelligent, adaptive, and scalable software development.

References: