The 15-Minute iOS Project

👋 Introduction

For the past several months I’ve been building personal iOS apps to keep my skills current during my job search. I’d like to share a tool I’ve built that makes setting up a professional-grade iOS project take only minutes.

🕐 The Time Saving Inspiration

In the past when working on personal projects I tended to use a simple Git repository and do everything manually. It worked ok, even though sometimes in my excitement to push I’d forget to run the unit tests. However, once you’ve lived with professional automation that enforces code quality it is hard to go back. It’s such a huge productivity boost and helps prevent one from making simple mistakes and speeds up one’s development process.

However, I’ve found myself spending valuable time building out the same automation frameworks and tooling each time I set up a new iOS project. Setting up a project with CLI scripts, linting, code formatting, GitHub CI, and all the configuration files that make for a professional-grade project used to take hours of time. Last weekend I spent part of a day with Claude Code and came up with a GitHub Template Repository called SwiftProjectTemplate that aims for zero-configuration setup of new iOS projects, complete with GitHub CI workflow, code lint, code formatting, and build and test automation.

🧰 The Professional iOS Developer Tech Stack

There are certainly many ways to configure and organize a professional tech stack for iOS development. Below is what I prefer to use, and it is definitely CLI-centric. It might not be for everyone, especially if you prefer GUI dev tools.

📂 File Structure

My biggest pet peeve about Xcode’s new project wizard is that it gives you a really basic folder structure. A good iOS project has well-organized folders for keeping files together. SwiftProjectTemplate is very opinionated about using the MVVM pattern and automatically sets up a directory structure for you like so:

MyAwesomeApp/
├── MyAwesomeApp/
│   ├── Models/              # Data models and Core Data entities
│   ├── Views/               # SwiftUI views and UI components
│   ├── ViewModels/          # Business logic and view state
│   ├── Services/            # Network, persistence, business services
│   ├── Extensions/          # Swift extensions and utilities
│   └── Helpers/             # Helper functions and utilities
├── MyAwesomeAppTests/       # Unit tests (mirrors main structure)
├── MyAwesomeAppUITests/     # UI tests
└── scripts/                 # Development automation scripts

🍺 Homebrew

I rely on a bunch of tools from Homebrew to keep the project organized and the code clean. Using a Brewfile allows one to easily specify the required tools and install them.

⚙️ XcodeGen

My biggest frustration with Xcode has always been its project format. Merging changes from multiple users can be a serious pain, and if you do it wrong you can lose files or make the project file unreadable. XcodeGen solves that by using a simple YAML project.yml configuration file to automatically generate the Xcode project.

🎨 SwiftFormat

Everyone has their code style preferences. SwiftFormat allows one to configure how code should be formatted, and check/enforce the code style. It can also fix simple formatting issues around structure and spacing.

🔍 SwiftLint

A related tool that helps enforce consistent syntax and best practices is SwiftLint. This tool allows one to configure standards for code syntax, clarity, complexity, and consistency.

✨ xcbeautify

As a power command line user I appreciate readable output and logs. Xcode is quite verbose and xcbeautify helps make the copious Xcode build and test logs more user-friendly.

📄 yq

My preferred format for configuration files is YAML, which is just as expressive as JSON but a little easier on the eyes for us humans. The CLI command yq is a powerful tool for parsing YAML files and pulling data out of it so you can supercharge one’s scripts and automation.

🦾 GitHub CLI

GitHub provides a powerful command-line tool called gh for interacting with GitHub. I find it particularly useful for automating GitHub actions, debugging, and resolving errors in one’s CI workflow.

📝 VSCode + Markdownlint

I tend to use VSCode for all of my coding/editing beyond Swift and Xcode. It is a lightweight IDE that has a ton of functionality and extensions. The markdownlint extension makes editing Markdown easier by highlighting syntax/style issues and providing informative warnings. The SwiftProjectTemplate repo includes a .markdownlint.json that silences some common warnings about style that occur when writing a more compact style of Markdown (which I’ve found AI agents like to use).

💻 iTerm2

