Two weeks ago, I wrapped up my first project while working at Atomic Object: a voice-first golf scorekeeping app, built native in Swift. Before this, I had never done iOS development or written any Swift.
AI made learning a new language a lot easier, but writing the code is only half the battle. Claude couldn’t help me as much with tasks like setting up my editor, keeping the tests and builds fast, demoing to a client, and getting through App Store review. I figured those out through trial and error, learning a few tricks along the way. This post is my guide to the human side of iOS development: the steps AI can’t teach you that make day-to-day work smoother.
1. Get working code navigation in VS Code.
I quickly found that Xcode is not the most user-friendly IDE. If you’d rather edit in VS Code, navigation features like ⌘-click or Go to References won’t work out of the box.
To fix that:
- Install the Swift extension in VS Code.
- Build the project once in Xcode so there’s an index to read.
- Generate a build server config from the repo root:
brew install xcode-build-server xcode-build-server config -project App.xcodeproj -scheme Dev
This writes buildServer.json at the repo root. Add it to your .gitignore, since it contains paths specific to your machine.
2. Turn off “Debug executable” when the simulator drags.
As the app grew, Xcode got slower to build and run. Turning off the debugger makes a noticeable difference:
Scheme → Edit Scheme → Run → Info → uncheck Debug executable.
The app launches faster and stops stalling under the debugger. The tradeoff is that breakpoints and simulated location stop working until you turn it back on, so I toggle it as needed.
If things keep acting up, a quick Product → Clean Build Folder never hurts.
3. Make your demos easy to follow.
Demoing an iOS app over Zoom can be disorienting. We’re used to holding our phones, tapping the screen, and feeling the phone respond. Watching someone else’s phone on a laptop takes all of that away, making it hard to tell what’s happening on screen. Here’s how I set up demos so my client and coworkers could follow along.
Show a cursor. By using a trackpad connected to my phone, my audience could see exactly what I was tapping, and I could also point to the part of the screen I wanted them to look at.
- Plug an Apple Magic Trackpad into the iPhone with a USB-C cable. (I couldn’t get it to pair over Bluetooth, but a Bluetooth mouse also works if you have one.)
- On the iPhone, go to Settings → Accessibility → Touch → AssistiveTouch and turn it on.
- Under Pointer Devices → Devices, you should see your Magic Trackpad (or whatever mouse you’re using).
- Turn off Always Show Menu to hide the floating AssistiveTouch button.
Next, I had to get my phone’s screen onto the call. QuickTime can mirror an iPhone over a cable, but my phone’s only port was already taken by the trackpad. QuickTime can also mirror wirelessly, but only when the Mac and iPhone are signed in to the same Apple account, and mine weren’t. The solution was to mirror directly into Zoom:
- In Zoom: Share → Other → iPhone/iPad via AirPlay.
- On the iPhone: Control Center → Screen Mirroring → pick Zoom.
If your Mac and iPhone are on the same Apple account, you can mirror with QuickTime instead: File → New Movie Recording, then choose the iPhone as the camera source.
4. Save a simulator that matches your client’s phone.
Our client tested on an iPhone 17 with a larger text size. To see exactly what they were seeing, I made a simulator to match:
- Xcode → Window → Devices and Simulators → +.
- Pick the model and give it a name (“Bob’s Phone”).
- Boot it, then go to Settings → Accessibility → Display & Text Size → Larger Text.
- Pick the model and give it a name (“Bob’s Phone”).
- Boot it, then go to Settings → Accessibility → Display & Text Size → Larger Text.
The setting stays with that simulator, so it’s always ready.
While I’m on the topic of simulators: they can’t use the microphone or camera. Anything that records audio, uses speech recognition, or uses the camera has to be tested on a physical device.
5. Know which kind of review you’re dealing with.
TestFlight and the App Store have three levels of access, and each one has different review requirements. When I asked Claude what we needed for an external beta, it mixed up beta requirements with App Store requirements, making external beta look much stricter than it is. Here’s how they actually differ:
- Internal testers are people on your App Store Connect team. They get builds right away with no review. We added our designer, our delivery lead, and anyone else we wanted quick feedback from. For our first beta round, we also added a few test users to the team in a Marketing role so we could skip review. Looking back, submitting to external beta would probably have been just as easy.
- External testers are anyone with an invite or a public link, and their builds need Beta App Review. It’s much lighter than App Store review: it mostly checks that the app launches, doesn’t crash, and that the reviewer can get in. You can resubmit as often as you need, so start early instead of waiting until the app feels finished.
- The App Store reviews everything against the full guidelines: screenshots, description, privacy policy URL, privacy labels, no placeholder content, and rules like account deletion if users can create accounts. Expect a few rounds of rejections the first time.
Wrapping up
AI got me writing Swift much faster than I expected. But what made the project go smoothly was the stuff I learned by doing: the tooling, the simulator, the demos, and the review process. Hopefully this saves you some of that trial and error. Thanks for reading!
If you’re starting an iOS project of your own, I turned my project’s setup into a skeleton you can clone: ao-ios-starter. It builds and runs right away, with placeholder screens you can swap out. Happy building!