I started tracking our profit-and-loss line by line eighteen months ago when I realized I had no idea whether running an AI-first agency was actually making us more money – or just making me feel more productive. The vibes were good. The margin math was unclear.

What I found changed how I price, how I hire, and where I reinvest. This post is that P&L breakdown, written for agency owners who want numbers, not inspiration.

The Revenue Side: What Clients Pay For Has Changed

For the first ten years of running Wbcom Designs, clients paid us for time. We quoted in hours, invoiced in hours, and justified our rates by how many senior hours a feature required. That model made sense when the relationship between effort and output was linear.

It stopped making sense around mid-2024. When a senior developer working with Claude Code can produce code that would have taken three days in a single afternoon, the hourly framing becomes awkward for everyone. The client asks why a “simple” feature costs as much as before. You know it doesn’t – so either you under-charge and crater the margin, or you over-explain the billing and look defensive.

We moved almost entirely off hourly billing for new engagements in late 2024. Here is what replaced it:

  • Outcome-based project pricing: A fixed price for a defined deliverable. The client buys the shipped feature or plugin, not our hours. Our AI leverage is built into the margin.
  • Retainer pricing for judgment and accountability: Monthly retainers covering ongoing development, QA, and advisory. The client is buying my team’s experience and the guarantee that someone competent is watching their codebase – not raw hours of code output.
  • Productized service packages: Fixed-scope, repeatable engagements (plugin audits, performance packages, migration packages) with a known cost structure and a known delivery time. We do these fast now. We charge for the outcome, not the speed.

The shift in what clients pay for is real: they now pay for judgment, accountability, and outcomes. Not hours. That shift is good for everyone – but only if you actually reprice instead of carrying the old rate card forward.

How Our Proposals Changed

Old proposals had a time breakdown. Senior developer: X hours at $Y/hour. Design review: Z hours. The client could see exactly what they were paying for and negotiate line by line.

New proposals lead with scope, deliverables, and a single fixed price. The work breakdown is internal. What we publish is: what gets built, what done looks like, what the price is, and what happens if scope changes. We get fewer price negotiations now. Clients who push back on outcome pricing usually want an hourly relationship – and that’s a useful filter at the proposal stage.

The Cost Side: Where AI Actually Shows Up on the P&L

API Spend as a Real Line Item

I covered the model-level cost breakdown in detail in the Cost-First AI Stack post – the logic behind routing calls to Haiku vs Sonnet vs Opus based on task complexity. The headline number for this post: we run roughly $2 a day in Claude API spend.

That $2/day is doing work that previously justified a $4,000/month developer hire. Not because the API is replacing someone who would sit at a desk 160 hours a month – it’s replacing a category of output. The repetitive stuff: boilerplate, code review, documentation, test writing, first-pass debugging, PR descriptions. That used to require a junior or mid developer to produce at scale. Now it’s API calls.

$2/day is $60/month. The comparison isn’t $60/month vs $4,000/month – that framing is too clean. The honest version: we produce substantially more deliverable output per senior engineer per month, and the incremental cost of that additional output is API spend, not headcount. The $60/month enables a productivity ceiling that previously required $4,000/month in additional headcount to reach.

What Stays Human (and Why Those People Cost More Now)

Here is the part most AI agency content gets wrong: the humans who stayed are more expensive, not cheaper. Here is why.

When you remove junior and mid-level output from AI, the humans who remain are the ones AI cannot reliably replace. That means:

  • Senior engineers who can audit AI output at speed – they know what correct looks like and can catch the plausible-but-wrong code Claude produces on edge cases
  • Architects who set the constraints AI works within – the system design, the plugin architecture, the data model decisions
  • Client-facing leads who own accountability – someone has to sign off on the deliverable and take responsibility if it breaks in production
  • QA engineers who design test cases – running tests through AI is easy; knowing which tests matter is not

These are senior roles. Senior roles command senior salaries. Our average developer cost went up per head as we became more AI-first, not down. What changed is that we need fewer heads to reach the same (or higher) output level.

The workflow that makes this work is covered in the AI-Agency Operating System post – the n8n + MCP + Claude stack that handles the orchestration layer so senior people spend their time on judgment, not coordination.

