Antigravity × Cursor × Claude Code — A Practical 3-Tool AI Development Workflow for 2026
Combining Antigravity (agent-first), Cursor (surgical edits), and Claude Code (automation) for real-world development. Phase-by-phase tool selection, AGENTS.md as a shared contract, measured cost analysis from an indie developer running several apps and sites in parallel.
In the first week of running three AI IDEs side by side, I started every morning asking myself which one to open. That hesitation was the most expensive part of the day.
It went badly. Picking by mood meant naming and typing conventions drifted inside a single feature, and aligning them afterwards cost more than the code did. So I decided who leads each phase before the phase begins.
Antigravity (agent-first, large context, spec-driven), Cursor (local edits, model choice, JetBrains support), and Claude Code (terminal-native, parallel worktrees) don't overlap much in what they're good at. That's the point: once you've decided who gets the work and when, one person can run something close to a small team.
What follows is that allocation table, AGENTS.md as the shared contract, a five-day example, and a way to measure rather than assume. Prices, limits, and available models change quickly, so treat the figures below as worked examples and check each official page before you commit.
Chapter 1: The Three Tools Compared
Antigravity: Agent-first Architecture
Core traits:
Multi-agent system design (16 specialized agents)
1M token context window
Spec-driven development (define requirements, agents execute)
Manager View orchestrates all agents
40+ skills, 11 commands
Excels at:
Large-scale architecture — Multiple expert agents weigh in on design simultaneously
Pricing: Plans differ in parallelism and usage caps. Check the official pricing page for current numbers.
Comparison Matrix
Dimension
Antigravity
Cursor
Claude Code
Best Phase
Design, large-scale
Implementation, tweaks
Automation, CI/CD, parallel
Context Size
1M tokens
100-300k tokens
200k tokens
Execution Speed
Slow (5-15 min)
Fast (seconds–1 min)
Medium (1-3 min)
IDE Integration
Web-based
VSCode, JetBrains
CLI only
Files per Task
20-30
5-10
Precision-targeted
Model Selection
Gemini family (available models change)
Multiple vendors
Claude models (via API)
Offline
No (Web API)
Yes (Ollama)
No (API-required)
Multi-agent
Yes (16 agents)
No (single LLM)
Partial (scripts)
Monthly Est.
Varies by plan and usage
Varies by plan
Varies by usage
✦
Thank you for reading this far.
Continue Reading
What follows includes implementation code, benchmarks, and practical content we hope you'll find useful. This site runs without ads — server and development costs are supported entirely by members like you. If it's been helpful, we'd be truly grateful for your support.
WHAT YOU'LL LEARN
✦A phase-by-phase table of which tool leads, plus a five-day walk-through of one feature moving across all three
✦A measurement sheet for wait time, rework, and review time, so you stop trusting headline numbers and start trusting your own
✦An AGENTS.md written as a contract, and the wording that keeps each tool inside its role
Secure payment via Stripe · Cancel anytime
✦
Unlock This Article
Get full access to the rest of this article. Buy once, read anytime. This site is ad-free — your support goes directly toward keeping it running.
Show concrete code examples from existing patterns
Sanity-check design against actual implementation patterns
Phase 1: Architecture & Skeleton (Week 3-4)
Priority: 1st Antigravity, 2nd Claude Code
Build the project scaffold in parallel using Antigravity's agent parallelization.
Antigravity full throttle
Antigravity prompt:
"Specification v1.0 in hand. Build in parallel:
L1: Project Coordinator
├ L2: Backend Architect
│ Deliver: OpenAPI 3.0 spec, DB schema
│ Due: Day 2
│
├ L2: Frontend Builder
│ Deliver: Component design doc, Storybook setup
│ Due: Day 2
│
└ L2: DevOps Engineer
Deliver: Kubernetes manifests, Docker setup
Due: Day 2
After all complete, generate integration test template."
Time: 1-2 days (3 agents parallel)
Output: API spec, UI inventory, deploy config
Cost: 1 agent-day effective (3 agents paralleled → wall time 1 day)
Claude Code for IaC generation
After skeleton is set, generate cloud infrastructure.
Claude Code prompt:
"AWS Terraform config for:
- VPC, subnets, security groups
- ECS (Fargate), RDS (Postgres), ElastiCache (Redis)
- CloudFront + S3 origin
- CloudWatch + SNS monitoring
After generation, execute `terraform plan` and show diff."
Time: 30 min
Executable: Terraform apply ready
Confidence: High (IaC syntax validated)
Phase 2: Feature Implementation (Week 5-12)
Priority: 1st Cursor, 2nd Claude Code, 3rd Antigravity
This longest phase shows tool strengths most starkly.
Cursor: Main development machine
Pattern A: Existing code modification
Cursor prompt:
"In src/pages/signup.tsx, after the <form> tag, add OAuth login button.
Use component: OAuthButton (already imported)
Style: match existing buttons (Tailwind)
File: signup.tsx only"
Time: 30s–1 min
Changed lines: 3-5
Seamlessness: Perfect (Cursor infers style, dependencies automatically)
Cursor's @-mention precision prevents AI hallucination. Existing patterns are auto-inferred.
Pattern B: New module
Cursor prompt:
"New module src/services/purchaseAnalytics.ts
Function: getPurchaseStats(userId: string): Promise<PurchaseStats>
Requirements:
- Last 3 months of data
- Redis cache (1h TTL)
- Return null if user not found
- Reference: src/services/userService.ts pattern
Implement function + types."
Time: 2-3 min
Lines: 30-50
Test: Separate (Claude Code handles)
While Cursor implements, Claude Code builds test suites and CI/CD.
Claude Code prompt:
"Jest test suite for purchaseAnalytics.ts
Test cases:
1. Happy path: fetch 3 months user data
2. Cache: 2nd call hits Redis
3. Error: nonexistent user returns null
4. Resilience: Redis down → fallback to DB
After coding, run `npm test`."
Time: 3-5 min
Lines: 40-60
Coverage: 90%+
Confidence: High (automated verification)
Expand to GitHub Actions:
Claude Code prompt:
"Update .github/workflows/ci.yml for:
- npm test on push
- Coverage comment on PRs
- Auto-deploy staging after main merge
Tech: Node 20, postgres test DB, < 5min runtime"
Time: 2-3 min
Reuse: Every future release (2-3 min instead of 15)
ROI: Immediate
Antigravity: When decision-making is needed
Antigravity shines when implementation touches requirements.
Example: "Should we expand the API spec?"
Antigravity prompt:
"Current status: Backend 80% done, Frontend 60%.
Security review flagged: API response missing compliance field.
Decision needed:
A) Expand API spec + change Frontend type defs (both 1d delay)
B) Satisfy compliance via alternative approach?
AGENTS.md + Spec v1.0 as reference. What's optimal?"
Time: 3-5 min
Output: Architecture Decision Record (what + why)
Confidence: All perspectives vetted
Phase 3: Integration & QA (Week 13-14)
Priority: 1st Claude Code, 2nd Cursor, 3rd Antigravity
Claude Code: Automation backbone
Claude Code prompt:
"Playwright E2E test: user signup → login → search → purchase flow
Steps:
1. Register
2. Login
3. Search products
4. Add to cart
5. Checkout
6. Verify confirmation email
Constraints: Staging env, < 3 min, screenshots on failure
Run `npm run test:e2e` after."
Time: 10-15 min
Lines: 100-150
Trust: 95%+ (human testing supplement)
Add performance measurement:
Claude Code prompt:
"Daily Lighthouse audit (Staging env).
Metrics: LCP, FID, CLS, Performance Score
Diff from yesterday? Alert to Slack.
Store results as JSON (time-series)"
Time: 5 min
Continuous benefit: Daily visibility
Cursor: Performance optimization
Cursor prompt:
"src/components/ProductList.tsx is slow.
Implement:
1. React.memo (prevent re-render)
2. useCallback for event handlers
3. useMemo for expensive computations
Compare Lighthouse before/after."
Time: 2-3 min
Gain: LCP -0.5s, FID -30ms typical
Phase 4: Security & Compliance (Week 15)
Priority: 1st Antigravity, 2nd Claude Code
Antigravity prompt:
"Security pre-release review.
Check:
- OWASP Top 10
- Dependency vulnerabilities
- .env management
- GDPR / data protection
- Encryption (transit + at-rest)
Output: Review Report with Priority-ranked fixes"
Time: 30 min–1 hour
Output: Go/no-go gate decision
Scope: All backend, frontend, infra code
Cursor implements fixes:
Cursor prompt:
"Address Security Review Priority-1 items:
1. Validate Bearer Token strictly (src/api/auth.ts)
2. Prepared statements everywhere (src/db/queries.ts)
3. Populate .env.example with all vars
Reference: AGENTS.md Security section"
Time: 15-20 min
Phase 5: Production Deployment (Week 16)
Priority: 1st Claude Code, 2nd Antigravity
Claude Code prompt:
"Deployment pipeline:
Steps:
1. Git tag v1.0.0
2. Docker image → ECR
3. Update K8s manifest with new tag
4. Deploy to Staging + smoke test
5. Canary deploy (5% → 25% → 100%)
6. CloudWatch monitoring (auto-rollback if error rate > 1%)
After, update README with deployment docs"
Time: 20-30 min
Reuse: Every release (2-3 min)
Confidence: Automated, human error eliminated
Chapter 3: AGENTS.md as Cross-Tool Glue
Multi-tool risk: divergence. "Python in Antigravity, JavaScript in Cursor" creates integration hell later.
Solution: AGENTS.md, a single source of truth for all tools.
AGENTS.md with tool-specific sections
# AGENTS.md — Team Development Standards## Tech Stack (ALL TOOLS)- Frontend: TypeScript 5.x + React 18 + Tailwind 3.x- Backend: TypeScript 5.x + Node.js 20 + Express 4.x- Database: PostgreSQL 15- Infra: Terraform 1.6.x## Code Standards (ALL TOOLS)- ESLint: strict mode- TypeScript: strict mode- Test coverage: >= 80%- Prettier: line width 100## Tool-Specific Scopes### Antigravity- When: Spec definition, large architecture decisions- Outputs: Markdown docs, Architecture Decision Records- Deliverables: Specification v1.0 → immutable### Cursor- When: Feature implementation, code modification, review response- Config: VSCode settings.json, .eslintrc.json (shared)- Output: Git commits, PRs### Claude Code- When: Test automation, CI/CD, scripts, performance measurement- Language: Bash, Python, GitHub Actions YAML- Outputs: Executable scripts, monitoring dashboards## Cross-Tool ValidationSpec (Antigravity) → Implement (Cursor) → Test (Claude Code) → Architecture check (Antigravity)For this loop to close, all tools must share typing, naming, dependencies via this AGENTS.md.
Sync workflow
Week 0: Antigravity creates Specification v1.0 + AGENTS.md v1.0
Week 1-16: Changes happen
On change (e.g., "add new ESLint rule"):
1. Update AGENTS.md
2. Notify Cursor, Claude Code
3. Apply to new code immediately, old code gradually
Week 16: Final review
Does everything conform to AGENTS.md?
If yes → production gate passed
Chapter 4: Real-world Example — Recommendation Engine
Day 1: Antigravity spec
Antigravity prompt:
"Recommendation engine feature.
Requirements:
- Suggest products based on user purchase history
- Hourly batch processing
- Mobile + web compatible
Output: Full Specification including:
- API: GET /recommendations/{userId}
- Response: [{ productId, score }]
- Cache: 1h TTL
- DB schema: user_interactions, product_recommendations
- Infra: Kubernetes CronJob, resource estimates"
Time: 3-4 hours
Output: Specification v1.0 + AGENTS.md confirmations
Day 2: Claude Code batch script
Claude Code prompt:
"Batch recommendation processor.
Input: user_interactions table (100M rows)
Algorithm: Collaborative Filtering (simplified)
Output: product_recommendations table
Runtime: < 30 min (hourly execution)
Memory: < 512 MB
Retry: Auto 3x on error
After: simulate 1M users with test data"
Time: 2-3 hours
Language: Python + PostgreSQL
Lines: 100-150
Validation: Local test with 1M rows
Day 3: Cursor frontend
Cursor prompt:
"ProductCard component: add recommendation badge.
Changes to src/components/ProductCard.tsx:
- Show recommendation score (0-100) as gauge
- Score >= 70 → light blue background
- Click → "Why recommended?" modal
Reference: Figma ProductCard design"
Time: 5-10 min
Lines: 15-20
Next:
"Hook useRecommendations(userId)
Calls: GET /api/recommendations/{userId}
Manages: loading, error, cache (1 min)
Use in: ProductPage component"
Time: 3-5 min
Hook lines: 30-40
Day 4: Claude Code tests
Claude Code prompt:
"E2E test: Recommendations end-to-end
Flow:
1. Home page shows recommendations
2. Click recommendation → detail page
3. View "Why recommended?" modal
4. Add to cart from recommendation
Test data: test_user_001 (100 purchase history)"
Time: 20 min
Lines: 60-80
Coverage: All major flows
Also:
"Batch job monitoring script
Alert conditions:
- Execution time spike (> 50%)
- Memory > 512 MB
- Error rate > 1%
- Unusual recommendation counts
Output: Slack + Grafana"
Time: 15-20 min
Continuous value: 24/7 observability
Day 5: Antigravity integration
Antigravity prompt:
"Final integration check before production.
Verify:
1. Batch script working (Claude Code report)
2. Frontend displays correctly (Cursor + E2E tests)
3. API SLA met (< 500ms)
4. DB indexes optimized
5. Go/no-go decision"
Time: 1-2 hours
Output: Integration Report + Go/no-go
Timeline: 5 days (vs. 10-12 days single-tool)
Chapter 5: Cost Analysis
The yen amounts and day counts below are placeholder assumptions meant to show the shape of the argument. Plan prices and project rates differ for everyone, so look at which lines add and which multiply, not at the totals.
Scenario 1: Single tool (Cursor only)
Tool: Cursor Pro ¥2,000/month
Per feature (5 days):
- Cursor implementation: 4 days
- Manual testing: 0.5 days
- DIY CI/CD scripts: 0.5 days
Total: 5 days @ ¥20k/day = ¥100k human
Monthly (1 feature): ¥2k tool + ¥20k human = ¥22k
Scenario 2: 3-tool portfolio
Tools: ¥5k (Antigravity) + ¥2k (Cursor) + ¥3k (Claude) = ¥10k/month
Per feature (5 days):
- Antigravity spec + design: 0.5 days (multi-agent parallel)
- Cursor implementation: 2 days (fewer bugs from spec)
- Claude Code tests + CI/CD: 1 day (then auto-running)
- Deploy + monitoring: 0.5 days (scripts exist)
Total: 4.5 days @ ¥20k/day = ¥90k human
Monthly (1 feature): ¥10k tool + ¥18k human = ¥28k
Apparent gap: ¥6k extra. But look closer:
Multi-month view (regression testing savings)
Month 1 (single tool):
New feature: 5 days
Regression (manual): 3 days
Total: 8 days/month
Months 2-6 (3-tool portfolio):
New feature: 4.5 days
Regression (automated): 0.5 days ← Claude Code CI/CD
Total: 5 days/month
Savings per month (M2-6): 3 days = ¥60k saved
6-month ROI
Single tool:
Tools: ¥2k × 6 = ¥12k
Human: ¥20k × 6 = ¥120k
Total: ¥132k
3-tool:
Tools: ¥10k × 6 = ¥60k
Human: ¥18k + (¥12k × 5) = ¥138k ← savings kick in M2+
Total: ¥198k
Apparent: ¥66k more
**Whether it pays off** depends on your own rates: build the same table with your numbers before deciding.
Plus assumed effects (illustrative, not measured):
- Feature velocity: 6 features vs. 5 (20% gain)
- Bug rate: 3% → 0.8% (automated testing)
- Developer burnout: reduced (boring work automated)
Chapter 6: Tool Selection Decision Tree
New task arrives
↓
"Affects entire project direction?"
YES → Antigravity (multi-agent, full scope)
NO ↓
↓
"Modifying existing code (< 200 lines)?"
YES → Cursor (surgical, fast feedback)
NO ↓
↓
"Scripting, testing, deployment?"
YES → Claude Code (terminal, automation)
NO → Cursor (default)
[ ] Claude Code tests run in CI (no manual regression)
[ ] GitHub Actions gate: no merge without passing tests
[ ] Coverage maintained >= 80%
Phase 4-5
[ ] Antigravity security review complete
[ ] Claude Code deployment scripts tested (rollback works)
[ ] Monitoring dashboard live (Grafana + Slack)
[ ] Production deployment fully automated
Chapter 8: What the Official Docs Don't Tell You About Running This
I was reworking the full-screen layout of a wallpaper app one night. At first I asked Antigravity to fix every screen at once. It went badly. The agents fanned out, anything past my plan's parallel limit sat in a queue, and I couldn't tell what was happening off-screen while the clock kept moving.
So I switched to Cursor and specified files one by one. Now I was the one tracking consistency across every screen by eye.
Both failures had the same root: I was choosing tools by how fast they felt. What I should have watched was wait time, rework, and my own review time.
Judge a tool by the wait and rework you measured in your own setup, not by a number someone else published.
8.1 Read parallelism and wait time together
Lining up agents in Manager View looks powerful, but how many run at once is set by your plan, and the rest queue. Limits and consumption change, so instead of fixing numbers here, here's a sheet for measuring them yourself.
What to record
How to measure
When I step back (my rule of thumb)
Wait time
From sending the instruction to the first agent starting
Over a third of total task time: cut parallelism and split the task
Tokens consumed
Note the usage dashboard before and after
Large swings on the same kind of task usually mean a vague instruction
Rework count
Times you re-asked after receiving output
Past three, rewrite the spec itself
Review time
Time to read the output and decide
Longer than the implementation: cut the task smaller
The same sheet works for all three tools. A week of notes is enough to expose the gap between "it felt fast" and "review ate a full day."
8.2 Use @-mention to decide scope up front
Cursor's @-mention lets you pin files and symbols instead of dumping a whole folder. Responses come back faster and stray edits are less likely.
Over-narrowing has its own failure, though: forget the type definitions or shared config, and you get plausible code that doesn't type-check. My rules:
Always name the file being edited.
Add the type definitions that file imports.
Treat external doc lookups as unreliable. Put critical specs in rule files inside the repo (such as .cursor/rules/) and @-reference those.
8.3 Three worktree traps with Claude Code
git worktree lets you run several branches in parallel. Decide these three things on day one:
node_modules is per worktree. Check disk space monthly.
Lock files collide. Changes touching package-lock.json should run in one designated worktree only. Write that rule into AGENTS.md.
CI can't tell worktrees apart. Tag branch names or PR titles ([wt-A]) so you can tell which workspace a change came from.
When I developed a live-wallpaper feature and a messaging feature side by side, one went to Antigravity and the other I drove in Cursor. What stuck with me: parallel work needs separate workspaces and a separate review order too.
8.4 Review cost by line item, not by total
Early on I watched only the monthly total and tried to push it down. But if the total drops and rework grows, you pay in your own hours. Now I review these line items once a month:
Line item
Question to ask monthly
AI IDE subscriptions
Did each tool lead at least one task this month?
API usage
Any wasted re-runs inside automation scripts?
CI minutes
Can parallelising tests cut the wait?
Hosting and payments
Tracked as fixed costs, separate from dev tooling?
Your own time
How much went into review and rework (compare with 8.1)?
A tool that led nothing this month is next month's cancellation candidate. Spending your own time to save on tools, or paying for tools so you can spend time on decisions: I weigh that trade-off on the same table every month.
8.5 Write AGENTS.md as a contract
Over time AGENTS.md stopped feeling like a config file and started feeling like a contract between me and three agents. When it states both the clauses and what happens on violation, outputs come out at a consistent grain.
# AGENTS.md v1.3## Language and frameworks (all tools)- Language: TypeScript strict mode (any only with a justifying comment)- Frontend: Next.js App Router + React Server Components- Backend: Cloudflare Workers + KV- Styling: Tailwind CSS (custom CSS only in layout.css)## Contract clauses (violating changes are reverted)1. No merging changes to public API response shapes without an ADR2. No merging changes that weaken typing (adding `any`, loosening strict)3. No pushing changes that fail lint or type checks## Tool scopes (no overlap)- Antigravity: changes touching every screen, security review, spec writing- Cursor: single-file edits, ESLint / TypeScript fixes- Claude Code: shell scripts, CI/CD workflows, automation## Cross-tool validation- When implementing an Antigravity spec, cite the section number in the commit message- Tests generated by Claude Code are read by a human before merge
I call it the agents' employee handbook. Whatever isn't written, the agents will fill in on their own, so an unwritten clause is an open door for accidents.
8.6 What to delegate and what to decide yourself
Hand over what the three tools can carry without hesitation: first drafts of code, test scaffolds, deployment runbooks. They're faster than I am and they don't tire.
What I keep for myself is what a user feels the moment the screen opens. Drawing that line first means adding AI IDEs never means giving up judgment.
Your next step: split today's task into three piles: delegate, delegate-and-read-closely, decide myself. That alone removes much of the hesitation about which tool to open.
Conclusion
What helped most wasn't the comparison matrix. It was deciding who gets the work before the work starts.
Antigravity takes whole-project decisions and design, Cursor takes local implementation and edits, Claude Code takes tests and automation. Tie the three together with one AGENTS.md and adding tools no longer adds hesitation. The setup costs real effort, and it gets paid back a little more with every project.
Pick one small task you already have and run the Chapter 8 sheet on it: wait time, rework, review time. Once there's a single row of numbers, the next allocation decision mostly makes itself.
Share
Thank You for Reading
Antigravity Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.