A few weeks ago, we shipped Rowta — a trip planning app for group road trips — to TestFlight with real users. The core of it was built in a single evening.

Not a prototype. Not a demo. A real SwiftUI app with trip management, expense splitting, convoy tracking, push notifications, and a Cloudflare Workers backend. 50 Swift files. On TestFlight. With testers sending feedback.

Here's how we did it, and what we actually learned about building with AI.

The setup

Sett & Stone uses a split model: humans architect, AI builds. That distinction matters more than most people realise.

The human (in this case, our founder) brings domain knowledge, taste, and product judgment. They decide what to build, how it should work, and what good looks like. The AI — Claude Code, running in non-interactive mode — writes the actual Swift, designs the data models, implements the animations, wires up the networking.

This isn't "vibe coding" in the way people usually mean it. It's closer to being an architect who can summon a construction crew at will.

The PRD-first workflow

The single most important lesson: AI code is only as good as the brief you write.

We start every feature with a Product Requirements Document. Not a formal enterprise PRD — more like a detailed conversation with your future builder. It covers:

  • What the feature does, precisely
  • Data models and relationships
  • UI layout and interactions (in words, not wireframes)
  • Edge cases and error states
  • What "done" looks like

A vague brief like "add expense tracking" produces generic, half-baked code. A specific brief like "three split types: equal division, percentage-based, and exact amounts; settlement dashboard showing net balances between all members; handle edge cases where a member leaves mid-trip" produces something you can actually ship.

💡 Key insight

LLMs produce generic UI without specific design direction. Every PRD needs opinionated choices about layout, typography, colour, and interaction patterns — or you'll get the same bland interface every other AI-built app has.

The evening

Rowta started with a PRD that described a trip planning app for campervan road trips. Group coordination, shared expenses, convoy tracking. The kind of thing you'd want when four mates take their vans to a festival.

The workflow looked like this:

  1. Write the PRD — 30 minutes of thinking about what the app actually needed to do
  2. Plan mode — Claude Code reads the PRD and proposes an architecture (file structure, data models, key decisions). Human reviews, adjusts, approves
  3. Execute in phases — each phase is a chunk of the PRD. Models first, then views, then backend, then integration
  4. Verify — after each phase, regenerate the Xcode project, build, check

The first working build — trip creation, member management, basic UI — took about two hours. By the end of the evening, we had expense tracking, map integration, and a styled design system.

What AI is actually good at

Some things worked remarkably well:

  • Boilerplate — SwiftData models, CRUD operations, navigation stacks. The stuff that's necessary but not interesting. AI does this in seconds.
  • Pattern implementation — "Build a friend code system like multiplayer games use" produces something functional immediately because the pattern is well-documented.
  • Refactoring — "Move all action buttons above the fold" or "extract this into a reusable component" is trivially easy for AI.
  • Backend wiring — Cloudflare Workers, APNs configuration, OAuth flows. AI knows these patterns cold.

What AI is bad at

Some things were consistently problematic:

  • Taste — AI doesn't have opinions about whether a button should be in the top-right or bottom-centre. It picks whatever the average app does. You have to be prescriptive.
  • Xcode project management — AI creates Swift files perfectly but cannot reliably update the .pbxproj file. We solved this with XcodeGen: define the project in YAML, regenerate after every change.
  • Schema migrations — SwiftData schema changes without default values cause silent crashes. AI doesn't always think about migration paths.
  • Integration testing — AI can write unit tests, but it can't tap through the app and notice that the convoy map feels laggy or the notification arrives 3 seconds late.

The XcodeGen lesson

This deserves its own section because it cost us hours before we solved it.

The first time we let Claude Code build a substantial feature (80+ files), it created every Swift file correctly but added zero of them to the Xcode project. The app built fine... with none of the new code included. We had an 86-file app where Xcode only knew about the original 4.

The fix: never let AI touch the project file. Instead, use XcodeGen. Define your project structure in a project.yml, and regenerate the .xcodeproj after every change. AI creates files, XcodeGen makes Xcode aware of them. Simple, reliable, automated.

We now have a verification script that catches this class of error in seconds:

#!/bin/bash
# Run after Claude Code changes
xcodegen generate
xcodebuild -scheme Rowta -destination 'platform=iOS Simulator' build

Where we are now

Rowta is on TestFlight (v1.0.4, build 11). It has:

  • Full trip lifecycle — planning, active, completed
  • Friends system with friend codes
  • Expense tracking with three split types
  • Real-time convoy tracking via Core Location
  • Push notifications via APNs
  • PostHog analytics

Built by a team of one human and one AI, mostly in evenings, over the course of a few weeks. The velocity is real. The constraints are real too.

What this means for indie devs

If you're an indie developer, AI coding doesn't replace you. It changes your bottleneck.

Before AI: your bottleneck was typing speed, boilerplate fatigue, and the friction of looking up APIs you've used before.

After AI: your bottleneck is knowing what to build. Product sense. Domain knowledge. Taste. The ability to write a clear brief and make quick judgment calls when the AI asks "which approach?"

The developers who thrive with AI aren't the ones who type fastest. They're the ones who think fastest.

AI is the material we work with. Not the architect. Not the client. The material.

We'll share more about the specific patterns and tools that work for us. If you're building iOS apps with AI and want to compare notes, reach out — [email protected].

Sett & Stone is a small software studio based in Yorkshire, UK. We build Rowta (trip planning), Glucoscape (diabetes management), and various tools for things we find interesting.