Your agency's clients are about to ask why this costs so much

A business owner walks into a peer group meeting and mentions they need a customer portal. Their agency quoted twelve weeks and $40,000. Another member says: “I just had something similar built in three weeks for $8,000.”

Same functionality. Same quality. Different economics.

The business owner doesn’t understand why the gap exists. They don’t know that the second build used AI-assisted development. They don’t know that one senior developer with the right tools can now produce what used to require a team of four. They just know the numbers don’t match, and they’re going to ask their agency about it.

This conversation hasn’t happened at scale yet. But it will. And the agencies that haven’t prepared for it are going to lose clients not because they did anything wrong, but because the pricing model they’ve relied on for a decade just stopped making sense.

The Model That’s Exposed

Most software agencies sell time. They might call it a project quote, a fixed price, or a retainer, but the underlying math is the same: estimate the hours, multiply by the rate, add margin. The client pays for the team’s time, and the agency’s profitability depends on how efficiently that time is used.

This model worked because there was a relatively stable relationship between complexity and time. A feature that required forty hours of development required forty hours regardless of who built it, give or take the skill differential between developers. Clients couldn’t easily comparison-shop because the time-to-build was broadly consistent across agencies.

AI broke that consistency. A senior developer using AI-assisted tools can now produce certain categories of work in a fraction of the time it took twelve months ago. Standard CRUD interfaces, API integrations, data transformations, component libraries. The translation work that converted a known solution into specific code has been compressed dramatically.

The agency that still quotes based on pre-AI timelines isn’t lying. They’re quoting honestly based on their current process. But their current process is no longer competitive, and the client will find that out: not from understanding AI, but from getting a cheaper quote somewhere else.

Why “Use AI to Cut Costs” Is the Wrong Response

The instinctive reaction is to adopt AI tools internally, reduce development time, and either cut prices or increase margins. This is logical and insufficient.

It’s insufficient because it preserves the same model (selling implementation time) and just compresses it. The agency that was quoting twelve weeks now quotes six. But the solo consultant is quoting three. And next year, the tools will be better, and the solo consultant will be quoting two. You cannot win a compression race against someone with no overhead, no team to coordinate, and no process to change.

More importantly, cutting prices to match tells clients that the original price was inflated. It erodes trust in every previous quote. “If you can build it in six weeks now, why were you charging me for twelve before?” is a question with no good answer.

The agencies that survive this don’t compete on the same axis. They change what they sell.

What Clients Actually Need (And Don’t Know How to Ask For)

Here’s the structural opportunity that most agencies are missing.

AI has made it dramatically easier to build software. It has not made it any easier to know what to build. If anything, the gap has widened. The cost of building the wrong thing used to be weeks of wasted development time; now it’s weeks of wasted development time plus the false confidence that comes from how quickly and cleanly the wrong thing was built.

The client who got their portal built in three weeks for $8,000 might have the wrong portal. It might solve the problem they described rather than the problem they have. It might work perfectly in isolation and break their existing workflow. It might be locally correct and systemically dangerous, the exact failure pattern we see in AI-assisted development at every scale.

What an experienced agency knows, what years of client work teach you, is that the most expensive part of software is not building it. It’s building the wrong thing. It’s the portal that nobody uses because it doesn’t match how the team actually works. It’s the integration that solves last year’s problem. It’s the feature that was specified by someone who didn’t understand their own process well enough to describe what they needed.

This is where the agency’s value lives now. Not in the code. In the thinking that precedes the code.

The Shift: From Selling Hours to Selling Architecture

The agency that thrives in this environment sells something different. Not implementation time. Architecture. Systems thinking. The ability to look at a client’s business and understand (before a line of code is written) what the system needs to do, how it connects to everything else, and what will break if you get it wrong.

This is the work that AI cannot do. It requires understanding the client’s business at a level that no model can reach from a brief. It requires the institutional knowledge that comes from years of working with similar businesses. It requires the kind of judgment that distinguishes between a solution that demos well and a solution that survives contact with reality.

Concretely, this looks like:

Discovery as the product. Instead of quoting a build, quote the discovery phase separately. Two weeks to understand the business, map the workflows, identify the actual requirements, and produce a specification that any competent developer (or AI) could build from. The specification is the deliverable. It’s worth more than the code because it prevents the most expensive failure mode: building the wrong thing well.

Architecture over implementation. Design the system. Define the data model. Specify the interfaces. Then let AI-assisted development handle the translation (whether that’s your internal team using AI tools or the client’s own developer). The agency’s value is in the design, not the typing.

Ongoing oversight, not ongoing development. The retainer model shifts from “we maintain your code” to “we ensure your system evolves correctly.” Review AI-generated changes before they ship. Catch the confident incorrectness that AI-assisted development produces, and provide the senior judgment that the tools cannot.

What This Means for Agency Developers

This is the part that’s hardest to say plainly, so let’s say it plainly.

If your value to the agency is that you write reliable code efficiently, your value is being compressed. Not because you’re less skilled than you were last year, but because the tools now do the part of your job that was measurable in lines per day.

But here’s what the tools don’t do: they don’t understand the client’s business. They don’t know why the last project failed. They don’t catch the requirement that the client forgot to mention because they assumed it was obvious. They don’t design systems that survive the next three years of business change.

If you’ve spent years building software for clients, you have something more valuable than code output. You have domain knowledge. You understand how businesses in your verticals actually work; not how they describe their work in a brief, but how they actually operate day to day. That understanding is the asset. The question is whether you’re using it or burying it under implementation work that AI can now handle.

The developers who lean into this (who position themselves as the person who understands the problem, not just the person who writes the solution) become more valuable, not less. The ones who define their worth by output volume are in a race they cannot win.

The Uncomfortable Arithmetic

A traditional agency with eight developers, a project manager, and a designer has a monthly overhead that demands a certain volume of billable work. That overhead was sustainable when the relationship between team size and output was relatively fixed.

AI changes the arithmetic. One senior developer with AI tools can now match the output of two or three mid-level developers for a significant category of work. The agency doesn’t need fewer good people; it needs different good people. More architects, more discovery specialists, more people who can sit with a client and understand their business deeply enough to specify the right system. Fewer people whose primary function is converting specifications into code.

This is not a comfortable conversation. But it’s better to lead it internally than to have it forced by a client who just got a quote from a solo consultant at a third of the price.

The Agencies That Will Thrive

The agencies that navigate this well share three characteristics.

They’ve already started using AI internally, not to cut costs, but to free their senior people from implementation work so they can spend more time on the design and discovery work that clients actually need.

They’ve begun separating discovery from implementation in their pricing, making it clear that understanding the problem is a distinct, valuable service, not an unpaid preamble to the build.

And they’ve started having honest conversations with their teams about where value is shifting, not as a threat, but as an opportunity to focus on the work people actually find meaningful. Most developers didn’t get into this industry to write CRUD endpoints. They got into it to solve interesting problems. AI is removing the boring parts. The question is whether agencies recognise that and restructure accordingly, or cling to the old model until the market restructures for them.

Perth AI Consulting helps technical teams and agencies understand where AI changes the economics, and where it doesn’t. Start with a conversation.