AI Built the Application. But Did It Build the Right Solution?
SIMPLEX INSIGHTS · SOFTWARE ARCHITECTURE & AI-ASSISTED ENGINEERING
The application worked. That was the encouraging part. An AI coding assistant had produced a simple application surprisingly quickly. There was something tangible to demonstrate, and the apparent development effort was modest.
Then came the engineering review. The implementation hadn't used the frameworks anticipated by the team, and database access was scattered across the application. Bringing the code into a maintainable structure took another two days of refactoring, with further AI usage and human effort.
This is an intentionally generalised example, but the lesson is familiar: producing working code quickly is not the same as delivering the right software efficiently.
A working demonstration is only the beginning
The temptation is to call the first working version a productivity success. It may well be a useful prototype. But a demonstration rarely proves that a solution follows the organisation's architecture, respects its security boundaries or can be supported economically.
There is a more uncomfortable question. If the required frameworks, component responsibilities and database-access rules were never specified, did the AI actually get them wrong? Or did it produce a reasonable interpretation of an incomplete request?
Models can make poor engineering choices even with good instructions. Yet when the expected solution exists only in a developer's head, the agent is being asked to satisfy requirements it cannot see. That creates avoidable uncertainty before the first line is written.
The architectural vacuum
In October 2026, Gartner described AI systems as operating in an “architectural vacuum”, warning that software generation can outpace the ability to review it and expose wider technology risks. Its point is broader than code structure, but it speaks directly to the need for deliberate boundaries and ownership.
A specification does not need to dictate every implementation detail. It should make the important decisions explicit: which technologies are appropriate, where business logic belongs, how components interact, how data is accessed and what the finished solution must demonstrate.
Without these boundaries, an agent may create shortcuts that look efficient locally but create coupling, duplicate patterns or extra maintenance work. The application can be functional while its long-term costs remain hidden.
Faster code does not automatically mean faster delivery
Google's 2025 DORA research describes AI as an amplifier of an organisation's existing strengths and weaknesses. Teams with good engineering foundations may realise substantial benefits; weak practices are not repaired simply by generating more code.
Consider the total journey to an accepted change. It includes clarifying intent, designing the solution, generating code, testing, reviewing, correcting and releasing it. Time saved in implementation can be lost again if developers spend days unravelling unnecessary dependencies.
Token consumption matters too, particularly when an agent repeatedly rewrites work. But the larger economic question is not the cost of the initial prompt. It is the total effort required to deliver and maintain an accepted outcome.

Start with an architecture brief, not a mountain of documentation
The answer is not to restore months of up-front design or require a formal review board for every small change. Good direction should be proportionate to the work. For a modest application, a concise architecture brief may be enough.
Before asking an agent to implement, establish at least:
- Purpose and acceptance: the business problem, essential use cases and what a successful outcome looks like.
- Technology choices: the approved frameworks, languages, dependencies and reasons for important constraints.
- Component boundaries: where presentation, business rules, services and persistence responsibilities belong.
- Data and integration: database access conventions, API contracts, error handling and external interfaces.
- Engineering safeguards: security requirements, reproducible builds, relevant tests and review responsibilities.
These decisions do not have to be perfect or immutable. Architecture should evolve as the team learns. What matters is that important choices are visible, discussable and testable before generation turns them into a large body of code.
AI can help prepare the specification
Interestingly, Anthropic's 2026 AI-native software development playbook places intent, specifications and an approved implementation plan ahead of building. The playbook presents AI as a participant in those stages, not simply a code generator waiting for instructions.
That is the opportunity: ask the model to challenge an incomplete requirement, identify unanswered questions, suggest architectural options and outline what might break. Then let the engineer or product owner resolve the consequential choices before implementation begins.
The model can make the discussion faster. It should not silently become the authority on an organisation's standards, architecture or risk acceptance.
The engineer's expertise has not become redundant
Experienced developers and architects understand why a framework was selected, how data should flow, which shortcuts are acceptable and where a seemingly small change creates wider risk. Their value is not limited to typing code.
As AI takes on more implementation work, engineering judgement shifts towards framing problems, choosing trade-offs, defining constraints, inspecting outputs and improving the standards that guide the next task.
McKinsey's May 2026 analysis of agentic software delivery similarly emphasises clear business direction, modular architecture and consistent workflows. Faster execution depends on the system around the agents, not just the capability of the models.
This is a positive development for skilled engineers. AI can help them spend less time on repetitive implementation, provided their expertise shapes what gets produced.
Measure the solution, not the code generated
Rather than declaring success when a demo runs, compare the time and cost to a solution that passes its agreed acceptance and quality checks. Track review effort, refactoring and rework, defects, architectural exceptions and the work required to keep the result maintainable.
For a small pilot, compare a code-first approach with one that begins from an agreed brief. Include the time spent designing that brief. If the second approach reduces correction and uncertainty, the benefit becomes visible in the overall result—not in a headline about how quickly the AI wrote its first files.
Our earlier Insight explores independent verification of agent-generated changes. Architecture provides the direction that helps make those checks meaningful.
Where Meridian fits
At Simplex, Meridian connects evidence-based readiness assessments, practical engineering enablement and responsible AI governance. The focus is on understanding whether an organisation has the architecture, working practices and controls needed to benefit from AI-assisted development.
Our Meridian Software Factory is an evolving direction for supervised agentic engineering, not a finished product that organisations must adopt. Existing teams can also use the assessment findings to strengthen their own tools, standards and delivery practices.
AI-assisted development can shorten delivery times. But without the right direction it can just as easily accelerate rework. The goal is not faster code. It is better engineering outcomes with less avoidable effort.
Before asking AI to build your next application, have you told it enough about the solution you actually need?
Is your engineering environment ready to benefit from AI?
A Meridian Readiness Assessment can help examine architecture, engineering standards and practical AI adoption constraints before an organisation invests further in automation. The right starting point is the decision and the evidence—not a particular tool.
Further reading and sources
- Gartner — Top strategic technology trends for 2027 (20 October 2026). The risks of an architectural vacuum in AI-enabled technology.
- Google DORA — State of AI-assisted Software Development (2025). AI as an amplifier of engineering strengths and weaknesses.
- Anthropic — The AI-native SDLC playbook (21 August 2026). Intent, specification, planning, build and review across the software lifecycle.
- McKinsey & Company — Rewiring software delivery for the agentic era (28 May 2026). Architectural discipline and repeatable engineering workflows.
Simplex Insight · Published 18 November 2026. The development scenario is intentionally generalised; no client, codebase or confidential findings are identified. This article provides general engineering guidance.