How Agencies Use Greta to Deliver Client Apps in Days, Not Months

TL;DR: AI app builders compress agency build phases from months to days, but the agency's value shifts to discovery, scoping, judgment, the harden phase, client management, and support --- it doesn't disappear. The workflow: tight discovery, prompt-driven build with the client in the loop, harden phase (the part that justifies the fee), handoff or retainer. Pricing must shift from hourly (which collapses and penalizes efficiency) to value-based and retainer. Offer code ownership, always include the harden phase, and lean into the expertise that's hard to replicate.

Introduction

Agencies that build software for clients face a disruption and an opportunity. AI app builders compress the build phase from months to days --- a client app that took a three-person team eight weeks can now have its core built in under a week. This breaks the traditional agency model (bill hours for building) and opens a new one (deliver outcomes fast, charge for value and judgment).

The agencies that thrive aren't the ones pretending nothing changed, nor the ones panicking that AI replaces them. They're the ones who recognize that when building is fast, the agency's value shifts to everything around the build: discovery and scoping, design and product judgment, the harden phase that makes generated apps production-ready, client management, and ongoing support. The build compresses; the expertise doesn't.

This guide covers how agencies use AI app builders to deliver client apps in days. The new workflow --- discovery, prompt-driven build with the client in the loop, harden phase, handoff or retainer. The pricing model shift from hourly toward value-based and retainer. What changes and what doesn't. And the honest realities --- including the harden phase that's easy to skip and the client-expectation management that fast delivery requires.

What changes (and what doesn't)

What compresses

• The build phase --- months to days for the core app
• Iteration speed --- changes in hours not sprints
• Prototyping --- clients see working software fast
• Time to first usable version

What doesn't change (the agency's real value)

• Discovery --- understanding the client's actual problem
• Scoping --- defining what to build and what not to
• Design and product judgment --- what good looks like
• The harden phase --- making generated apps production-ready
• Client management --- expectations, communication, trust
• Ongoing support and maintenance
• Domain expertise in the client's industry

The new agency workflow

Phase 1: Discovery and scoping (unchanged, still critical)

• Understand the client's real problem (not just their stated request)
• Define the core scope (what delivers value; what to defer)
• Map the data model and key workflows
• Set expectations about the fast build AND the necessary harden phase
• This phase is now a larger share of the project; invest in it

Phase 2: Prompt-driven build (compressed)

• Build the core with the AI app builder
• Client in the loop --- show working software early and often
• Iterate fast based on client feedback
• Days, not weeks
• The speed is the visible magic, but it's the smaller part of the value

Phase 3: The harden phase (the part that justifies the fee)

• Security audit (RLS, secrets, auth, input validation)
• Performance (indexes, queries)
• Error handling and monitoring
• Polish and edge cases
• Operations (deployment, backups, rollback)
• This is where agency expertise shows; clients can't do this themselves
• Skipping it is how agencies ship apps that break in production

Phase 4: Handoff or retainer

• Handoff --- deliver code (clients own it), document, train
• Retainer --- ongoing development, maintenance, support
• Retainer is increasingly the model (recurring revenue, ongoing relationship)
• Either way, the relationship continues beyond the build

The pricing model shift

Why hourly breaks

• If you bill hours and the build takes days, your revenue collapses
• Clients don't want to pay for hours; they want outcomes
• Billing hours penalizes your efficiency (the faster you are, the less you earn)
• Hourly is misaligned with the new reality

Value-based pricing

• Price on the value delivered, not hours spent
• A client app that runs their business is worth far more than the build hours
• Charge for the outcome (a production-ready app that solves their problem)
• The fast build is a margin advantage, not a reason to charge less

Retainer / productized services

• Monthly retainer for ongoing development and support
• Productized offerings (fixed-scope, fixed-price packages)
• Recurring revenue smooths the agency business
• Ongoing relationship beats one-off project churn

The pricing transition

• Move from hourly to value-based and retainer
• Communicate value, not time
• Don't compete on being cheap because you're fast --- compete on outcomes and expertise
• The agencies that lower prices to match faster builds race to the bottom

Code ownership matters for agencies

• Clients increasingly want to own their code (not be locked to the agency or a platform)
• Code-generating builders (Greta) produce real code in a repo the client can own
• Platform-locked tools complicate handoff and client ownership
• Offering code ownership is a selling point vs platform-locked competitors
• Clean handoff (documented, owned code) builds trust and referrals

What agencies can now offer that they couldn't

• Faster turnaround (days to first version)
• More projects in parallel (build compresses)
• Lower-budget clients become viable (faster build = accessible to smaller clients)
• Rapid prototyping as a paid discovery offering
• More iteration within the same budget
• Higher margins on the build phase

The risks and how to manage them

Risk: skipping the harden phase

