- A working application demonstrates capability, not necessarily production readiness.
- Security, data integrity, resilience, delivery and operational ownership need evidence proportionate to the risk.
- The next step is usually an assessment of what exists, not an automatic rebuild.
AI can make a working application appear remarkably quickly. The harder question is whether you can let customers depend on it.
Google’s 2025 DORA research found that 90% of respondents used AI at work and more than 80% believed it increased their productivity. Yet 30% reported little or no trust in AI-generated code.1
There is no contradiction in using a tool enthusiastically while remaining sceptical of its output. Software can work perfectly in a demonstration and still fail in ways nobody has tested. But what happens when the person building the application has never had to ask those questions?
AI-assisted development has made it possible for founders and small teams to turn an idea into a functioning product at extraordinary speed. Interfaces appear, integrations work and the first real workflow can be demonstrated without months of conventional engineering effort. That is genuine progress. It can create real business value.
It also brings forward a potentially misleading milestone: the moment the application looks finished.
The Eureka moment
Picture the founder who has spent a fortnight building an application with an AI coding agent. The interface is polished. The database works. Customers can complete the central journey. They demonstrate it to a prospective investor, colleague or early customer, and it behaves exactly as expected.
The reaction is understandable: we’ve built it.
In one sense, they have. The prototype may already contain valuable workflow logic, useful data structures and an interface worth keeping. Writing it off would be commercially unhelpful.
The demonstration shows what the application can do when everything goes to plan. Daily use asks more of it. What happens when two users act at the same time? Can one customer retrieve another customer’s records? What if a dependency fails halfway through a transaction? How do we detect an incident, recover lost data or roll back a release?
A working demonstration shows capability. The questions behind it call for evidence of their own.
Two definitions of done
In an experienced engineering team, the route to production normally includes much more than writing application code. Requirements, architecture, testing, security, deployment and operational considerations inform one another throughout delivery.
That process is not always efficient, and it does not guarantee good software. But experienced teams are accustomed to asking questions that are invisible to the end user.
An AI-assisted builder can arrive at the same visible result by a different route. The product can appear complete before its non-functional requirements have been articulated, let alone tested.
The work has not necessarily disappeared. Some of it has moved to the other side of “it works”.
The two development tracks in the opening image illustrate the point: both routes can produce working software, and both ultimately need assurance. The difference is where that assurance becomes visible. The tracks are illustrative; they do not promise a fixed time advantage or suggest every AI-assisted team defers these checks. Experienced engineers can also use AI within disciplined delivery practices.
The review paradox: when AI finds what AI missed
On an AI-assisted project, the application was already working when routine pull-request reviews were introduced. Those reviews uncovered edge cases, race conditions and interactions between components that earlier development and unit tests had missed.
Preparing the next release took longer as the findings were investigated. That release also included new features and architectural refactoring, so the extra time cannot all be put down to the reviews.
What matters is what the reviews brought to light.
The review did not create those problems. It made previously hidden work visible.
Each finding raised another question. Was it a genuine risk? How severe was it? Did the proposed fix preserve the intended behaviour? Was it introducing more complexity than the problem justified? Did the revised code need another review?
A technically experienced person can investigate those questions, reject poor recommendations and decide when the remaining risk is acceptable. An AI agent may suggest a fix in seconds, but someone still has to decide whether that fix is right for the product.
That is a new kind of bottleneck: generating the next change may be cheap, while establishing that the change is appropriate remains difficult.
What the application doesn't show you
Production readiness is not one certificate or a single test. It is a collection of justified decisions about the risks an application creates.
- Security and access control. Authentication is only the beginning. The application must also enforce what each user is authorised to do, protect secrets, handle sensitive information and defend the interfaces it exposes.
- Data integrity and concurrency. Happy-path tests rarely prove that simultaneous requests, interrupted operations or retries leave records in a valid state.
- Architecture and maintainability. Code that runs today still needs to be understood, changed and supported. Generated abstractions can be legitimate while adding indirection that earns little value.
- Testing and delivery. Automated tests, dependency checks, reproducible builds and separated environments reduce the chance that a routine change creates an incident.
- Operations and recovery. Logs, monitoring, alerts, backups, restoration procedures and rollback plans matter most after launch.
The appropriate depth depends on the application. An internal tool handling non-sensitive information does not need the same assurance programme as a public, multi-tenant product processing personal or financial data. NIST’s Secure Software Development Framework provides a useful starting point for tailoring secure development practices to the risks involved.3
Nor does every application automatically need an expensive penetration test before its obvious weaknesses have been addressed. Testing should follow an understanding of exposure, threats, data sensitivity and applicable obligations. A penetration test may still be necessary for a particular risk or requirement; it is not a substitute for basic engineering controls.
Confidence is not the same as correctness
DORA’s 2025 findings show widespread AI use and perceived productivity benefits alongside scepticism about generated code. The 30% figure describes respondents reporting little or no trust. It does not tell us how much generated code is defective, or how many applications are production-ready.1
Research on productivity is mixed. In an early-2025 controlled study, METR found that experienced open-source developers working on familiar repositories took 19% longer with the AI tools available at the time, despite expecting to be faster. The result is a snapshot of those tools and tasks, not a forecast for every team or application.2
The point is that faster generation of working code does not automatically provide faster, safer delivery of production systems. As the volume of code increases, the relative value of tests, review, observability and informed judgement can increase with it.
In an age of abundant code, confidence becomes the scarce engineering resource.
Combining domain expertise with engineering confidence
There is another reason to take founder-built applications seriously: the founder may understand the problem better than any off-the-shelf software vendor. A product built around a specific business can capture its real workflows, exceptions and operating knowledge without the compromises a multi-sector SaaS platform sometimes needs to make. AI-assisted development gives that expertise a more direct route into working software.
Ownership can also change the economics. A business may avoid recurring per-user licence fees for its core application and gain greater control over its roadmap and intellectual property. That does not eliminate hosting, maintenance, support, security or third-party service costs, and it does not guarantee lower total cost of ownership. But it creates an alternative worth assessing on its merits.
The opportunity is to combine complementary strengths while preserving what has already been created:
| Founder brings | Fulcrum brings |
|---|---|
| Deep domain expertise | Architecture and engineering judgement |
| Understanding of real workflows | Production-readiness assessment |
| Speed and experimentation | Risk-based assurance |
| Business differentiation | Technical sustainability |
| Product vision | Practical route to production |
The aim is to preserve the business knowledge and value already embedded in an application while establishing the confidence needed to operate it reliably. This is also the economic distinction explored in Fulcrum’s earlier Build vs Buy insight.
Assess what exists. Don't automatically rebuild it.
For a founder holding a working AI-built application, the first question should not be “how much will it cost to rebuild this properly?” It should be: what have we already got, and what would we need to know before putting it in front of customers?
A focused production-readiness assessment should show what is already sound, what needs strengthening and what can wait. Start with five questions:
- Who will use the application, and what information or transactions will it handle?
- Which workflows are critical, and what happens when they fail?
- What architecture, environments, deployment controls and automated tests already exist?
- Where are the most consequential unknowns — especially around access, data integrity, security and recovery?
- Which findings must be resolved before launch, and which can be managed or improved afterwards?
The outcome should be a prioritised plan, not a generic list of everything an enterprise engineering organisation might do. Some problems will need immediate remediation. Others can be handled through time-boxed validation, better monitoring or phased rollout. Some apparent defects may turn out not to matter in the intended operating context.
That is where experience earns its place: knowing which questions matter and how much evidence is enough.
From working software to working business capability
The commercial promise of AI-assisted development is substantial. It enables people to explore ideas, validate workflows and create useful products without the cost and organisational machinery previously associated with bespoke software.
We should protect that advantage. But accessibility to software creation is not the same as expertise in software operation. A founder who has built something impressive may need help with the last, less visible stage because it is valuable enough to take seriously.
Fulcrum works across product definition, architecture and delivery. For an AI-assisted application approaching launch, that can mean understanding the existing implementation, identifying the risks that genuinely matter and creating a proportionate route into production.
The code works. That's a real achievement. Can you trust it to keep working when the conditions change?
- Google Cloud, 2025 DORA State of AI-Assisted Software Development. Survey of nearly 5,000 technology professionals; source for adoption, perceived productivity and reported trust. These are survey responses, not measurements of code quality or production readiness.
- METR, “Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity”. Controlled study on familiar repositories with early-2025 tools; the 19% result should not be generalised beyond that setting.
- NIST, Secure Software Development Framework SP 800-218. Risk-based practices for developing secure software.