At 66% gross margin on the same project price, the business feels different. Delays don't threaten the economics. You can say yes to things without calculating whether it's worth it.
At 66% gross margin on the same project price, the business feels different.

The Margin Math: A Worked Example

Abstract claims about margin improvement are not useful. Here is a worked example based on a real project type – a mid-complexity WordPress plugin build with documentation and testing.

Line ItemPre-AI (2022)AI-First (2025)
Project price (client invoice)$10,000$10,000
Senior dev hours40 hrs @ $80/hr = $3,20020 hrs @ $90/hr = $1,800
Mid dev hours60 hrs @ $50/hr = $3,00010 hrs @ $60/hr = $600
Junior dev hours40 hrs @ $30/hr = $1,2000 hrs = $0
QA hours20 hrs @ $40/hr = $80012 hrs @ $50/hr = $600
PM / coordination10 hrs @ $60/hr = $6006 hrs @ $65/hr = $390
AI tooling / API$0$45 (project allocation)
Total cost$8,800$3,435
Gross margin$1,200 (12%)$6,565 (66%)

A few notes on this table:

  • The project price is the same – we have not cut rates. This is a conscious choice I’ll come back to.
  • Senior and QA hourly rates went up slightly – accurate, because the remaining humans are more senior and command higher rates.
  • Junior hours dropped to zero – we no longer staff juniors on client projects. They work on internal tooling where mistakes cost us, not the client.
  • Total hours dropped from 170 to 48 – a 72% reduction in billable time for the same deliverable.
  • Gross margin went from 12% to 66% – this is the AI dividend, and it’s real.

The 12% pre-AI margin is tight. That was the reality for most small WordPress agencies running team-heavy delivery models. One project delay, one scope creep conversation that went badly, one staff member sick for a week – and you were at breakeven or below. The margin was thin enough that the business felt fragile.

At 66% margin on the same project price, the business feels different. Delays don’t threaten the project economics. You can absorb one revision cycle without renegotiating. You can say yes to things without calculating whether it’s worth it.

Capacity Economics: How Output Per Person Changed

For most of our history, revenue growth required headcount growth. More projects meant more developers. More developers meant more management overhead. The scaling math was roughly linear, which meant growing the agency felt like carrying an ever-heavier backpack.

That relationship broke down in 2024. We processed 40% more client work in 2025 than in 2023 with a smaller development team. The decoupling is real.

What changed:

  • A senior developer now handles what two developers handled before. Not because they work longer hours – because the AI layer handles the output-production work and they handle the judgment work.
  • Onboarding time for new codebases dropped dramatically. Claude can read a codebase and produce an accurate architecture summary faster than a new developer can. New team members become productive on client code faster.
  • Documentation and handoff overhead nearly disappeared. AI-generated documentation is good enough that the “writing everything down” cost that used to consume senior developer time is now automated.
  • Parallel project capacity increased. A senior developer can context-switch across more projects because AI maintains the tedious context – test cases, documentation, boilerplate – that used to make context-switching expensive.

The implication for hiring: we hire fewer people, more senior, and we invest more in their tooling setup. The cost per hire went up. The headcount stayed flat or dropped. Revenue went up. This is what decoupled growth looks like in practice.

Pricing Mistakes I Have Watched Agencies Make

Mistake 1: Passing AI Savings Straight to the Client

This is the most common one. The logic sounds reasonable: AI cuts your costs, so you can cut your prices and win more work. The outcome is that you build a race to the bottom where the only competitive moat is being the cheapest AI-assisted shop.

Clients are not paying for your cost structure. They are paying for outcomes. If you deliver the same outcome faster and better, the price does not go down – the margin improves. The risk is that if you cut prices to reflect your AI efficiency, you anchor the market lower and everyone loses, including you when the next efficiency wave arrives and you have no more room to cut.

Hold the price. Improve the margin. Reinvest the margin into better tooling and better humans.

Mistake 2: Treating AI Tooling Costs as Overhead

Some agencies bundle API costs into general overhead and don’t track them per project or per client. That’s fine when the spend is $20/month. It becomes a problem at scale when you have dozens of projects running concurrent AI workflows and the spend is unpredictable.