VSCode and macOS have their own terminals for entering commands, but once the scrollback buffer fills up the terminal starts jumping around and behaving oddly. If you’ve got a long-running Claude Code session you will encounter this highly annoying bug. I prefer to use iTerm2, which has superior configuration, customization, and scrollback buffer options than the built-in macOS Terminal. Increase your scrollback size to something huge like 500,000 lines (or unlimited) and enjoy using the terminal again!

🔨 Xcode

I tend to prefer using the latest Xcode tools and Swift version, so by default (as of this writing) the SwiftProjectTemplate will target iOS 18.0, Xcode 15.4, and Swift 5.10. I find it useful to use the latest tools, especially when creating a new project! However, I included the flexibility to configure different versions for those with specific use cases.

🗂️ GitHub

SwiftProjectTemplate automatically configures a GitHub PR template and CI workflow. It’s great having a consistent format for one’s pull requests, and it serves as a good reminder to follow best practices when merging code. (You did remember to test your code, right?) The CI workflow leverages a suite of scripts that are part of the repository and make the sometimes complicated CLI commands easier. It should work out of the box and SwiftProjectTemplate will generate a minimal iOS project with tests that should build and pass the full CI suite of quality gates.

🤖 CLI Scripts

The repo contains a ./scripts directory with helper scripts for common CLI operations (build, test, lint, format), as well as a Git hook for pre-commit validation, and a “preflight” script to easily do an automated validation on-demand. This is also where the setup.sh script lives, which bootstraps one’s project.

The really cool script though is simulator.sh which is a helper tool for the complicated xcrun simctl command–which I can never remember how to use, and has complicated arguments. This script makes it easy to find which simulators are available (by device, OS, and arch), as well as configure the default simulator to use for app tests and UI tests. It will write out a simulator.yml config file in the root of the project, which the test.sh and ui-test.sh scripts will read (via yq) in order to execute tests using one’s preferred simulator!

I have found this to be a real time saver, especially when configuring one’s GitHub CI workflow, as the simulators available on the GitHub runner might be different from what are in your local environment.

🤖 Collaborating With an AI Agent

One of my favorite ways to leverage AI agents is building automation infrastructure–especially CLI scripts. I am no expert on bash, awk, sed, and the myriad of obscure CLI tools with their myriad of complicated arguments and configuration options. What once might have taken me hours of googling to get a basic script working can now be accomplished in minutes, and achieve a sophisticated and user-friendly CLI command (complete with --help documentation and clear, verbose arguments, and informative feedback).

I’ve been using Claude Code for a while because I am partial to the CLI interface, and it doesn’t tie you to any specific editor.

Using Claude I’ve been able to easily set up GitHub workflows. Leveraging the gh CLI tool to debug workflow issues reduces the amount of trial-and-error commits and workflow runs–a time consuming and clunky way to debug one’s CI.

🪄 Using Xcode’s Project Wizard

SwiftProjectTemplate will generate a minimal iOS app–it doesn’t really do much. If you want a more fully-featured jumping off point I’d still recommend using Xcode’s new project wizard. Turn off the “Create Git repository on my Mac” option and then copy the generated files over, preserving your repository’s existing folder structure.

🚀 Contributing to the Developer Community

What started as a personal productivity tool has become something I’m excited to share with the broader iOS community. By turning SwiftProjectTemplate into a GitHub Template Repository, any developer can bootstrap a fully-configured professional iOS project in minutes.

The real win isn’t just individual time savings—it’s raising the baseline quality for iOS projects everywhere. When setup friction disappears, developers spend more time on what matters: building great apps. New developers get professional-grade tooling from day one, and experienced developers can focus on innovation rather than infrastructure.

There’s also an environmental consideration that’s increasingly important: AI resource efficiency. Rather than every developer burning through thousands of AI tokens recreating the same project setup, we can solve it once and share the solution. As AI becomes central to development workflows, being thoughtful about when and how we use these computationally intensive tools matters for both cost and carbon impact.

Setting up a professional iOS project used to mean hours of configuration before writing your first line of app code. Now it takes 15 minutes—and you only need to figure it out once.

Ready to try it? Check out SwiftProjectTemplate and start your next iOS project the right way.