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."

{
  "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

{
  "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"
    },
    {
      "id": "overnight-l10n",
      "description": "Propagate newly added Localizable.strings keys into Japanese, Simplified Chinese, Korean, and Spanish.",
      "agent": "localizer",
      "schedule": "23:00 JST",
      "outputDir": "./WallpaperApp/Resources/",
      "validation": "python3 scripts/validate_strings.py WallpaperApp/Resources/Base.lproj/Localizable.strings WallpaperApp/Resources/*.lproj/Localizable.strings"
    }
  ]
}

// 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"
  antigravity agent run localizer --input "
  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.

#!/usr/bin/env python3
"""Detect format-specifier drift in Localizable.strings.
Treats the base locale (usually en or ja) as truth and compares each translation's
specifier set and positional arguments. Standard library only.
Drop it at scripts/validate_strings.py and call it from CI.
"""
from __future__ import annotations
import re, sys, os
from collections import Counter
 
# "key" = "value";  (escaped \" allowed)
ENTRY = re.compile(r'^\s*"((?:[^"\\]|\\.)*)"\s*=\s*"((?:[^"\\]|\\.)*)"\s*;', re.M)
# matches %@ %d %1$@ %.2f %% and friends
SPEC = re.compile(
    r'%(?:(\d+)\$)?([-+ #0]*)(\d+|\*)?(?:\.(\d+|\*))?'
    r'(hh|h|ll|l|q|L|z|j|t)?([@dDiuUxXoOfeEgGcCsSpaAF%])'
)
 
 
def parse(path: str) -> dict[str, str]:
    with open(path, encoding='utf-8-sig') as f:
        src = f.read()
    src = re.sub(r'/\*.*?\*/', '', src, flags=re.S)
    return {m.group(1): m.group(2) for m in ENTRY.finditer(src)}
 
 
def specs(value: str) -> list[tuple]:
    out = []
    for m in SPEC.finditer(value):
        if m.group(6) == '%':          # %% is a literal, not an argument
            continue
        out.append((m.group(1), m.group(6)))   # (position or None, conversion)
    return out
 
 
def check(base: str, tr: str) -> list[str]:
    b, t = specs(base), specs(tr)
    errs = []
    bpos = any(p for p, _ in b)
    tpos = any(p for p, _ in t)
 
    if len(b) != len(t):
        errs.append(f'count {len(b)}->{len(t)}')
 
    if bpos != tpos and (b or t):
        errs.append('positional-mix')       # only one side uses %1$@ form
 
    if bpos and tpos:
        bm = {int(p): c for p, c in b if p}
        tm = {int(p): c for p, c in t if p}
        if set(bm) != set(tm):
            errs.append(f'arg-index {sorted(bm)}->{sorted(tm)}')
        else:
            for i in sorted(bm):
                if bm[i] != tm[i]:
                    errs.append(f'arg{i} type %{bm[i]}->%{tm[i]}')
    else:
        # without positions, order itself carries the argument mapping
        bt = [c for _, c in b]
        tt = [c for _, c in t]
        if bt != tt:
            if Counter(bt) == Counter(tt):
                errs.append(f'order {"".join(bt)}->{"".join(tt)}')
            else:
                errs.append(f'type {"".join(bt) or "-"}->{"".join(tt) or "-"}')
    return errs
 
 
def run(base_path: str, targets: list[str]) -> int:
    base = parse(base_path)
    bad = 0
    for tp in targets:
        tr = parse(tp)
        loc = os.path.basename(os.path.dirname(tp)) or tp
        for key, bval in base.items():
            if key not in tr:
                print(f'{loc}: [{key}] MISSING'); bad += 1; continue
            for e in check(bval, tr[key]):
                print(f'{loc}: [{key}] {e}'); bad += 1
        for key in tr.keys() - base.keys():
            print(f'{loc}: [{key}] ORPHAN'); bad += 1
    return bad
 
 
if __name__ == '__main__':
    if len(sys.argv) < 3:
        sys.exit('usage: validate_strings.py <base.strings> <target.strings>...')
    n = run(sys.argv[1], sys.argv[2:])
    print(f'--- {n} issue(s)')
    sys.exit(1 if n else 0)

