What custom software actually costs when writing the code is cheap

The cost of custom software now depends on two things: how much of the work is still undecided when the build starts, and how hard it is to prove the result is right. The amount of code matters less, because AI writes it. Reveneau builds this way: AI writes all of its code, every change has to pass an eval suite written from the specification before it ships, and because it uses AI instead of hiring more engineers, that saving goes into the client's price.
For most of the history of this industry, estimates followed the size of the work: more screens, more endpoints, more code, more months. Size was a poor measure of value. Estimates used it because writing the code was the largest cost.
When the implementation is generated, the volume of code stops predicting the bill. A large internal tool can cost less than a small billing rule, for reasons a line count cannot show. The cost now sits in other parts of the work, and if you are buying software, you should know which parts.
How much does custom software development cost?
A custom build costs the number of people on it, times the weeks they work, times what each person costs per week. Then add the work after launch. Ask every supplier to show its quote in that form, because it is the form you can check.
The US Bureau of Labor Statistics publishes the wage part. In its Occupational Outlook Handbook, read on 8 November 2026, the median annual wage for software developers was $135,980 in May 2025. Over 52 weeks that is $2,615 a week. The table applies that wage to two team sizes chosen for this example. It shows wages only. A supplier's price also pays for benefits, tools, offices and its own margin.
| Example build | Developer weeks | Wages at the BLS median |
|---|---|---|
| 3 developers for 12 weeks | 36 | $94,140 |
| 6 developers for 26 weeks | 156 | $407,940 |
The weekly wage is the same in both rows, so the extra people and weeks alone make the second build cost more than four times the first. When two quotes for the same build differ, ask each supplier how many people it plans and for how many weeks. The answer shows which of the numbers differs.
AI changes the people number: Reveneau uses AI instead of hiring more engineers, so the same build takes a small team. The weeks still depend on the two things the rest of this post covers: how much is undecided when the build starts, and how hard it is to prove the result is right.
For the decision before any quote, read when to build custom software and when to buy it. For a product that calls an AI model on every request, what an AI product costs, model usage included adds the provider's per-request price.
The two things that decide the cost
Look at where the money goes in a build today and you find two places.
Ambiguity is how much of the work is still undecided when building starts. This was always expensive, but it used to be one factor among several. Now it is the largest one, because every open question in a specification has to be answered by somebody. If you answer it, you pay for a conversation. If you leave it open, the model answers it with the most plausible answer and does not mention that it did, and you pay to discover the choice later, in production, after other things have been built on top of it.
This difference in cost is the main point. Take a team that hands over a neat specification for a pricing engine it is confident about. Two weeks in, real customer data shows the rules contradict each other in cases the specification never covered. Nobody priced that, because nobody can price a problem that has not been found yet. When AI writes the code, the contradiction shows up as working code that picks one answer without saying so and looks finished. An engineer writing by hand would have stopped to ask.
Verification difficulty is how hard it is to prove the software is right, and it depends on one thing: what being wrong would cost you. A large internal tool where a mistake means someone re-enters a form is cheap to check. A small rule that charges a customer's card is not, because it needs a specification precise enough to test against, a test suite that covers the awkward cases, careful review, and often reconciliation that finds mismatches afterwards.
Put those together and you get the result that surprises people. A fifty-thousand-line internal system can cost less than a five-hundred-line pricing change. The cost of a mistake now decides the price, and the size of the code matters less.
What got cheaper, and what did not
Be precise about this, because "AI makes software cheaper" is true in a way that misleads if you plan around it.
Writing the implementation used to be the largest line item in a build. AI now does that part. That saving is why projects that used to take quarters can take weeks.
Three things did not get cheaper. Deciding exactly what to build still takes the same conversations with the same people. Reviewing what came back takes longer per line than reviewing a colleague's work, for reasons we go through in what good code review looks like when nobody wrote the code. And turning a working first draft into something that keeps working under real use, with its error handling and its monitoring and its security review, costs the same as before.
So the total falls, by less than the drop in the cost of writing code. Anyone quoting you a ninety percent reduction is quoting the saving on one line item as though it were the whole invoice.
Integrations still cost more than people expect
Every outside system you connect to adds work you do not control. A payment provider, a CRM, an old internal database: the easy part is calling it, and AI now writes that part.
The hard part is the rate limits, the downtime, the data that does not match your assumptions, and the change the other team releases next quarter that breaks your system. None of that got easier, and as a share of the budget it grew, because the part around it shrank. A build with five integrations still carries five separate sources of surprise, and those surprises are exactly the kind that a generated first draft handles poorly.
Adding people still does not work
The old rule is still true, and the reason is now clearer. Coordination cost was always what made a late project later when you added engineers to it. What has changed is the ratio: the work that used to use extra people is the work that got automated, so most of the work that remains is the kind that needs coordination. Specification, review, and judgment are hard to split between many people. Adding people to a late build now mostly adds meetings.
Where to spend to lower the total
The cheapest money in a project is spent on the specification, before anything starts.
This is simple arithmetic. Every decision closed before the build begins is a decision that does not turn into rework, and rework is where budgets go. When AI writes code fast, a build with missing decisions produces something quickly, which feels like progress, and the cost of the missing decisions arrives all at once later. In the past such a build failed slowly, where everyone could see it.
A paid discovery phase that ends in a specification detailed enough to build from is usually the best-value line in the whole engagement. It is also the honest basis for a fixed price, which brings us to the last point.
Fixed price, and how to read a quote
A fixed price on unscoped work forces the supplier to guess, and the supplier prices the guess, either by adding extra to the number or by protecting the margin later when the surprises arrive. Both outcomes cost you. Fixing the price after discovery is often the right choice, because by then both sides know what is being built.
When you are comparing quotes that differ by a large amount, ask each supplier two questions: what are you assuming, and what do you think the riskiest part of this is. A supplier who names a specific risk has thought about your problem. A supplier whose number is low because they quietly assumed the easy reading of every ambiguity has not, and you will pay the difference later as change requests.
One last thing is the same as it always was. Building is a fraction of what software costs across its life. It still has to be understood, monitored, secured, and changed safely by people for years, and a system that can be regenerated in an afternoon still needs people who know how to operate it. A quote that ignores the years after launch only estimates what it costs to start.
Sources
- US Bureau of Labor Statistics, "Software Developers, Quality Assurance Analysts, and Testers", Occupational Outlook Handbook, pay section (median annual wage for software developers, May 2025; read 8 November 2026): https://www.bls.gov/ooh/computer-and-information-technology/software-developers.htm
- Fred Brooks, "The Mythical Man-Month" (adding people to a late software project makes it later, because of coordination cost): https://archive.org/details/mythicalmanmonth0000broo


