Running a Solo AI Studio with Antigravity × Google AI — Automating Every Stage of App Development as One Developer

# AGENTS.md — Phase 1: Idea Validator
 
## market-researcher
You evaluate app ideas with quantitative market research. Search for data on App Store / 
Google Play category rankings, top competitor review counts, and keyword competition.
 
Evaluate each idea across:
1. Market size (ranking stability in the category, competitor trajectory)
2. Technical feasibility (can one developer ship in 4 weeks?)
3. Monetization outlook (AdMob CPM benchmarks, subscription pricing norms, one-time pricing)
4. Differentiation (what does this offer that top-10 apps don't?)
5. ASO difficulty (keyword competition for the 3 primary terms)
 
Output: Markdown scoresheet + recommended ASO keywords + alternative concepts if score < 6

antigravity agent run market-researcher \
  --input "A wallpaper app delivering one high-resolution nature photo per day. \
           Offline save. Focused on Japanese seasons."

// .antigravity/mcp-config.json
{
  "mcpServers": {
    "stitch": {
      "command": "npx",
      "args": ["@google/stitch-mcp"],
      "env": {
        "GOOGLE_AI_API_KEY": "YOUR_GEMINI_API_KEY"
      }
    }
  }
}

# AGENTS.md — Phase 2: Implementation Team
 
## ui-builder
Role: Generate Swift / Kotlin UI components from Stitch output
Constraints:
- SwiftUI / Jetpack Compose only (no UIKit / XML layouts)
- Every interactive element and meaningful image must have an accessibilityLabel
- Accept Stitch JSON as input, output working code
- Handle Dynamic Type at all size classes — no layout breakage at largest accessibility sizes
Output: src/Views/
 
## data-layer-engineer
Role: Implement data persistence and CloudKit sync
Constraints:
- Use SwiftData (not Core Data)
- CloudKit sync via CKContainer using private database only
- Offline behavior: serve from local cache, sync in background after reconnection
- Users without iCloud should get fully functional local-only experience
Output: src/Models/ and src/DataLayer/
 
## test-writer
Role: Auto-generate XCTest / JUnit tests for implemented components
Constraints:
- Must cover happy path, error cases, and edge cases for each component
- Target 80%+ line coverage
- Use DI container for mocks; no real network calls in unit tests
- Write async/await-compatible XCTest using structured concurrency
 
## localizer
Role: Produce localized strings for all app text
Languages: Japanese (source), English, Simplified Chinese, Korean, Spanish
Constraints:
- Natural expressions, not literal translations
- No phrases that would trigger App Store review concerns
- Output: Localizable.strings format per language

// .antigravity/tasks.json
{
  "tasks": [
    {
      "id": "overnight-data-layer",
      "description": "Implement SwiftData + CloudKit sync for the wallpaper app. Create WallpaperItem model and WallpaperRepository. Offline cache must fall back gracefully; sync resumes in background after reconnection.",
      "agent": "data-layer-engineer",
      "schedule": "22:00 JST",
      "outputDir": "./WallpaperApp/Models/",
      "validation": "swift build && swift test WallpaperAppTests/DataLayerTests"
    },
    {
      "id": "overnight-ui",
      "description": "Convert Stitch-generated design (./stitch-output/main-screen.json) into SwiftUI code. Full accessibility support required.",
      "agent": "ui-builder",
      "schedule": "22:30 JST",
      "outputDir": "./WallpaperApp/Views/",
      "validation": "swift build"
    }
  ]
}

// WallpaperFetcherTests.swift — auto-generated by test-writer agent
import XCTest
@testable import WallpaperApp
 
@MainActor
final class WallpaperFetcherTests: XCTestCase {
 
    // Happy path: correct URL generated for a valid date
    func testFetchURL_ValidDate_ReturnsCorrectURL() async throws {
        let fetcher = WallpaperFetcher(
            baseURL: URL(string: "https://cdn.example.com")!
        )
        let date = Calendar.current.date(
            from: DateComponents(year: 2026, month: 5, day: 6)
        )!
 
        let url = try await fetcher.fetchURL(for: date)
 
        XCTAssertEqual(url.host, "cdn.example.com")
        XCTAssertTrue(url.path.hasSuffix("2026-05-06.jpg"))
    }
 
    // Edge case: falls back to cache when offline
    func testFetch_WhenOffline_ReturnsCachedURL() async throws {
        let mockMonitor = MockNetworkMonitor(isConnected: false)
        let cache = WallpaperCache()
        let cachedURL = URL(string: "https://cdn.example.com/cached.jpg")!
 
        await cache.set(key: "latest", value: cachedURL)
 
        let fetcher = WallpaperFetcher(networkMonitor: mockMonitor, cache: cache)
        let result = try await fetcher.fetchURL(for: Date())
 
        XCTAssertEqual(result, cachedURL)
    }
 
    // Error case: future dates throw WallpaperFetchError
    func testFetch_FutureDate_ThrowsError() async {
        let fetcher = WallpaperFetcher(
            baseURL: URL(string: "https://cdn.example.com")!
        )
        let futureDate = Date().addingTimeInterval(86400 * 30)
 
        do {
            _ = try await fetcher.fetchURL(for: futureDate)
            XCTFail("Expected error not thrown")
        } catch let error as WallpaperFetchError {
            XCTAssertEqual(error, .futureDateNotAllowed)
        } catch {
            XCTFail("Unexpected error type: \(error)")
        }
    }
}

# fastlane/Fastfile
lane :generate_screenshots do
  # Pull screenshot frame templates from Stitch
  sh("python3 scripts/fetch_stitch_frames.py")
 
  # Capture from simulator at all required device sizes
  capture_screenshots(
    workspace: "WallpaperApp.xcworkspace",
    scheme: "WallpaperAppUITests",
    output_directory: "fastlane/screenshots",
    devices: [
      "iPhone 16 Pro Max",
      "iPhone SE (3rd generation)",
      "iPad Pro (12.9-inch) (6th generation)"
    ],
    languages: ["ja-JP", "en-US", "zh-Hans", "ko-KR"],
    override_status_bar: true,
    concurrent_simulators: true
  )
 
  # Apply branded overlay from Stitch template
  sh("python3 scripts/apply_brand_overlay.py \
      --input fastlane/screenshots \
      --template stitch-output/screenshot-frame.json \
      --output fastlane/framed_screenshots")
 
  frame_screenshots(path: "fastlane/framed_screenshots")
end

# scripts/generate_promo_video.py
"""
Generate three variants of a 30-second App Preview using Veo 3.
Variants enable A/B testing in App Store Connect.
"""
import time
from pathlib import Path
from google import genai
 
client = genai.Client(api_key="YOUR_GEMINI_API_KEY")
 
PROMO_VARIANTS = {
    "morning": """
        30-second app promo video with a morning light theme:
        1. Phone lock screen appears, showing a stunning mountain wallpaper (5s)
        2. Slow swipe to a cherry blossom scene (8s)
        3. User taps 'Favorite' to save the wallpaper (5s)
        4. Home screen shows the wallpaper blending with a living room setting (8s)
        5. App icon appears with the tagline 'Japan. Every day.' (4s)
        Style: cinematic, warm tones, no audio (silent)
    """,
    "zen": """
        30-second app promo with a minimal zen theme:
        Wallpapers slowly appear center-frame — Japanese garden, temple, snow scene.
        Quiet, unhurried transitions. Subtitle: 'Quiet Japan in your hand, every day.'
        Style: near-monochrome, extremely restrained
    """,
    "vivid": """
        30-second high-energy promo:
        Japanese seasons cycle quickly — cherry blossoms, summer green, fireworks, 
        autumn leaves, snow. Each scene 2 seconds. App UI appears at the end.
        Tagline: 'Every season. Every day.'
        Style: vibrant colors, upbeat pacing
    """
}
 
def generate_all_variants():
    operations = []
    for name, prompt in PROMO_VARIANTS.items():
        print(f"Generating: {name}")
        op = client.models.generate_videos(
            model="veo-3-0-generate-preview",
            prompt=prompt,
            config={
                "numberOfVideos": 1,
                "durationSeconds": 30,
                "aspectRatio": "9:16",
                "resolution": "1080p",
            }
        )
        operations.append((name, op))
        time.sleep(2)
 
    # Wait for all to complete
    for name, op in operations:
        while not op.done:
            time.sleep(15)
            op = client.operations.get(op)
 
        uri = op.response.generated_videos[0].video.uri
        out = Path(f"fastlane/promo_videos/{name}.mp4")
        out.parent.mkdir(exist_ok=True)
 
        import urllib.request
        urllib.request.urlretrieve(uri, out)
        print(f"✅ {name}: {out}")
 
if __name__ == "__main__":
    generate_all_variants()

#!/bin/bash
# scripts/generate_metadata.sh — managed by Antigravity
 
APP_DESCRIPTION=$(cat docs/app-description-en.md)
 
for lang in "ja-JP" "zh-Hans" "ko-KR" "es-ES"; do
  echo "Generating for: $lang"
  gemini "
  Translate and localize the following English app description for the $lang market.
 
  Requirements:
  - Comply with App Store review guidelines
  - Use natural, native-sounding expressions — not literal translation
  - Include primary keywords in the first paragraph
  - Stay within 4,000 characters
 
  App name: Japan Seasons Wallpapers
  Description:
  ${APP_DESCRIPTION}
  " > "fastlane/metadata/${lang}/description.txt"
 
  sleep 2
done

# fastlane/Fastfile — submission lane
lane :submit_for_review do
  increment_build_number(
    build_number: latest_testflight_build_number + 1
  )
 
  build_app(scheme: "WallpaperApp", export_method: "app-store")
 
  upload_to_testflight(
    skip_waiting_for_build_processing: false,
    changelog: sh("git log --oneline -10").strip
  )
 
  deliver(
    submit_for_review: true,
    automatic_release: false,
    metadata_path: "./fastlane/metadata",
    screenshots_path: "./fastlane/framed_screenshots",
    app_review_information: {
      demo_user: "demo@example.com",
      demo_password: "Demo1234!",
      notes: "Sign in with the demo account to access all features"
    },
    submission_information: {
      add_id_info_uses_idfa: false,
      export_compliance_uses_encryption: false,
      content_rights_has_rights: true,
      content_rights_contains_third_party_content: false
    }
  )
end

# .github/workflows/ios-pipeline.yml
name: iOS CI/CD Pipeline
 
on:
  push:
    branches: [main, 'release/*']
  pull_request:
    branches: [main]
 
jobs:
  test:
    runs-on: macos-15
    steps:
      - uses: actions/checkout@v4
 
      - name: Select Xcode 26
        run: sudo xcode-select -s /Applications/Xcode_26.app
 
      - name: Run tests
        run: |
          xcodebuild test \
            -workspace WallpaperApp.xcworkspace \
            -scheme WallpaperApp \
            -destination 'platform=iOS Simulator,name=iPhone 16 Pro' \
            -resultBundlePath TestResults.xcresult
 
  deploy-testflight:
    needs: test
    if: github.ref == 'refs/heads/main'
    runs-on: macos-15
    steps:
      - uses: actions/checkout@v4
      - run: gem install fastlane
      - name: Deploy to TestFlight
        env:
          APP_STORE_CONNECT_API_KEY_ID: ${{ secrets.API_KEY_ID }}
          APP_STORE_CONNECT_ISSUER_ID: ${{ secrets.ISSUER_ID }}
          APP_STORE_CONNECT_KEY: ${{ secrets.API_KEY }}
        run: fastlane deploy_testflight

// ❌ Common AI output — no accessibility context
Image(wallpaper.imageName)
    .resizable()
    .aspectRatio(contentMode: .fill)
    .ignoresSafeArea()
 
// ✅ Properly labeled
Image(wallpaper.imageName)
    .resizable()
    .aspectRatio(contentMode: .fill)
    .ignoresSafeArea()
    .accessibilityLabel("\(wallpaper.title) — \(wallpaper.locationName)")
    .accessibilityAddTraits(.isImage)

# AGENTS.md — Task size principle
 
Break all long tasks into subtasks that complete within 30 minutes.
 
❌ "Implement the entire app data layer" (could take hours)
✅ "Implement WallpaperFetcher class only — network + error handling" (20–30 min)
✅ "Implement WallpaperCache class only — read/write/expiry" (20–30 min)
 
Commit after each subtask. Reference previous commit in the next task's description.

# scripts/weekly_report.py
"""
Auto-generated every Monday by Antigravity scheduler.
Fetches performance data and creates improvement proposals as Antigravity tasks.
"""
import subprocess
 
def generate_report(downloads, dau, crash_rate, avg_rating, top_complaints):
    prompt = f"""
    Analyze the following app performance data and identify the 3 highest-priority 
    improvements for the next 2-week sprint. For each improvement, include:
    - What to change
    - Why it matters (user impact estimate)
    - How to implement it (concrete steps)
 
    Weekly metrics:
    - Downloads: {downloads}
    - DAU: {dau}
    - Crash rate: {crash_rate}%
    - Average rating: {avg_rating}
    - Top user complaints: {top_complaints}
    """
 
    return subprocess.run(
        ["gemini", prompt],
        capture_output=True, text=True
    ).stdout