The full flow — from cold inquiry to monthly retainer
A typical Antigravity contract engagement runs through eight steps from first contact to ongoing operations. This article walks each step, focusing on the operational walls indie developers actually hit and the patterns that work.
| Step | Typical duration | Main artifact |
|---|
| 1. Discovery call | 1 day–1 week | Project notes |
| 2. Rough estimate | 2–3 days | Price-range proposal |
| 3. Requirements definition | 1–2 weeks | 3–5 page spec doc |
| 4. Contract signing | 3–7 days | Engagement agreement |
| 5. Build | 2–6 weeks | Working agent + demo |
| 6. Acceptance testing | 1–2 weeks | Acceptance signoff |
| 7. Delivery + initial ops | 1–2 weeks | Operations manual |
| 8. Monthly operations | Ongoing | Monthly report |
Step 1 — Discovery: ask about the automation boundary first
The most important thing to establish in the first conversation is the boundary between "work humans will keep doing" and "work the agent will take over." Antigravity agents tend to look like they could automate everything, which inflates client expectations dangerously.
Five questions I always ask in discovery:
First: "Who does this work today, on what cadence, and how much time does it take?" This produces both volume estimates and a defensible time-savings dollar figure.
Second: "If this work were automated, what would they do with the recovered time?" This sounds simple but is diagnostic — clients who can't answer typically aren't seriously committed to automating.
Third: "Have you tried to automate this before?" If yes, the reasons it didn't stick usually surface human-side operational issues, not technical ones, and those will dominate this project too.
Fourth: "What's the worst possible mistake this process could make?" The answer drives accuracy targets and error-handling design.
Fifth: "May I ask what budget range you have in mind?" Asking directly, in the first conversation, prevents weeks of estimate misalignment later.
Step 2 — Estimate: price as a three-layer build-up
Pricing is the part of contract work that paralyzes most indie developers. The build-up I use:
Initial-build pricing
Initial = (build hours × hourly rate)
+ (requirements hours × hourly rate)
+ (verification hours × hourly rate)
× 1.2 buffer
Sustainable hourly rates for Antigravity-specialty solo work are $80–$150/hour. Below that, ongoing operations will burn you out emotionally even if the dollar amount looks reasonable.
Monthly retainer pricing
Monthly = (monthly hour cap × hourly rate)
+ (forecast Antigravity / Gemini API cost × 1.5)
Marking up API cost protects you when a user does something unexpected and inflates token consumption.
Presenting the price to the client
When you present the bundle, the 3:1 to 5:1 ratio of initial-build to monthly retainer lands most comfortably with clients. A $3K initial pairs naturally with $600–$1K/month, for example.
Step 3 — Requirements: keep the spec to 3–5 pages
Specs that are too long don't get read. The template I use covers six sections in 3–5 pages:
- Background and goal — why this needs to be automated (½ page)
- Current state — how the work happens today (1 page)
- Future state — what the agent does, what the human approves (1 page)
- I/O specification — exact data shapes in and out (1 page)
- Exception handling — what happens when things go wrong (½ page)
- Operations — who watches what when, monthly report contents (½ page)
Specs longer than 10 pages don't get read by the buyer, which means "this isn't what I expected" complaints at delivery.
Step 4 — Contract: five clauses indie developers must include
Generic engagement agreements miss several Antigravity-specific risks. Five clauses I always include:
Clause 1 — Acceptance criteria
"Acceptance is satisfied when deliverables meet the input/output specification recorded in the requirements document." Without this, clients can subjectively claim "it's not done yet" indefinitely.
Clause 2 — Change orders
"Requirement additions or changes after contract signing require a separate written estimate and mutual agreement before execution." Without this, you'll be asked for unpaid feature additions.
Clause 3 — External API change handling
"Failures caused by changes to external APIs (Gemini API, Antigravity platform, etc.) are addressed within the monthly retainer scope. Changes requiring fundamental redesign are subject to separate estimates." On a young platform, breaking changes happen 2–4 times per year.
Clause 4 — Data handling and confidentiality
"Business data acquired during the engagement will not be disclosed to third parties for the duration of the contract and for 5 years following its termination." For Antigravity specifically, always confirm sector-specific regulations with the client before agreeing on data flows.
Clause 5 — Termination
"Either party may terminate the monthly retainer with 30 days written notice." Without this clause, clients ask for indefinite extensions while their replacement vendor onboards.
Steps 5–6 — Build and acceptance: show a working demo every 1–2 weeks
The single most important practice during the build is showing a working demo to the client every 1–2 weeks. Going dark until final delivery dramatically increases the likelihood of "this isn't what I imagined."
For Antigravity agents specifically, that means standing up a minimal web UI early (Streamlit, Gradio, or a tiny Next.js page) so the client can interact with the agent themselves. This single change cuts requirement-misunderstanding incidents to a small fraction of what it would otherwise be.
Acceptance testing should be executed by the client, against scenarios derived from their actual workflow. Engineer-written test cases miss the kinds of edge cases that real users encounter.
Step 7 — Delivery: a one-page operations manual that protects you
At delivery, write a one-page operations manual. Without it, post-delivery support tickets start at "I don't know how to use this," and the included monthly hours evaporate fast.
Five required sections:
- When the agent runs automatically (e.g., daily at 9am)
- What humans need to verify (which classes of agent output require human approval)
- What to do when an error occurs (self-service recovery steps)
- Contact and response window (clearly within retainer scope)
- What is not included in the monthly retainer (feature additions, new capabilities, after-hours support)
Section 5 is the most important. Without it, every request feels like it should be inside the retainer, which destroys your gross margins.
Step 8 — Ongoing operations: where the real margin lives
Most indie developers underestimate that the ongoing-operations phase is where contract work becomes truly profitable. Initial-build margins typically run 20–40%; once monthly operations stabilize, gross margins climb to 70–90%.
Three predictable trouble patterns
Trouble 1 — Scope creep
"While you're at it, can you also automate this?" requests need to be politely declined. "That's outside our current scope; I'll prepare a separate estimate." Saying yes once invites endless future asks.
Trouble 2 — External API breaking changes
Both Gemini API and Antigravity ship breaking changes 2–4 times per year. Triage by Clause 3: fixes under ~10 hours fall inside the retainer; anything larger is a separate estimate.
Trouble 3 — Personnel handoffs on the client side
When the client's point of contact changes, the new person typically wants a full reintroduction. Up to 30 minutes is inside the retainer; beyond that, a paid onboarding package ($300–$500 flat) is reasonable.
The monthly report
To make the monthly retainer feel earned, send a short monthly report with three sections:
- Agent execution counts and success rate this month
- Estimated time savings (hours × salary equivalent)
- One improvement proposal (a seed for a future change order)
The presence or absence of this report changes retention dramatically. In my own data, retainer clients who receive monthly reports stay an average of 1.5 years; those who don't average around 8 months before churning.
A realistic year-one revenue plan toward $80K/year
A practical year-one plan for an indie developer doing Antigravity contract work:
| Line item | Count | Unit | Annual |
|---|
| Initial build (Pattern 1: sales automation) | 4 | $3,500 | $14,000 |
| Initial build (Pattern 2: accounting) | 3 | $4,500 | $13,500 |
| Initial build (Pattern 3: marketing volume) | 6 | $1,800 | $10,800 |
| Monthly retainer (13 clients, blended) | 13 × 12 | $400 avg | $62,400 |
| Total | | | ~$100,700 |
The crucial structural point: trying to hit $100K from initial builds alone produces unmanageable project volume. The retainer book has to carry over half of annual revenue. That's the entire reason building the retainer book is a strategic priority, not just a nice-to-have.
Migrating from contract work to SaaS in year two
After ~12 months of contract work and 10+ retainer clients, the SaaS migration window opens. The smoothest migration runs in three phases.
Phase 1 (late year 1): Extract patterns common across multiple clients into shared internal modules. This alone reduces ongoing-operations hours.
Phase 2 (early year 2): Publish the shared modules as a customizable SaaS. Position new sales as "SaaS with custom configuration." Drop pricing relative to bespoke contract work — initial $3K → $1K, monthly $400 → $300 — to widen the funnel.
Phase 3 (late year 2 onward): Operate as pure SaaS. Stop accepting new bespoke contracts. Existing clients stay on a special grandfathered tier; new clients get the self-serve product.
This phased migration converts the relationships and domain understanding you built during contract work into the foundation of the SaaS, which gives the SaaS a much higher hit rate than building one from scratch.
Closing
Antigravity contract work is determined less by technical difficulty than by the operational discipline of pricing, contracting, and delivery. Most indie developers exhaust themselves on early projects through one of three failure modes: underpricing, ambiguous contracts, or runaway ongoing operations. Every one of those is preventable with the patterns in this guide.
Take this playbook and start your first project. The most actionable next step: list three plausible client candidates this week, schedule the first discovery call within two weeks. The hardest part is the first call. Once you've had it, the rest of this flow is mechanical.