# .github/workflows/ci.yml (relevant step only)
      - name: Validate localization structure
        run: |
          python3 scripts/validate_strings.py \
            WallpaperApp/Resources/Base.lproj/Localizable.strings \
            WallpaperApp/Resources/*.lproj/Localizable.strings

# scripts/weekly_report.py
"""Runs every Monday on the Antigravity scheduler."""
import json
import subprocess
import sys
 
 
def fetch_metrics(bundle_id: str) -> dict:
    """Pull last week's numbers from App Store Connect via fastlane."""
    result = subprocess.run(
        ["fastlane", "run", "app_store_connect",
         "action:get_app_info",
         f"app_identifier:{bundle_id}"],
        capture_output=True, text=True,
    )
    if result.returncode != 0:
        raise RuntimeError(f"fastlane failed: {result.stderr.strip()[:200]}")
    return json.loads(result.stdout)
 
 
def generate_report(m: dict) -> str:
    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: {m['downloads']}
    - DAU: {m['dau']}
    - Crash rate: {m['crash_rate']}%
    - Average rating: {m['avg_rating']} ({m['review_count']} reviews)
    - Top user complaints: {m['top_complaints']}
    """
    result = subprocess.run(
        ["antigravity", "agent", "run", "release-analyst", "--input", prompt],
        capture_output=True, text=True,
    )
    if result.returncode != 0:
        raise RuntimeError(f"agent failed: {result.stderr.strip()[:200]}")
    return result.stdout
 
 
if __name__ == "__main__":
    try:
        print(generate_report(fetch_metrics("com.example.wallpaper")))
    except (RuntimeError, KeyError, json.JSONDecodeError) as e:
        # Never swallow a failure into an empty report
        print(f"weekly_report failed: {e}", file=sys.stderr)
        sys.exit(1)

#!/usr/bin/env node
// phase-cost.mjs — zero dependencies. Aggregates session cost by phase.
// usage: node phase-cost.mjs ~/.antigravity/cost-ledger.jsonl
import { readFileSync } from "node:fs";
 
const path = process.argv[2];
if (!path) {
  console.error("usage: node phase-cost.mjs <ledger.jsonl>");
  process.exit(2);
}
 
const rows = readFileSync(path, "utf8")
  .split("\n")
  .filter((l) => l.trim())
  .map((l, i) => {
    try {
      return JSON.parse(l);
    } catch {
      console.error(`skip: line ${i + 1} is not valid JSON`);
      return null;
    }
  })
  .filter((r) => r && typeof r.cost === "number" && Number.isFinite(r.cost));
 
const agg = new Map();
let exact = 0;
let rounded = 0;
for (const r of rows) {
  const phase = r.phase ?? "unlabeled";
  const a = agg.get(phase) ?? { n: 0, sum: 0, max: 0 };
  a.n += 1;
  a.sum += r.cost;
  a.max = Math.max(a.max, r.cost);
  agg.set(phase, a);
  exact += r.cost;
  rounded += Math.round(r.cost * 100) / 100; // what a rounded display would sum to
}
 
const usd = (v) => `$${v.toFixed(4)}`;
const entries = [...agg.entries()].sort((x, y) => y[1].sum - x[1].sum);
 
console.log("phase      runs      total     share   avg/run    max/run");
for (const [phase, a] of entries) {
  console.log(
    phase.padEnd(10) +
      String(a.n).padStart(5) +
      usd(a.sum).padStart(11) +
      `${((a.sum / exact) * 100).toFixed(1)}%`.padStart(9) +
      usd(a.sum / a.n).padStart(10) +
      usd(a.max).padStart(11)
  );
}
console.log("-".repeat(56));
console.log(`total (unrounded)      ${usd(exact)}   ${rows.length} runs`);
console.log(`total (each row rounded to 2dp) ${usd(rounded)}`);
const drift = rounded - exact;
console.log(
  `rounding drift ${usd(drift)} (${((drift / exact) * 100).toFixed(2)}% across ${rows.length} rows)`
);