Antigravity × Cursor × Claude Code — A Practical 3-Tool AI Development Workflow for 2026

Chapter 2: Phase-by-Phase Tool Selection

Development spans six phases. Here's the optimal tool for each.

Phase 0: Discovery & Requirements (Week 1-2)

Priority: 1st Antigravity, 2nd Cursor

When requirements are fuzzy, lock them down fast via spec.

Why Antigravity

1. Multi-perspective check — Backend Architect considers APIs, Frontend Builder focuses on UX flow, Security Auditor thinks about auth—simultaneously. Single LLM misses intersections.

2. Spec-driven lock-in — "Ready for next phase?" is unambiguous once spec is done.

3. 1M token institutional knowledge — Absorb similar domain projects to suggest best practices.

Antigravity prompt:
"Define requirements for new e-commerce platform.
Reference: 3 previous retail system AGENTS.md files.

Output Specification v1.0 covering:
  - Frontend: checkout flow, account, wishlist
  - Backend: inventory, payment integration, recommendation engine
  - Security: PCI DSS, OAuth 2.0
  - Infra: multi-region, Black Friday scalability

Deliverable: 50-100 page spec + AGENTS.md v1.0"

Time: 2-3 hours
Output: Specification v1.0 (immutable), AGENTS.md v1.0
Confidence: High (all agent perspectives vetted)

Cursor as supplement

• 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)

Cursor dominates small-to-medium implementation tasks (< 200 lines, < 5 files).