• Fast build tempts shipping unhardened apps
• Apps break in production; reputation suffers
• Always include the harden phase; it's where your expertise shows
• Educate clients that fast build + hardening = the real deliverable

Risk: client expectation inflation

• Fast delivery makes clients expect everything fast
• Set expectations: build is fast; hardening, scoping, and judgment take real work
• Manage the 'if it's so fast, why does it cost that' conversation with value framing

Risk: commoditization

• If building is easy, what stops clients building themselves?
• Your value is discovery, judgment, hardening, and support --- not just building
• Lean into the expertise that's hard to replicate, not the build that's now easy

Common Mistakes

• Lowering prices because you're faster --- Race to the bottom. Charge for value and outcomes.
• Skipping the harden phase --- Apps break in production; reputation suffers. Always harden.
• Sticking with hourly billing --- Misaligned with fast builds. Move to value-based and retainer.
• Treating the build as the whole value --- Discovery, judgment, hardening, support are the value.
• Not offering code ownership --- Clients want to own their code. Offer it as a differentiator.
• Over-promising on speed --- Fast build doesn't mean the whole project is instant. Set expectations.
• Competing on being cheap --- Compete on expertise and outcomes, not price.
• Ignoring the retainer opportunity --- Recurring revenue beats one-off churn. Offer ongoing support.
• Pretending nothing changed --- The model shifted. Adapt the workflow and pricing.
• Panicking that AI replaces agencies --- It shifts the value; it doesn't eliminate the expertise.
• Poor handoff --- Undocumented, messy handoff loses trust. Deliver clean, owned, documented code.
• Skipping client education --- Clients need to understand build vs harden vs ongoing. Educate them.

Frequently Asked Questions

Q1: Does AI replace software agencies? No --- it shifts their value. Building compresses to days, but discovery, scoping, design judgment, the harden phase, client management, and ongoing support remain. Agencies that lean into expertise thrive; agencies that only sold build hours struggle. The model shifts; the expertise matters more.

Q2: How should agencies price now? Move from hourly to value-based and retainer. Billing hours collapses when builds take days and penalizes your efficiency. Price on outcomes (a production-ready app worth far more than the build hours) and offer retainers for recurring revenue and ongoing relationships.

Q3: What's the harden phase and why does it matter? It's making the fast-generated app production-ready --- security audit, performance, error handling, monitoring, operations, edge cases. It's where agency expertise shows and what clients can't do themselves. Skipping it ships apps that break in production. It's a core part of the deliverable, not an extra.

Q4: Won't clients just build it themselves? Some will try; building is easier now. But discovery (understanding the real problem), judgment (what good looks like), hardening (production-readiness), and ongoing support are hard to replicate. Agencies that sell those, not just building, stay valuable. The build being easy is exactly why the surrounding expertise matters more.

Q5: Should agencies offer code ownership? Yes --- increasingly a selling point. Clients want to own their code, not be locked to an agency or platform. Code-generating builders produce real code the client can own. Clean, documented handoff of owned code builds trust and referrals; platform lock-in complicates it.

Q6: How do I handle 'if it's so fast, why does it cost that'? Value framing. The build speed is your margin advantage, not a reason to charge less. The deliverable is a production-ready app that solves their problem and runs their business --- worth far more than the hours. Educate clients that fast build plus hardening plus judgment is the real value.

Q7: What's the biggest opportunity for agencies? Higher margins and more projects via compressed builds, plus retainer relationships for recurring revenue. Lower-budget clients become viable. Rapid prototyping becomes a paid discovery offering. The agencies that adapt pricing and lean into expertise capture more value than the old hourly model allowed.

Conclusion

• AI app builders compress agency build phases from months to days, but the agency's value shifts to discovery, scoping, judgment, the harden phase, client management, and support --- it doesn't disappear.
• The workflow: tight discovery, prompt-driven build with the client in the loop, harden phase (the part that justifies the fee), handoff or retainer.
• Pricing must shift from hourly (which collapses and penalizes efficiency) to value-based and retainer. Charge for outcomes, not hours. Don't race to the bottom on price because you're fast.
• Offer code ownership, always include the harden phase, manage client expectations, and lean into the expertise that's hard to replicate. The build is now easy; the surrounding expertise is the value.

If you run an agency, adapt deliberately. The build phase compressing to days is an opportunity, not a threat --- but only if you shift your model. Invest more in discovery and scoping (now a larger share of the project). Always include the harden phase; it's where your expertise shows and what clients can't do themselves. Move pricing from hourly to value-based and retainer. Offer code ownership as a differentiator. Manage the expectations that fast delivery creates. The agencies that thrive in 2026 deliver client apps in days AND charge for the judgment, hardening, and support that make those apps production-ready and maintained. Compress the build. Charge for the value. Lean into the expertise that AI can't replace.