October 22nd, 2026, posted in for_founders
by Adelina
For most of the last twenty years, custom software came with a familiar trade-off. You got exactly what your business needed, but you paid for it in time and money. Months of development, large teams, long feedback loops. Many companies looked at the estimate and settled for an off-the-shelf tool that did 70% of the job.
AI is changing that trade-off. Custom software is getting faster to build, more practical to maintain and more affordable to commission. Things that used to take weeks now take days. Features that weren't worth building suddenly are.
But the most interesting change isn't the one everyone talks about. AI writing code is the easy part. The hard part, and the part that decides whether you get good software or just more software, is everything that happens before a single line gets generated.
What AI changes, and what it doesn't
AI is very good at producing code. Give it a clear, well-scoped task and it will write the model, the endpoint, the form, the tests. It handles setup, boilerplate, integrations and standard features faster than any developer typing by hand.
What AI doesn't do is decide what to build. It doesn't know that your sales team hates the approval flow, that half your users are on mobile in a warehouse, or that the reporting feature matters more to your CFO than the dashboard everyone keeps asking for. It doesn't design an architecture that will still hold up in three years. It doesn't notice that the code it just wrote works perfectly and opens a security hole.
Product thinking, design and engineering haven't become less important. They've become the bottleneck. When code is cheap, the quality of your decisions is what separates a good product from an expensive mess.
The problem with "here's a Copilot licence"
Most companies' AI strategy for development looks the same. Buy a subscription for every developer, tell them to use it, expect output to double.
It rarely does. Here's why. The quality of what AI produces depends almost entirely on the quality of what you give it. A vague prompt gets vague code. A prompt missing the business context gets code that solves the wrong problem, very quickly.
So now your developer has a new job. Before coding, they have to work out what the feature should do, how it should look, which edge cases matter, how it fits the rest of the system and how it should be tested. Then they have to turn all of that into a prompt. Congratulations: you've asked one person to be product owner, designer, architect, tester and developer at the same time, and to do it faster than before.
That's not a realistic expectation. It's the reason so many teams feel busier with AI, not faster.
Don't let developers prompt
Our position is simple. Developers shouldn’t be writing the foundational prompts. Product owners and UX designers should.
By foundational prompts, we mean the ones the entire application is built from: the features, the user flows, the business rules and the acceptance criteria. Developers still use AI every day to tweak code, fix issues and make changes along the way. But those prompts are corrections and refinements, not the main build.
The people who understand the product, the users and the business logic are the ones best placed to describe what needs to be built. When they produce precise specs, developers receive work that’s ready to execute with AI. Their job goes back to what engineers are actually good at: architecture, code quality, security, scalability and making sure what ships really works.
It sounds like a small shift in who does what. In practice, it changes the whole process.
Design captures the product
We've built software design-first since long before AI coding tools existed. Every product starts in Figma, not in a code editor.
Design is where the product becomes concrete. Screens, user flows, states, edge cases, what happens when something goes wrong. Clients can see and react to the product before anyone commits to building it. Changing a flow in design takes hours. Changing it in code takes weeks and usually breaks something else.
Design-first used to be about avoiding expensive surprises. With AI, it does something more. A well-built design, with consistent UI kits and reusable component libraries, is the most complete description of a product you can have. It's context, and context is exactly what AI needs.
Specs turn that context into instructions
This is where design-first meets spec-driven development. Once the product is designed, product owners turn it into user stories with clear acceptance criteria. Each story is broken into technical tasks: specific, scoped instructions for backend and frontend. Those technical tasks become the prompts AI coding tools work from.
The chain looks like this: Design - user stories - acceptance criteria - technical tasks - AI-assisted code - review and tests
Nothing in that chain is improvised. By the time a developer opens their editor, the what and the why are already decided. AI handles the heavy lifting of writing code, the developer steers, checks and owns the result.
The ULTRA suite: AI development tools we built ourselves
We didn’t find off-the-shelf solutions that supported this way of working, so we built our own proprietary tools. We put the same effort into them that we put into client products: careful design, real-world testing and constant refinement. The result is ULTRA, a suite of AI-powered tools designed around the way we build software, from the first user story to the final test.
ULTRA Stories turns feature descriptions and design files into user stories in minutes, then breaks each story into technical tasks that work as precise prompts for AI coding tools. It also generates estimates based on project context and tech stack.
Development happens with AI coding partners guided by our architecture, coding standards and project context. Designs become clean frontend foundations quickly, and every developer works from the tasks, not from a blank prompt. Small tasks are still done by hand, because writing a prompt for a two-line change is slower than writing the two lines.
ULTRA Review analyses every pull request for security risks, technical debt, extensibility issues and alignment with our standards. It catches the small problems early, so the team lead who reviews the code afterwards can focus on architecture and logic.
ULTRA Tests helps generate automated test suites straight from the user stories and acceptance criteria, so what gets tested is exactly what was specified.
Around these sit tools for planning, tracking, deployment and monitoring. The point isn't the number of tools. It's that every step, from idea to production, is designed to feed the next one with the right context.
Why this works better than a coding tool alone
A coding tool speeds up one step: writing code. Our process speeds up the whole chain and removes the reasons projects slow down.
Rework drops, because decisions are made in design, where they're cheap, instead of in code. Prompts get better, because they're written by the people who understand the product. Quality holds, because AI-generated code is checked four times: by ULTRA Review, by a team lead, by automated tests and by manual QA when needed. And developers stay engineers, instead of becoming part-time product managers.
What it means for clients
For the companies we build for, the difference shows up early. You validate your idea sooner, because you see the product in design before development starts. You iterate where it's fast and cheap, moving screens and flows around until they're right. You get clear user stories and estimates grounded in the actual spec, not a guess. And when development starts, it moves quickly, because the hard thinking is already done.
The result is custom software that's 3.7x faster to build than with our pre-AI process, without trading away stability, security or scalability.
The advantage is the system, not the AI
Every development company has access to the same AI models. Anyone can buy the same subscriptions tomorrow. If AI alone were the advantage, it wouldn't be an advantage for long.
Our speed comes from the system around AI: a design-first process refined since 2010, specs written by people who understand the product, proprietary tools that connect each step, and senior engineers who own every line that ships. AI is the engine. The process is what makes it drive in a straight line.
FAQ
Does AI make custom software cheaper?
It makes it faster, and faster usually means less expensive. The biggest savings, though, come from avoiding rework, which is why clear design and specs matter more than the AI tool itself.
Will AI replace developers?
No. It changes their work. Developers spend less time typing code and more time on architecture, review, security and making sure everything works together. Those skills matter more with AI, not less.
What is spec-driven development?
An approach where every feature is fully specified before coding starts: user stories, acceptance criteria and technical tasks. With AI, those specs become the instructions the coding tools follow.
Why design first instead of going straight to code?
Because design is where you find out what the product should be. Changing a flow in Figma takes hours. Changing it in code takes weeks. A good design also gives AI the context it needs to generate the right code.
Is AI-generated code secure?
Only if it's checked. Every pull request we ship is reviewed by ULTRA Review and a team lead, covered by automated tests and tested manually when needed. AI writes code quickly. Engineers make sure it's safe to run.
Can you help our in-house team work this way?
Yes. Besides building products, we help teams set up the process: how specs are written, who writes the prompts and how AI-generated code gets reviewed.
The real revolution
Much of the conversation about AI in software is about volume. More code, faster, with fewer people. That misses the point.
The real revolution isn't AI writing more code. It's teams learning to build software differently with AI: deciding better, specifying better, reviewing better and letting each person do the job they're actually good at.
Thinking about custom software, or wondering why AI hasn't made your team faster? Show us what you want to build or how your team works today. We'll show you what a design-first, spec-driven process would change, from the first screen to production.
