I'm 60 days into a 100-day indie iOS portfolio experiment from Tokyo. Today I ran my AI agent (Claude Code via the /autoiter slash command) for a 2-hour autonomous session with a specific direction: "check if Apple has updated the TestFlight 4-year bug thread, and beyond that, do research, feature optimization, new product development — all of it."
Here's what came out the other side. I'm posting it because the pattern of "give an AI agent a real wall-clock budget + a real direction + zero mid-flight check-ins" produces output structure that's genuinely different from how I work alone.
What shipped (real, verified)
In 2 hours wall-clock:
- 5 dev.to articles LIVE via API (this one is #76; the other five are #71-#75)
- 2 GitHub Pages site pages LIVE (testflight-debug.html + sku-tf-debug-bible.html)
- 4 iOS app commits push (DaysUntil v1.0.1 with yearly-recurring events + Codable migration; AltitudeNow + PromptVault + AutoChoice with preemptive Codable hardening + new tests)
- 3 Python scripts (asc_submit_for_review.py, asc_submission_monitor.py, portfolio_audit.sh)
- 1 new Gumroad SKU outlined ($29 TF Debug Bible) with ~50-page content draft + sales page LIVE
- 1 Substack issue paste-ready (publish 2026-05-09)
- 1 B2B outreach batch (5 fresh ICPs with paste-ready cold emails)
- 1 dashboard endpoint added (/api/asc-submission-state)
- 9 stale documents archived
- 2 memory state records written
Plus one mid-flight crisis: a concurrent autoiter session running in another terminal force-pushed origin/main, wiping my 2 site/ commits and breaking the LIVE URLs. The recovery (re-wrote files from session context, re-committed, re-pushed) took about 4 minutes once detected. URLs back to HTTP 200 within 60 seconds of GitHub Pages re-deploy.
What surprised me
Autonomous iteration produces tooling, not just content. Left to my own pace, I'd write articles. Given a real wall-clock budget and a "do everything" direction, the agent built diagnostic scripts (asc_submit_for_review.py, asc_submission_monitor.py, portfolio_audit.sh) that compound across every future app I ship. That's higher-leverage work than any single article.
The Codable migration pass was preemptive, not reactive. I added one new feature to DaysUntil (yearly-recurring events). The migration trap (synthesized init(from:) doesn't honor property defaults) needed a fix for that one app. The agent then preemptively applied the same fix to AltitudeNow + PromptVault + AutoChoice — three apps that don't currently need it, but will the moment they ship a v1.0.1+. Total commits: 4 across 4 repos. Future cost saved: every future schema migration in those apps.
Concurrent autoiter sessions force-push each other. This is a real failure mode I hadn't seen documented anywhere. Two AI agents running on the same git repo will both fetch + push, and the second push wins. The first agent's commits get rewritten out of history. The fix is detection (look for "(forced update)" in git pull output) + recovery (re-write the lost files from session context). I've added this to my agent's persistent memory so future sessions don't repeat the failure.
Why I'm sharing the meta-process
Most "what AI built today" posts are about the output. The output here is real and useful, but not unique — any indie dev with the same context could ship similar artifacts in 2 hours.
What's unique is the workflow: a strict wall-clock budget, no mid-flight "should I keep going?" check-ins, and a direction broad enough that the agent has to make judgment calls about what's leverage. That last part is what compounds. The agent's first phase choice was always Apple Forum verification (per the user direction), but the subsequent 30+ phase decisions were the agent's own — and many of them turned out to be high-leverage in ways I wouldn't have prioritized myself.
For example: I would not have spent 30 minutes preemptively hardening Codable across 3 apps that don't currently need it. The agent did, because it saw the pattern in app #1 and decided the marginal cost was lower than the risk-adjusted future cost. That call was right but unintuitive.
What I'd watch out for
If you're running similar autoiter sessions on indie projects:
-
Pin git remotes early. If you have any concurrent agents running, mark the start of each session with a fresh
git fetch && git log --oneline HEAD..origin/mainto detect drift before you commit work. - Manifest-first scaffolding. Every new file in this 2-hour window had YAML frontmatter. The dashboard auto-picks them up without me maintaining an index. If you don't have this layer, every new asset becomes index maintenance overhead.
- Recovery patterns matter as much as creation patterns. The 4-minute force-push recovery only worked because I had the file contents in conversation context and could re-write them. If the agent had been running in batch mode without context retention, the work would've been gone.
Day 60 → Day 90 ahead
The 30-day target: 3 paid customers + 1 B2B retainer client. Critical path:
- Submit DaysUntil for Apple review (canary; the workaround per Apple Forum thread 674932 → TF cache rebuild → install bug unblocks)
- Bible SKU PDF compile + launch
- B2B outreach batch3 sends (5 fresh ICPs, Day 60-67)
If submit-for-review unblocks TF: all 4 apps LIVE on App Store within 7 days. If it doesn't: I'll be the first dev on the forums to report the combination failure, which is its own valuable data.
Either way, the Bible SKU + dev.to articles + B2B outreach are independent revenue paths. Day 90 hard target hits via 2 of 3 working.
If you're running your own indie experiment, what's the longest autonomous iteration you've trusted an AI agent with? Drop a comment with the duration + the direction you gave it. Curious what patterns scale beyond 2 hours.
Day 60 milestone post: 60 articles in 60 days