Can coding agents design software ?

Introduction

AI is smart and getting smarter, but can it design? From scratch?

Coding agents have become remarkably good at writing software. Give one a repository and a well-defined task and it can often understand the surrounding implementation, modify several files, write tests, run the application, diagnose failures and iterate until the result works.

This naturally raises a larger question. If an AI can write the code, can it also design the system? The answer is increasingly yes — but that answer needs qualification.

Designing something is easy

Ask a capable coding agent to build an application from scratch and it will design an architecture.

It has to. Files need to be organised. Components need responsibilities. APIs have to be created. State has to live somewhere. Data has to flow through the application. The agent will make all of those decisions.

The problem is not whether AI can produce a design. The problem is whether it can consistently produce a good design. That is a much harder question.

Code has enormous training data

One reason coding agents are so effective is that software provides unusually rich training material. Public repositories contain billions of lines of code. Programming languages have formal syntax. Compilers provide immediate feedback. Tests tell an agent whether behaviour is correct.

Software design has fewer of these advantages. Architecture is often implicit. Important decisions are scattered across meetings, documentation and code. Two systems with almost identical functionality may have completely different architectures because of requirements that are invisible in the repository.

And unlike a compiler error, poor architecture may not become visible immediately. A badly structured system can work perfectly well. Its problems emerge six months later when somebody tries to change it.

Local intelligence versus global structure

Coding agents are particularly strong at local reasoning. Here is a component. Here is the surrounding code. Here is the required behaviour. Change it.

Architecture requires more global reasoning.

• What are the fundamental concepts in this domain?
• Where should responsibility live?
• Which components should know about each other?
• Which dependencies are acceptable?
• Where should state exist?
• What must remain independently replaceable?
• What constraints might matter two years from now?

These are not primarily coding questions. They are questions about the shape of the system. AI can certainly reason about them, and its ability to do so will improve. But giving an agent a blank repository and asking it to make all architectural decisions implicitly is still very different from giving it an explicit architecture.

The problem gets larger as agents get better

There is an interesting paradox here: better coding agents do not make architecture less important, they make it more important.

When implementation was expensive, architecture evolved relatively slowly. A development team could only create so much software in a given period. An agent can generate enormous amounts of code very quickly. That means a poor structural decision can also propagate very quickly. The limiting factor moves from:

Can we implement this ? towards Should the system work this way ?

That is a significant change in software engineering.

Architecture as context

This is one of the ideas behind vmblu: an architecture should not exist only as a picture created for humans. It should be structured information that an AI agent can consume directly.

If a system says:

• Component A is responsible for this.
• Component B exposes these capabilities.
• A communicates with B through this interface.
• These are the permitted connections.

then the coding agent no longer has to infer those decisions from source code.

The architecture becomes part of the agent's context and that reduces the design space dramatically. And reducing the design space is often more valuable than making the agent itself marginally smarter.

Calls, messages and architectural intent

This becomes particularly important when architecture expresses not only which components communicate, but how they communicate.

A conventional function-call architecture has an implicit temporal and algorithmic structure.

Call this.
Wait for the result.
Then call that.

Message-oriented systems represent something different. Components behave more like independent participants in an organisation. One component sends information or requests to another, but the participants remain structurally distinct.

Both approaches are useful. Neither should be treated as universally superior. But they communicate different architectural intent, and that intent should be visible rather than hidden inside implementation details.

vmblu deliberately makes communication part of the architecture for this reason.

Safety

Software will be developed more and more by agents for agents. As a consequence there are two safety concerns to consider for modern software: have the coding agents introduced dangereous activity in the code, maybe because of ambiguous prompts or misunderstood intentions, and secondly can we control how an external agent uses the system.

A lot of safety concerns can be alleviated by good design and static analysis, but vmblu has a runtime and can also check that for a running system unacceptable actions are intercepted and that external agents only get access to these parts of the system that are explicitely made accessible.

So, can agents design?

Yes. And increasingly, they will design very well. But that does not imply that humans should stop designing systems and simply delegate architecture to an unconstrained agent.

A better model is collaborative. Humans define intent, domain structure, constraints and important architectural choices. AI can challenge those decisions, suggest alternatives and identify weaknesses. The architecture can then be made explicit. Coding agents work within it.

Over time, we expect AI to become increasingly capable at the architectural layer as well. It may analyse designs, compare alternatives, identify coupling, suggest decomposition or even generate complete candidate architectures. But the important word is candidate.

Architecture represents what we want a system to become. That makes it one of the places where human judgement remains most valuable. Coding agents are becoming extremely good builders. Our objective is to give them better blueprints.