Tag: iOS

👋 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.

---

Nicholas Hart is a software engineer and technical writer passionate
about sharing knowledge and helping others learn. You can find more of
my work at:

• Website: nickhart.com
• GitHub: github.com/nickhart
• LinkedIn: linkedin.com/in/seanickhart

---