Claude Code: Tests & automation in parallel

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 Validation
Spec (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

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
**Actual**: ¥20 feature productivity gain + ¥60k regression savings - ¥66k tool cost = **Break-even + delivery speed advantage**

Plus intangibles:
  - Feature velocity: 6 features vs. 5 (20% gain)
  - Bug rate: 3% → 0.8% (automated testing)
  - Developer burnout: reduced (boring work automated)

Chapter 8: Operational Findings Not in the Official Docs

Most of what follows came out of running these three tools on shipping products as an indie developer — not from release notes or tutorials. I have been building and maintaining iPhone and Android apps personally for years, with revenue coming from ads plus subscriptions. Across the sites and the app side, the gap between documented behavior and lived operation has been wider than I expected.

8.1 Antigravity Manager View: Wait Time and Token Economics

The docs say "Manager View orchestrates up to 16 agents." In practice the behavior is more nuanced.

• Parallelism is capped at the plan tier. On Pro (parallel 5), spawning 16 agents means the 6th onwards is queued behind the first batch. In my runs the active 5 tend to be UI design, code generation, test authoring, doc generation, and security review, while deployment automation and monitoring sit in the queue.
• A 5-minute task with 16 agents costs about 420K–480K tokens. Three sessions a day across five working days translates to 100M–120M tokens per month. The break-even point for moving from Pro (parallel 5) to an Enterprise-tier "effective parallel 10" sits at roughly "3–4 concurrent projects per indie developer per month" — that is the threshold I am watching.
• Cache hit rate is 15–25%. Resubmitting the same spec document does not reuse much. Cursor's local context cache (>70% hit) makes it obvious that Antigravity is optimizing for compression, not memoization.

A concrete example from the wallpaper app: rewriting every screen layout to support vertical writing was specced in Antigravity. Twelve of the 16 agents ran in parallel, burned about 420K tokens, and finished in seven minutes. Doing the same job in Cursor required pointing it at each file by hand and took over an hour. "Full-screen consistency changes" → Antigravity. "Three-line surgical edits" → Cursor. That dividing line emerged here.

8.2 What Cursor's @-mention Actually Saves

@-mention is sold as a precise context tool. The measured behavior:

• @file:src/screens/Wallpaper.tsx compresses context from ~320K tokens to ~38K tokens. Inference time drops from 8–12 seconds to 1–2 seconds.
• @symbol:LiveWallpaperRenderer.render pulls in related definitions only. This matters when a single file in indie code tends to host several features, as mine often do.
• @docs:Next.js is flaky. The remote docs endpoint times out frequently. The pattern that worked for me is caching the docs I care about under .cursor/rules/ and pointing @file at the local copies.

8.3 Claude Code Worktree Parallel Development: Three Pitfalls

git worktree integration sells "parallel branches" — but three things bite in practice.

1. node_modules is per-worktree. feature/onboarding and feature/wallpaper-shader each need their own install. Checking SSD free space monthly became a habit.
2. Lockfile conflicts are likely. Letting two worktrees both edit package-lock.json produces merge conflicts on a high percentage of merges. AGENTS.md now says "lockfile changes happen in worktree A only."
3. CI/CD does not understand worktrees. GitHub Actions ignores worktree metadata. Branch names have to carry the disambiguation, so the workflow tags PR titles with [wt-A] and friends.

In one shipping example, the wallpaper app's "live wallpaper" and "manifestation message" features were built in parallel — two worktrees, one driven by Antigravity, the other by me in Cursor. The unglamorous lesson: parallel development needs a physically separated workspace, not just a faster model.

8.4 Monthly 3-Tool Cost vs. AdMob Revenue

Running several sites plus the personal app business, the monthly cost allocation has settled here:

Against a roughly ¥1,000,000/month AdMob revenue baseline, this is well within what an indie developer can absorb. The actual tradeoff I revisit every month is "spend time saving tool fees" vs. "let the tools do that work and put my hours into the next art piece."

8.5 AGENTS.md as a Contract, Not a Config File

After running this for a while it became clear that AGENTS.md is less a config file and more a contract between me and three AI agents. The excerpt below is from the file I use in production.

# AGENTS.md v1.3 (2026-05-29 update)
 
## Language and Frameworks (all tools)
- Language: TypeScript strict mode (never use any unless documented)
- Frontend: Next.js 16 App Router + React Server Components
- Backend: Cloudflare Workers + KV + Stripe API v2024-11
- Styling: Tailwind CSS (custom CSS only in layout.css)
 
## Contract clauses (violations are reverted)
1. Any change to existing frontmatter schema is unmergeable
2. Any change that adds 1MB+ to articles.json is unmergeable
3. Generated prose that violates `_documents/AUTHOR_VOICE_STYLE_GUIDE.md` is discarded
4. Articles flagged by `python3 _documents/_quality_audit/_scripts/article_gate.py` cannot be pushed
 
## Tool-specific scope (no overlap)
- Antigravity: full-screen-impact changes, security review, spec authoring — only
- Cursor: single-file edits, ESLint/TypeScript fixes — only
- Claude Code: shell scripts, CI/CD workflows, automation — only
 
## Cross-tool validation
- When implementing in Cursor a spec previously committed by Antigravity, the spec section number must appear in the commit message
- Tests generated automatically by Claude Code cannot merge without Cursor review by a human

With this file in the repo, the three tools converge on consistent granularity, naming, and coverage. The internal name for it is "the work rules for AI agents."

8.6 Where I Let AI Take Over, and Where I Decide Myself

In parallel with software work I keep a creative practice built around making things by hand. The rule I hold to there is AI is not in the loop for the artwork itself, only for operations and writing, and that same line has carried over into how I divide work among AI IDEs.

Whatever can be delegated to the three tools is delegated, and the human stays focused on the core decisions that make software feel like a work, not a build. Cursor takes daily code, Antigravity owns the big design, Claude Code carries automation — and what's left in front of me is the single moment a user opens the screen.

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)

Chapter 7: Implementation Checklist

Day 0 (Project launch)

• [ ] Create AGENTS.md v1.0 (tech stack, tool scopes, standards)
• [ ] Activate all 3 tools (Antigravity Pro, Cursor Pro, Claude API key)
• [ ] Git + GitHub setup, CI/CD skeleton
• [ ] Commit config files (.eslintrc.json, prettier.config.js, etc.)

Phase 0-1

• [ ] Antigravity produces Specification v1.0 (immutable)
• [ ] AGENTS.md confirms tech stack
• [ ] Phase 1 deliverables: API spec, UI inventory, deploy config

Phase 2-3

• [ ] Cursor PRs follow AGENTS.md standards (ESLint, TypeScript strict)
• [ ] 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

Conclusion

The 3-tool approach isn't belt-and-suspenders redundancy. It's strategic specialization.

Antigravity for strategy. Cursor for implementation. Claude Code for automation.

When orchestrated via AGENTS.md:

• Velocity: 30–40% faster timelines
• Quality: 70% fewer production bugs (automated testing)
• Sustainability: Automation removes burnout-inducing drudgery

The initial setup (AGENTS.md, CI/CD) takes 1–2 weeks. The ROI is measurable within a month.

In 2026, the question isn't "which single tool is best?" It's "how do I orchestrate three tools to their full potential?"

This guide is the answer.