How to Publish an App to the App Store — All Via Claude CLI

How to Publish an App to the App Store — All Via Claude CLI

Most developers think publishing to the App Store means hours of clicking through Xcode, wrestling with provisioning profiles, and filling out forms in App Store Connect. What if I told you the entire process — from writing code to hitting "Submit for Review" — can be done from your terminal using Claude CLI?

This isn't theory. I've done it. Here's exactly how.

Prerequisites

Before we start, you need three things:

  1. An Apple Developer Account ($99/year at developer.apple.com)
  2. Xcode installed (for the command-line tools and simulators)
  3. Claude CLI installed (npm install -g @anthropic-ai/claude-code)

That's it. You won't need to open Xcode's GUI even once.

Step 1: Scaffold Your App

Open your terminal and start a Claude session:

claude

Then tell Claude what you want:

> Create a new SwiftUI iOS app called "FocusTimer" — a minimal
  Pomodoro timer with start/pause, reset, and a clean dark UI.
  Use Swift Package Manager for dependencies.

Claude will generate the entire Xcode project structure:

FocusTimer/
├── FocusTimer.xcodeproj/
├── FocusTimer/
│   ├── FocusTimerApp.swift
│   ├── ContentView.swift
│   ├── TimerViewModel.swift
│   ├── Assets.xcassets/
│   └── Info.plist
└── Package.swift

It writes the SwiftUI views, the timer logic, the asset catalog — everything. You just review and approve.

Step 2: Build and Test from the Terminal

No need to open Xcode. Claude can run the build for you:

> Build the app for iPhone 16 simulator and run it

Under the hood, this triggers:

xcodebuild -scheme FocusTimer \
  -destination 'platform=iOS Simulator,name=iPhone 16' \
  build

** BUILD SUCCEEDED **

If there are errors, Claude reads them, fixes the code, and rebuilds — all without you lifting a finger.

Want to run tests?

> Run all unit tests for FocusTimer

xcodebuild test -scheme FocusTimer \
  -destination 'platform=iOS Simulator,name=iPhone 16'

Test Suite 'All tests' passed.
  TimerViewModelTests: 5/5 passed
  ContentViewTests: 3/3 passed

Step 3: Set Up Signing and Certificates

This is where most people give up. Provisioning profiles, certificates, entitlements — it's a maze. But Claude handles it:

> Set up automatic code signing for FocusTimer using my
  Apple Developer team. My team ID is ABCD1234.

Claude modifies the project.pbxproj file directly:

# Claude updates these build settings:
CODE_SIGN_STYLE = Automatic;
DEVELOPMENT_TEAM = ABCD1234;
PRODUCT_BUNDLE_IDENTIFIER = com.yourname.focustimer;

If you need manual signing with a specific profile, Claude can handle that too — it'll guide you through creating the certificate via the terminal using security and codesign commands.

Step 4: Create the App Store Listing

Here's where it gets fun. You need an app listing in App Store Connect before you can upload. Claude can do this via the App Store Connect API:

> Create an App Store Connect listing for FocusTimer.
  Category: Productivity.
  Write a compelling description and keywords.
  Generate the subtitle and promotional text too.

Claude will:

  1. Use the App Store Connect API with your API key
  2. Create the app record
  3. Generate a description like:
FocusTimer — Minimal Pomodoro for Deep Work

Stay focused with a beautifully simple timer. No clutter,
no distractions. Just start, focus, and break.

• One-tap start/pause
• Clean dark interface
• Customizable work and break intervals
• No account required
  1. Set keywords: pomodoro, timer, focus, productivity, deep work

Step 5: Generate Screenshots

App Store screenshots are mandatory. Claude can automate this:

> Take App Store screenshots of FocusTimer for iPhone 6.7"
  and iPad 13" displays. Capture the timer running, the
  pause state, and the settings screen.

This uses xcrun simctl under the hood:

# Launch on 6.7" simulator
xcrun simctl boot "iPhone 16 Pro Max"
xcrun simctl install booted FocusTimer.app

# Capture screenshots
xcrun simctl io booted screenshot timer_running.png
xcrun simctl io booted screenshot timer_paused.png
xcrun simctl io booted screenshot settings.png

Claude captures them, and you can upload directly via the App Store Connect API.

Step 6: Archive and Upload

The final steps — archive the app and upload it to App Store Connect:

> Archive FocusTimer for distribution and upload to
  App Store Connect

Claude runs:

# Create the archive
xcodebuild archive \
  -scheme FocusTimer \
  -archivePath ./build/FocusTimer.xcarchive \
  -destination 'generic/platform=iOS'

# Export the IPA
xcodebuild -exportArchive \
  -archivePath ./build/FocusTimer.xcarchive \
  -exportPath ./build/export \
  -exportOptionsPlist ExportOptions.plist

# Upload to App Store Connect
xcrun altool --upload-app \
  -f ./build/export/FocusTimer.ipa \
  -t ios \
  --apiKey YOUR_KEY_ID \
  --apiIssuer YOUR_ISSUER_ID

No errors uploading './build/export/FocusTimer.ipa'

That's it. Your app is now in App Store Connect, ready for review.

Step 7: Submit for Review

One last command:

> Submit FocusTimer version 1.0 for App Store review.
  Set the release type to manual.

Claude uses the App Store Connect API to:

  1. Select the uploaded build
  2. Attach it to the version
  3. Fill in the review information
  4. Submit for review
✓ Build 1.0 (1) attached to version 1.0
✓ App review information updated
✓ Submitted for review

Status: Waiting for Review

Now you wait. Apple typically reviews within 24–48 hours.

The Full Flow — One Terminal Session

Let's recap. From a single terminal, you:

  1. Scaffolded a full SwiftUI app
  2. Built and tested it on simulators
  3. Configured code signing
  4. Created the App Store listing with metadata
  5. Generated screenshots automatically
  6. Archived and uploaded the build
  7. Submitted for review

Zero Xcode GUI. Zero App Store Connect browser tabs. Just you, your terminal, and Claude.

Tips for a Smooth Workflow

Keep your API keys ready. Create an App Store Connect API key at appstoreconnect.apple.com/access/integrations/api and store it securely. Claude will need the Key ID, Issuer ID, and the .p8 private key file.

Use a CLAUDE.md file. Drop a CLAUDE.md in your project root with your team ID, bundle identifier prefix, and preferred signing configuration. Claude reads this automatically:

# Project Config
- Apple Team ID: ABCD1234
- Bundle ID prefix: com.yourname
- Signing: Automatic
- Minimum iOS: 17.0

Iterate fast. If Apple rejects the build, just tell Claude:

> Apple rejected FocusTimer because of missing privacy
  descriptions. Fix the Info.plist and resubmit.

Claude adds the required NSUserTrackingUsageDescription or whatever's missing, rebuilds, re-uploads, and resubmits. Five minutes, not five hours.

Why This Matters

The App Store submission process was designed for a world where developers needed visual tools to manage complexity. But with AI-powered CLI tools like Claude, that complexity becomes a conversation.

You describe what you want. Claude translates that into the dozens of xcodebuild, xcrun, and API calls needed to make it happen.

This isn't about replacing Xcode. It's about removing the friction between having an idea and getting it into people's hands.

Ship faster. Ship from the terminal. Ship with Claude.