Willsey demonstrates the full build/sign/notarize/ship lifecycle for Mac and iOS apps using only Apple's first-party CLI tools (xcodebuild, xcrun, altool/notarytool) plus .xcconfig files and shell scripts. His thesis is that no third-party wrapper like Fastlane or Tuist is needed — the primitives have always been there, developers just defaulted to clicking Cmd-R in Xcode.app out of habit.
A significant share of the top HN comments came from experienced iOS developers pointing out that their CI pipelines have been built on xcodebuild and xcrun for years. To them, Willsey's post is a useful walkthrough but not a revelation — it just makes visible what shipping teams have long treated as table stakes.
The other half of the top HN thread was developers admitting they'd assumed the IDE was load-bearing and had never explored the underlying commands. For them, the post reframes iOS development as scriptable in the same way web, Android, and backend workflows already are — removing what felt like a uniquely GUI-bound corner of the industry.
Scott Willsey's post — which climbed to 415 points on Hacker News — walks through the full lifecycle of building, signing, notarizing, and shipping a Mac and iOS app without ever launching Xcode.app. Not "mostly without." Not "with a helper script." The IDE icon never gets clicked. Everything runs from a terminal, and by extension, from CI.
The stack is entirely first-party: `xcodebuild` for compilation and archiving, `xcrun` for the codesigning and notarization dance, `altool` (and increasingly `notarytool`) for uploading to App Store Connect, and a handful of `.xcconfig` files to keep build settings in text rather than buried in `project.pbxproj`. Willsey stitches these together with plain shell scripts. There's no Fastlane, no Tuist, no third-party wrapper — just the tools Apple ships and a text editor.
The punchline is that Apple's command-line story has been quietly complete for years; the IDE was the habit, not the requirement. The HN thread reflected this: half the top comments were seasoned iOS developers saying "yes, this is how our CI has worked forever," and the other half were developers admitting they'd never realized Xcode.app was optional.
For twenty years, iOS development has been the last major platform where the IDE was effectively load-bearing. Web devs script their builds. Android devs script their builds (Gradle is many things, but it is scriptable). Backend devs would riot if they had to click through a GUI to ship. iOS developers, meanwhile, have lived with a workflow where the canonical build was whatever happened when you hit Cmd-R inside Xcode, and reproducing that in CI required either Fastlane's substantial abstraction layer or an unpleasant afternoon with `xcodebuild` documentation.
Willsey's post matters because it demystifies the underlying primitives. Once you see the actual commands laid out — `xcodebuild -scheme Foo -configuration Release -archivePath ...`, `xcrun notarytool submit ... --wait`, `xcrun stapler staple ...` — the whole thing stops being magic. It's just processes with arguments. This is the difference between a workflow you can debug and a workflow you cross your fingers over.
There are three concrete benefits practitioners called out in the HN discussion. First, diffability: `.xcconfig` files live in git and produce readable diffs, unlike `project.pbxproj`, which is a UUID-strewn horror show that merges like broken glass. Second, reproducibility: a scripted build produces the same artifact on your laptop and on the CI runner, which matters when you're chasing down a "works on my machine" signing failure at 11pm before a release. Third, onboarding: a new engineer can read a fifty-line shell script and understand the entire pipeline, versus reverse-engineering what happens when someone clicks Product → Archive.
The interesting counterargument, which came from a few Apple-platform veterans in the thread, is that Xcode still owns things the CLI doesn't easily replicate — asset catalog previews, storyboard editing, Instruments profiling, and the increasingly opaque "Signing & Capabilities" tab that reaches out to App Store Connect to provision things on your behalf. Fair. But none of those are *build* concerns. You can develop in Xcode and still ship from a script. Most teams that do this seriously already do.
What Willsey has actually written is a Rosetta Stone for treating iOS like a normal platform. The post's popularity suggests a real appetite for that — especially now that agentic coding tools (Claude Code, Codex, Cursor's background agents) can drive terminals but can't drive Xcode's UI. A build pipeline that lives in scripts is a build pipeline an AI agent can operate.
If you ship an iOS or Mac app and your release process still involves a human clicking through Xcode's Organizer window, this is the week to change that. The migration is smaller than you think. Start by extracting your build settings into an `.xcconfig` — Xcode will happily read from it, so you can do this without breaking your existing workflow. Then wrap the archive step in a shell script. Then the export step. Then notarization. Each piece is independently useful; you don't need a big-bang rewrite.
The notarization piece is where most teams get stuck, and it's worth calling out specifically. `notarytool` replaced `altool` for notarization submissions in late 2023, and it's dramatically better — synchronous waiting, real error output, no more polling loops. If your CI still uses `altool submit --notarize-app`, that's technical debt. Migrate. The command surface is small and the failure modes are finally legible.
For teams evaluating whether to adopt Fastlane, the honest answer in 2026 is: probably not, unless you specifically need its App Store metadata management or screenshot automation. The build and ship steps are now clean enough in native tooling that Fastlane's abstraction is often more overhead than help. Fastlane made sense when `xcodebuild`'s error messages were incomprehensible and `altool` was a black box. Both have improved. The Ruby dependency, the plugin ecosystem drift, and the periodic Fastlane-breaks-on-new-Xcode dance are real costs. Weigh them.
For solo developers and small teams, the payoff is different but larger: your build pipeline becomes something you can hand to an AI agent. "Run the release script, tell me if notarization fails" is a tractable prompt. "Open Xcode and click Product → Archive" is not.
The direction of travel is clear: Apple's own tooling is getting more headless-friendly, not less. `notarytool`, the `xcodebuild -exportArchive` improvements, and the Swift Package Manager's steady encroachment on `.xcodeproj` all point at a future where the IDE is one client of a scriptable toolchain rather than the toolchain itself. Willsey's post is a snapshot of a workflow that already works today. The next few years will make it the default, and iOS will finally stop being the platform where CI feels like it's fighting the vendor.
I've been building and testing my iOS app just for fun via Linux only.Surprisingly, it's very easy. This works like a charm: https://github.com/xtool-org/xtoolYou do not need to upload to TestFlight or the App Store; you can just install the app locally to your iPhone v
If it's okay to mention my own complementary open source project, Axiom¹ does a good job of helping coding harnesses know how to do this effectively for Apple OS development.In addition to a deep roster of skills and agencts, Axiom includes several for-LLM tools². xclog, xcprof, xcsym, and xcui
It's kind of funny to be reading this:> I had Claude Code create mine: I told Claude, more or less: I want to archive, Developer ID-sign, notarize, staple, and install this app to /Applications without ever opening Xcode. Write me a script that does the whole chain and fails loudly if a
Technically, you are using Xcode.Xcode is a [buggy as hell] GUI wrapper for a lot of system-level UNIX utilities and apps [which are generally, not so buggy].Using CLI to release apps is a pretty old practice; at least as long as I've been doing it (I released my first Xcode app in 2012).
Top 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.
One down-side to this is that it does require you to run the agent on your Mac instead of in a Sandbox. I do this too and there are lots of problems I can't solve in a sandbox. I know a lot of you are throwing your hands up at the years of security practices we're throwing out the window w