Treat API spend like a materials cost – allocate a portion to each project, track it against the project margin, and review it monthly. You want to know which project types are efficient and which are consuming disproportionate API spend. The routing logic for model selection I covered in the Cost-First AI Stack post is specifically about this: using cheaper models for cheap tasks so the P&L stays clean.

Mistake 3: Racing to Eliminate All Human Costs

I’ve seen agencies respond to AI efficiency by trying to eliminate human costs entirely – fire the mid developers, cut the QA team, run everything through AI. The short-term margin looks great. The long-term result is delivery failures on complex work, client churn, and a reputation problem you can’t recover quickly.

AI does not replace senior judgment. It amplifies it. If you hollow out the senior layer, you lose the thing that makes the AI output valuable – the human who can tell whether the output is actually correct. The teams that are winning with AI are the ones that kept (or hired) senior people and gave them better tools, not the ones that tried to replace people with prompts.

What to Reinvest the Margin Into

When you go from 12% to 66% gross margin on project work, the question becomes: where does the difference go? Profit is the obvious answer, but the more strategic answer is: some of it goes into the investments that keep the margin high.

Tooling: The Compounding Asset

We reinvest a material portion of the margin improvement into internal tooling – MCP servers, custom agents, workflow automation. These are not one-time purchases; they compound. A QA agent we built six months ago has run on dozens of projects since. The per-project cost is now nearly zero. The upfront investment was absorbed by project three.

The discipline is treating tooling as capex, not expense. Build it once. Amortize it across projects. Track the utilization. If a tool isn’t used, depreciate it and stop maintaining it.

QA Gates: The Margin Insurance

The biggest margin killer in agency work is rework. A bug that gets to production and requires two days of senior developer time to diagnose and fix can wipe the margin on an entire project. AI-assisted output has a different failure mode than human-written code – it fails confidently on edge cases. That makes pre-production QA more important, not less.

We reinvest in QA infrastructure specifically: automated test suites, pre-commit hooks, staging environments that mirror production closely. The cost is real but the insurance value is higher. One prevented production incident pays for a quarter of QA tooling.

Productized Services: The Margin Multiplier

The highest-margin work we do is productized services – fixed-scope packages with a known delivery process. A WordPress plugin audit has a defined input, a defined process, and a defined output. The first time we did one it took twenty hours. Now it takes six. The price is the same. The margin is better every time we do it.

Productized services are where the combination of AI efficiency and process maturity compounds most aggressively. Reinvest margin into refining the process on each productized service. Document what AI handles. Document what humans check. Run the audit retrospective after every engagement. The service gets faster and more reliable with each iteration.

The Honest Version of the Transition

The margin math I showed above is accurate for where we are now. It was not accurate in month one of the transition. The first six months of going AI-first involved real costs: time spent on prompt engineering that didn’t pay off, AI output that needed more rework than expected, clients who were skeptical of the change in our process.

The transition had a learning curve that showed up in margin compression before the margin expansion. If you’re in that phase now – where AI feels like it’s creating work, not reducing it – that’s normal. The economics improve as the tooling matures and the team learns which tasks AI handles well and which it doesn’t.

The inflection point for us was when we stopped treating AI as a writing tool and started treating it as a workflow orchestration layer. The post on the AI-Agency Operating System covers what that looks like operationally. The P&L numbers I’ve shared here are what it looks like financially once the operating model is working.

The Bottom Line

Running an AI-first WordPress agency is economically different from running a traditional team-heavy agency. The differences that matter on the P&L:

  • Revenue per project stays flat or increases when you hold price and improve delivery quality
  • Cost structure shifts from labor-heavy to senior-light with API costs as a managed materials line
  • Gross margin expands significantly – from the 10-15% typical of hourly-billed agencies toward 60-70% on well-run project work
  • Headcount growth decouples from revenue growth – you can grow revenue without growing the team proportionally
  • The reinvestment cycle (tooling, QA, productized services) compounds the advantage over time

The risks are real too: AI output quality requires senior oversight to catch, clients need to be repriced appropriately rather than having savings passed through, and the tooling investment upfront requires margin that early-stage agencies may not have. None of those risks are reasons to avoid the transition. They’re reasons to plan it deliberately.

I track these numbers because the business decisions we make at Wbcom Designs need to be grounded in what’s actually happening on the P&L, not in how productive AI makes us feel. The numbers support the shift. Make them work for your agency too.