How to Price a Claude Code Agency Project: Why Hours Are the Wrong Unit
Straight up - the second you put hours on a Claude Code invoice, you've capped your own ceiling. The model gets faster every quarter. Your rate doesn't. So a project that took two days last spring takes six hours today and three hours next year, and if you're billing by the hour your invoice shrinks every cycle. That's the wrong direction for a business.
The right unit to sell is the outcome - the thing the client actually wanted before they ever heard the word "Claude." A small business doesn't want "twelve hours of MCP setup"; they want a Gmail-to-CRM automation that saves their ops manager an afternoon a week. A SaaS founder doesn't want "prompt engineering hours"; they want a working onboarding agent. Price the outcome and the arbitrage of using Claude Code stays in your column, where it belongs.
I spent eight years inside Apple, PlayStation, and Schwab. The thing those teams all had in common? Nobody could ship under three months. A Claude Code agency can deliver the same scope in three weeks. That speed gap is the entire arbitrage - and you only capture it if you price on what you delivered, not how long it took.
Step 1: Name the Outcome, Not the Tech
The first move in any pricing conversation is to translate the technology back into the language the client already uses. Don't sell an "MCP server." Sell "a Gmail-to-CRM automation that runs every morning at 7 a.m." Don't sell "a Claude Code agent." Sell "a weekly client report your ops manager doesn't have to write anymore." The client buys the outcome, the tech is invisible, and your scope-of-work reads like a deliverable instead of a hobby.
Here's a concrete shape. I shipped a Gmail-to-CRM agent to a real-estate client last month. On paper it's an MCP server plus a Claude Code cron prompt - maybe a weekend of work. On the invoice it's "Inbound lead routing automation," priced as a $2,400-a-month retainer. Same code. Completely different conversation. The work isn't the agent. The work is naming the outcome the client already wants and pricing it like infrastructure.
Step 2: Pick a Pricing Shape That Matches the Work
There isn't one correct way to price a Claude Code agency project - there are four, and the trick is matching the shape to the kind of work. Hourly is almost always the wrong call for the reasons above. The other three each fit a different engagement type cleanly.
Pricing shape vs the kind of work it fits
| Pricing shape | Best for | Example deliverable | Typical range |
|---|---|---|---|
| Fixed scope | One-off builds with a clear definition of done | A booking site, a Stripe checkout funnel, an internal tool replacing a spreadsheet | $1.5K – $15K per project |
| Monthly retainer | Ongoing agents, automations, or systems that need maintenance | A lead-routing agent, a weekly report bot, a Slack-to-Notion sync | $1.5K – $8K / month |
| Per-deliverable / productized | The same thing sold to many clients with light tweaks | A Stripe buy-button install, a booking widget, an onboarding-form-to-CRM hookup | $500 – $3K each |
| Hourly | Almost nothing in this category. Use only for true discovery work, capped | A two-hour audit of an existing stack before scoping a real engagement | Avoid for delivery |
Most new AI shops default to hourly because it feels safe. It's the opposite. Hourly invites clients to renegotiate every line and trains them to value your time the same way they'd value an assistant's. Pick one of the top three shapes per engagement and the conversation becomes about scope, not the clock.
Step 3: Anchor on the Replaced Cost
The single most useful number in any pricing conversation isn't your cost - it's the client's. Specifically, what was the thing they were doing (or paying) before you showed up? An ops manager spending six hours a week on a manual lead handoff is a $30K-a-year cost line. A $2,400-a-month automation that eliminates that work is a 20% saving, not an expense. That's the framing that makes a retainer obvious.
The math runs the same direction across every engagement. A small business pays a part-time bookkeeper $1,500 a month. A scoped "books-to-dashboard" automation at $1,800 a month is more expensive on paper and a third the cost on outcomes. A founder pays a junior dev $7K a month to glue together their stack. A retainer at $5K that does the same gluing with Claude Code and one MCP server is a $24K-a-year saving for the client and a higher-margin engagement for you. Anchor every quote on the replaced cost and the price stops feeling like a number you made up.
Step 4: Build a Three-Tier Offer Stack
Once you've named the outcome and picked the shape, present three tiers - good, better, best - and let the client pick. This single move eliminates 80% of the back-and-forth that kills new agency deals. Instead of negotiating one price, the client is choosing between three versions of the same offer, which is a completely different psychological exercise.
- Tier 1 - the minimum viable engagement. The deliverable, no maintenance, no support beyond a two-week bug-fix window. The price an unsure client can say yes to.
- Tier 2 - the standard package. Deliverable plus a month of refinement, plus one round of changes after launch. This is the tier most clients pick.
- Tier 3 - the agency-of-record tier. Deliverable plus a recurring retainer for ongoing maintenance, new feature requests, and quarterly upgrades. This is the tier that builds the business.
Price the tiers so the middle one is the obvious value. The first tier exists to make the second look like a steal; the third tier exists so the second doesn't feel like the ceiling. Most clients will land on tier two on their own, which is exactly what you want. And once they're in tier two, upgrading to tier three is a conversation, not a sale.
Step 5: Lock the Scope on Paper (Even at $5K)
Pricing without a scope-of-work is the single fastest way to bleed a Claude Code engagement. Every "can you just add this one thing" is free money out of your pocket if it's not in writing. Even a small fixed-scope project deserves a one-page SOW: deliverable, exclusions, timeline, payment terms, and what "done" looks like. Especially exclusions. Most scope creep happens because the client genuinely thought a feature was included and you genuinely thought it wasn't.
The SOW doesn't need to be a 20-page legal document. The shape that works for most engagements under $15K is: one paragraph naming the outcome, a bulleted list of exactly what's included, a bulleted list of what's explicitly NOT included, a single-line timeline, and a payment-terms line (50% on signing, 50% on delivery is the default that works almost everywhere). One page. Sent before any work starts. Signed back before you write a single prompt. That single discipline saves more revenue than any rate increase.
Common Pricing Traps for New AI Agencies
A handful of pricing mistakes kill more new AI shops than anything technical. They're all preventable with a single decision up front.
- Hourly for agents. An agent runs forever and gets faster every model release. You'll be invoicing zero hours in eighteen months. Price it as infrastructure on a retainer instead.
- Refusing a deposit. The minute you start work without money in hand, the project's priority drops on the client's end. 50% upfront isn't aggressive - it's normal, and asking for it filters out the engagements that would have ghosted you anyway.
- Discounting for "the first client." Every new shop does this and regrets it within ninety days. Discounted clients refer more discounted clients. Start at the rate you want to sustain, even if the first deal takes longer to close.
- Selling discovery for free. A two-hour scoping call IS the engagement starter - charge a small fixed fee for it, credit it against the full engagement if they sign, keep it if they don't. This single move cuts your pipeline noise in half.
- Promising support you didn't price. If maintenance isn't in the SOW, every "quick fix" the client asks for after launch is unpaid work eating your next engagement's margin. Bundle a defined support window or quote a retainer - don't do open-ended.
None of these are about being aggressive. They're about pricing the way a real services business prices, which is what a Claude Code shop is - even when it's one person and a laptop. Hold the line on the five above and the rest of the math takes care of itself. For more on the agency-side of building with Claude Code, the full playbook lives on the Duncan author page and on the Claude Code Club blog under the Monetization tag.
Frequently asked questions
How do I price a Claude Code agency project as a beginner with no portfolio?
Start with a productized offer - pick one specific outcome (a Gmail-to-CRM automation, a Stripe checkout install, a booking widget) and price it as a fixed package in the $500–$1,500 range. You're not selling your time, you're selling a finished thing. That makes the first sale easier and gives you something portfolio-able for the next one.
Should I ever charge hourly for Claude Code work?
Almost never for delivery. Hourly invites the client to renegotiate every line and trains them to value your time like an assistant's. The only real exception is paid discovery - a short, fixed-fee scoping call (often credited against the full engagement) so the conversation has skin in the game.
How much does a typical Claude Code agency project cost?
Fixed-scope builds usually land between $1,500 and $15,000 depending on integration count. Retainers for ongoing agents tend to sit between $1,500 and $8,000 a month. Productized deliverables (booking widgets, checkout installs, single automations) run $500 to $3,000 each. The exact number depends entirely on the replaced cost on the client's side.
What if the client wants to know how long it took me?
Tell the truth: "twelve years of context plus a weekend." The pricing isn't a timesheet - it's the outcome. If you've named the deliverable correctly and anchored on what you replaced for them, the time conversation rarely comes up. When it does, redirect to the value of what's now running for them automatically.
Do I need a contract for projects under $5,000?
Yes, but a single-page scope-of-work is plenty. Outcome paragraph, included list, excluded list, timeline, payment terms (50% on signing, 50% on delivery). One page, signed before work starts. That single discipline prevents the scope creep that quietly eats margin on every small engagement.
How do I justify a retainer to a client who's never paid for one?
Anchor on the replaced cost. If the automation saves them six hours a week of an ops manager's time, you're charging a fraction of what they were already spending. Frame it as ongoing infrastructure, not subscription software. The retainer covers maintenance, model upgrades, and quarterly improvements - three things they'd otherwise have to manage themselves.
Last reviewed by Duncan Rogoff on June 4, 2026
