Agency pricing isn't a con. It's an honest answer to a question nobody has re-asked in a while: how many people does it take to build this? For twenty years the answer was six or seven, and everything about how software gets sold — the day rates, the discovery phase, the account manager — was built on top of that number.
The number moved. The pricing didn't.
What you're actually paying for
Take a typical proposal apart and the software is a minority of it. The rest is the machinery around the software:
- The team you're quoted for. Account manager, project manager, designer, two or three developers, a tester. Some of them touch your project. All of them are in the rate, because the rate has to carry the ones who aren't billable this month.
- The handovers. Every person added to a project adds a briefing, a status meeting and something explained twice. Past a certain size, more people makes a project slower, and you pay for the slowness as hours.
- The uncertainty. Nobody has mapped your workflow yet, so the estimate has to survive the worst case. You're paying for the not-knowing, which is usually the largest single line in the number.
- The bench. Offices, sales, the pitch team, and the three proposals they wrote last month that didn't land. Reasonable costs for that business to have. They're just not your software.
None of this is hidden. It's in the day rate, which is why the day rate is what it is — and why negotiating the scope rarely moves the number much.
The incentive nobody mentions
When an invoice is hours multiplied by a rate, finishing early makes the invoice smaller. That doesn't make anyone dishonest — most agency people are trying hard and doing good work. It means nothing in the arrangement pays for being quick, and over a long enough project, arrangements win.
The same structure explains the other thing clients notice: the senior person who ran the pitch isn't the person who builds it. Pitches go to whoever is most experienced, projects go to whoever is free. You find out which after you've signed.
What AI actually changed, and what it didn't
This is where the claims get silly, so it's worth being precise. AI tooling did not make software free, and it does not let one person do the work of six. What it did was collapse a specific category of work — the part that was slow but not hard.
- Scaffolding and boilerplate. Setting a project up, wiring the standard pieces together, the hundred small files nobody enjoys writing.
- The first draft of everything. Tests, forms, admin screens, the plumbing between two systems that already have documented interfaces.
- Reading unfamiliar code. Understanding a codebase someone else wrote used to take a week before you could safely change a line.
That's the work the extra pairs of hands were there to absorb. Remove it and you don't get a faster six-person team — you get a job that stops needing six people.
What's left is judgement: deciding what's worth building, fitting it to systems you already run, deciding what happens when the software is wrong, and checking the output is actually right. That part doesn't divide neatly across a team. It gets worse when you try, which is the same reason adding people to a late project doesn't rescue it.
AI writing more of the code also raises the stakes on reviewing it. Veracode's 2025 GenAI Code Security Report found that 45% of tested code-generation tasks produced code containing a known security weakness. Fewer people doing the building only works if the people left are senior enough to catch that.
What this means for the price
A small team with modern tooling isn't running the same process more cheaply. It's running a shorter one. There's no account layer to brief, no handover between the person who understood the problem and the person writing the code, and no bench to carry. A change is a conversation instead of a change request.
That's why the prices on this site look the way they do — a free code check, a rescue from $350, a first version from $1,750, fixed and agreed before anything starts. Those aren't a discount on the old model. They're what the work costs without it.
Where the big number is still the right answer
Plenty of times, honestly. A regulated build with a formal audit trail, a system replacing something forty people use daily, anything needing a team on call at 3am, or work where the buyer genuinely needs a supplier large enough to sue. If that's your situation, the agency number is real and a studio this size is the wrong call.
The mismatch is at the other end: a first version, an internal tool, an automation, a rescue. Work measured in weeks, quoted as though it were measured in quarters.
Four questions to ask the quote in front of you
- 1Who exactly is doing the work, and what else are they on this month? A name and a percentage, not a role.
- 2How much of this number is discovery, and what do I own at the end of it? If mapping the problem is a third of the price, buy that part on its own first and take the result back to them.
- 3What happens to the price if it takes half as long as you think? A fixed price answers this. Hours multiplied by a rate answers it the other way.
- 4What would you tell me to buy instead of building? Every proposal should have an answer to this, including ours. An outfit that only builds has no mechanism to reach it.
A quote that survives those four is worth its number, whatever the number is. One that doesn't is a price inherited from a way of working that's already gone.