The reviews that come in for Beautiful HD Wallpapers and Ukiyo-e Wallpapers span English, Japanese, Spanish, Portuguese, German, Korean, Chinese, and a handful of other languages. When you're running a 50M-download app solo, responding to 30+ reviews a week in multiple languages quietly eats 1–2 hours every time you sit down to do it.
I started using Antigravity to semi-automate this workflow in early 2026. Today I can get through 30–40 replies in a single 30–45 minute session while keeping quality consistent. The key word is "semi" — full automation isn't where I landed, and I'll explain why. There's also a rate-limiting constraint with App Store Connect that isn't documented anywhere and will silently discard your replies if you don't account for it.
Why Manual Review Replies Were Breaking Down
I started my independent app business in 2013. Review management was always one of those tasks I handled sporadically — fine when things were slow, unsustainable during busy periods.
A negative review in Korean or Portuguese would take me 10+ minutes to respond to properly: understand the complaint, draft a thoughtful reply, translate it, check the tone, send. Multiply that by 30 reviews and you're looking at a half-day task that competes with actual development time.
My first attempt at using AI for this was simple: paste a review, ask Claude or Gemini to write a reply. Quality was fine, but two problems remained:
- The tone varied wildly — some replies sounded corporate, others too casual, none felt like the app's personality
- The submission step was still manual, and with dozens of queued replies, tracking what was sent and what wasn't became its own overhead
Antigravity's agent capabilities addressed both of these issues in a way that single-shot prompting didn't.
The 8-Second Rule Nobody Talks About
When I first built a script to automate the submission step through App Store Connect API, I ran into a confusing problem: replies appeared to go through (no error responses), but they simply didn't show up in the App Store.
After debugging, I found that sending review responses in rapid succession causes App Store Connect to silently discard them — no error, no warning, just nothing. Adding approximately 8 seconds of delay between each submission solved the problem completely.
import time
def reply_to_review(review_id: str, reply_text: str, client) -> bool:
"""App Store Connect review reply with rate limit handling"""
try:
response = client.post(
f"/v1/customerReviewResponses",
json={
"data": {
"type": "customerReviewResponses",
"attributes": {"responseBody": reply_text},
"relationships": {
"review": {
"data": {"type": "customerReviews", "id": review_id}
}
}
}
}
)
return response.status_code == 201
except Exception as e:
print(f"Error: {e}")
return False
finally:
# Wait 8 seconds between submissions to avoid silent discard
time.sleep(8)This isn't in Apple's documentation. Google Play is noticeably more tolerant — 3–5 seconds between requests works fine there. App Store Connect is where this constraint bites.
The Three-Stage Workflow
The process I settled on has three stages, with human review between stage 2 and 3.
Stage 1: Fetch and classify
Antigravity pulls reviews from App Store Connect API and classifies each by sentiment (positive / negative / bug report / feature request) and language. This runs automatically.
Stage 2: Generate replies
Based on the classification and a tone guidelines document I maintain, Antigravity generates a draft reply for each review. This is where the quality of the system prompt matters most.
Stage 3: Review and submit
I read through each generated reply, edit anything that feels off, then run the submission script with the 8-second delay baked in.
The only fully automated part is Stage 1. Stages 2 and 3 both involve me, but the work is dramatically lighter than writing from scratch.
Tone Guidelines: Where the Real Investment Goes
The biggest quality lever wasn't the model choice or the workflow architecture — it was the tone guidelines document I give to Antigravity. Here's a condensed version of what it looks like:
# Beautiful HD Wallpapers — Review Reply Guidelines
## App positioning
A wallpaper app centered on beauty and calm. Interactions with users
should feel warm and appreciative, not corporate.
## Core principles
- Lead with gratitude, even for critical reviews
- For bug reports: acknowledge the issue and give a concrete next step
- For 1-star reviews: avoid being defensive; focus on resolution
## Language-specific notes
- Japanese: Always use polite form (です/ます調)
- English: "Thanks for taking the time" lands better than "Thank you for your feedback"
- Spanish/Portuguese: Warmth is expected; don't be too formal
- Korean: Maintain formal speech level (존댓말)
- German/French: Use the formal "Sie/vous" address
## Character limits
- App Store: keep under 350 characters (longer replies display poorly)
- Google Play: up to 500 characters
Investing time here pays off in consistent output. When I revised these guidelines to add the language-specific notes, the quality gap between English and non-English replies nearly closed.
Handling the App Store vs. Google Play Difference
The same workflow covers both iOS (Beautiful HD Wallpapers, Ukiyo-e Wallpapers) and Android (Beautiful 4K/HDR Wallpapers). The APIs behave differently in a few practical ways:
- Submission delay: Google Play needs 3–5 seconds; App Store needs ~8 seconds
- Character limit: App Store responses over 350 characters can display poorly; Google Play allows up to 500
- Reply editing: App Store makes it difficult to edit a response after sending; Google Play is more forgiving
- API stability: Google Play Developer Publishing API tends to be more reliable
For App Store submissions, I have Antigravity enforce the 350-character limit during generation:
def generate_reply(review_text: str, rating: int, language: str,
platform: str = "ios") -> str:
max_chars = 350 if platform == "ios" else 500
prompt = f"""
Review language: {language}
Rating: {rating} stars
Review content: {review_text}
Write a reply in {language} for the above review.
- Maximum length: {max_chars} characters
- Follow the tone guidelines
"""
# ... send to Antigravity APIEnforcing this at generation time means I rarely have to manually shorten replies before submitting.
What Four Months of Running This Taught Me
Semi-automation is the right goal, not full automation
For 1–2 star reviews, I don't want to send AI-generated text without reading it first. A frustrated user deserves a human response, and getting this wrong publicly is worse than responding slowly. Antigravity is a fast draft machine, not a replacement for judgment on the difficult ones.
The tone guidelines are the actual product
About half the time I've put into this workflow went into refining the tone guidelines document, not the code. If you're building something similar, start there before writing any automation. A well-defined voice document makes the AI's output predictably good.
Review reply consistency might affect App Store visibility
Apple doesn't document this, but several indie developers I've talked with believe consistent review responses correlate with better App Store treatment. I can't verify this directly, but I've noticed that users who see a reply to a negative review sometimes come back with a revised rating — that's a concrete benefit that doesn't depend on any algorithm.
A practical starting point: take the last 10 reviews across your apps and sort them into the three buckets — appreciation, bug report, and feature request. Give Antigravity a basic tone guidelines document and generate draft replies for each bucket. You'll likely get usable output faster than expected, and you'll quickly see where the guidelines need sharpening.
Setting Up Antigravity for This Task
For anyone who wants to replicate this, here's the minimal Antigravity setup I'm using.
The agent runs as a scheduled task rather than interactively. It connects to App Store Connect using a JWT token generated from the App Store Connect API key, fetches unresponded reviews from the past 7 days, and produces a structured list of draft replies.
import jwt
import time
import requests
from datetime import datetime, timedelta
def generate_app_store_token(key_id: str, issuer_id: str, private_key: str) -> str:
"""Generate App Store Connect JWT token (valid for 20 minutes)"""
payload = {
"iss": issuer_id,
"iat": int(time.time()),
"exp": int(time.time()) + 1200,
"aud": "appstoreconnect-v1"
}
headers = {"kid": key_id, "typ": "JWT"}
return jwt.encode(payload, private_key, algorithm="ES256", headers=headers)
def fetch_unresponded_reviews(app_id: str, token: str, days_back: int = 7) -> list:
"""Fetch reviews without existing responses"""
url = f"https://api.appstoreconnect.apple.com/v1/apps/{app_id}/customerReviews"
headers = {"Authorization": f"Bearer {token}"}
params = {
"filter[territory]": "ALL",
"sort": "-createdDate",
"limit": 200
}
reviews = requests.get(url, headers=headers, params=params).json()
cutoff = datetime.now() - timedelta(days=days_back)
unresponded = []
for review in reviews.get("data", []):
created = datetime.fromisoformat(
review["attributes"]["createdDate"].replace("Z", "+00:00")
)
if created.replace(tzinfo=None) < cutoff:
continue
# Check if response already exists
if not review.get("relationships", {}).get("response", {}).get("data"):
unresponded.append(review)
return unrespondedThe Antigravity agent receives this list and the tone guidelines, generates replies, and writes them to a JSON file for my review. I look through the file, edit anything that needs work, then run the submission script.
The whole review step takes about 5–10 minutes for 30 reviews. The submission script then runs unattended for another 4 minutes (30 reviews × 8 seconds).
Multilingual Quality Checks
One thing I added after the first month: a simple automated check that flags replies Antigravity might have gotten wrong.
def basic_quality_check(reply: str, language: str, rating: int) -> list[str]:
"""Flag potential issues before human review"""
warnings = []
# Length check
if len(reply) > 350:
warnings.append(f"Too long: {len(reply)} chars (max 350 for App Store)")
# Check for obviously wrong language markers
if language == "ja" and not any(c in reply for c in ["す", "ます", "です", "ください"]):
warnings.append("Japanese reply may be missing polite form (です/ます)")
# Flag unexpectedly short replies for low ratings
if rating <= 2 and len(reply) < 80:
warnings.append(f"Reply to {rating}-star review is very short ({len(reply)} chars)")
# Check for placeholder text
if "[" in reply or "]" in reply:
warnings.append("Reply may contain unfilled placeholder text")
return warningsThese checks catch obvious issues — a Japanese reply that somehow came back in English, a 1-star response that's just two sentences, a placeholder that didn't get filled. They run before I review the batch, so the flags draw my attention where it's needed.
This kind of lightweight validation layer is something I've started adding to most Antigravity-assisted workflows. The model produces good output, but having a sanity check that runs before I see the results makes the review step meaningfully faster.