App Store Connect CLI: Automate iOS Deployment

I shipped my first iOS app the old way. App Store Connect, Apple's web interface for managing your apps, is a marvel of bureaucratic design. You upload a build, wait for processing, navigate to TestFlight, add testers, fill out the review questionnaire, upload screenshots for all five device sizes, and then click Submit. If you want to repeat this for every build, you're clicking through the same fifteen screens, every single time.

When I started vibe coding iOS apps with Claude Code, the coding part got fast. Terrifyingly fast. Claude could scaffold a SwiftUI app, write the business logic, and get it building in an hour. But then I'd spend the next two hours manually pushing it through App Store Connect.

That's backwards. The bottleneck shouldn't be a web UI.

asc - the App Store Connect CLI - fixes this. And if you're building iOS apps with AI tools, it might be the most important developer tool you're not using.

What App Store Connect CLI Actually Does

The pitch is simple: everything you do on App Store Connect's website, you can now do from your terminal.

That means uploading IPA files, reviewing TestFlight crash reports, submitting app versions for review, managing metadata and localizations across 30+ languages, handling certificates and provisioning profiles, and running entire release workflows from a JSON config file.

Under the hood, asc wraps Apple's App Store Connect API. That API has over 1,200 endpoints, organized into 60+ command groups. The CLI surfaces all of them with a consistent interface. Instead of three browser tabs and fifteen clicks, you type a command.

# Upload a build
asc builds upload --path MyApp.ipa
 
# Submit for review
asc submissions create --version 2.1.0
 
# Check TestFlight feedback
asc beta-testers feedback --sort date --limit 20

This is the kind of tool that sounds incremental until you actually use it. Then it feels like removing a pebble from your shoe that you'd forgotten was there.

Why This Matters for Vibe Coding

If you're using Claude Code for iOS development, you've probably noticed the asymmetry. The AI handles the hard cognitive work: architecture decisions, SwiftUI layout, Core Data schemas, networking layers. You're left with the manual, repetitive work: deployments, screenshot management, metadata updates.

This is exactly the wrong distribution of labor.

Vibe coding is about removing friction from the creative and technical process. You describe what you want, the AI builds it, you iterate. But if every iteration cycle includes twenty minutes of clicking through App Store Connect, you're not really vibe coding. You're vibe coding the code and manually coding the deployment.

asc closes that gap. With the CLI, you can wire Claude Code to execute deployments as part of your workflow. You could, in theory, tell Claude "build the release version and push it to TestFlight" and have the entire pipeline run without touching a browser.

That's the real promise here. Not just saving time today. Enabling a fundamentally different way of shipping iOS software.

Getting Started in Ten Minutes

Installation is one command:

brew install asccli

Or if you prefer:

curl -fsSL https://asccli.sh/install.sh | sh

After installing, you need to authenticate with App Store Connect. You'll need an API key from Apple, which lives in App Store Connect under Users and Access, then Integrations, then App Store Connect API. Create a key, download the .p8 file, and note the Key ID and Issuer ID.

asc auth add \
  --key-id YOUR_KEY_ID \
  --issuer-id YOUR_ISSUER_ID \
  --private-key ./AuthKey_YOURID.p8

That's it. You're now authenticated. Every subsequent command uses this credential automatically.

Let me walk through the commands you'll actually use every week.

Uploading Builds to TestFlight

After archiving in Xcode, you export an IPA and upload it:

asc builds upload --path MyApp.ipa

asc handles the chunked upload and polls for processing status. No more watching the App Store Connect progress bar spin.

Reviewing Crash Reports

This one surprised me. The first time I ran it, I realized I had been missing crash reports for months because I never thought to check the TestFlight crash tab.

asc beta-testers crashes \
  --app-id YOUR_APP_ID \
  --sort date \
  --limit 50

You get structured output you can pipe, grep, or feed to Claude for analysis. "Here are the last 50 crash reports, what patterns do you see?" That's a conversation you can't have when crash reports live in a web UI.

Managing Metadata

Updating your App Store listing across languages used to be a spreadsheet nightmare. Now:

# List current localizations
asc apps localizations list --app-id YOUR_APP_ID
 
# Update description for US English
asc apps localizations update \
  --locale en-US \
  --description "Updated description here"

You can write your metadata in a JSON file and apply it in one command. Version control your App Store listing. Diff your descriptions. This is software development applied to app metadata.

Submitting for Review

asc submissions create \
  --app-id YOUR_APP_ID \
  --version 2.1.0

Add a --review-notes flag if you have notes for the reviewer. The command validates your submission before sending it, catching common issues before they trigger a rejection.

CI/CD Integration: The Real Unlock

The commands above are useful for ad-hoc work. The real unlock is integrating asc into your CI/CD pipeline.

Here's a GitHub Actions workflow that uploads every main branch push to TestFlight:

name: Deploy to TestFlight
 
on:
  push:
    branches: [main]
 
jobs:
  deploy:
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v4
 
      - name: Install asc
        run: brew install asccli
 
      - name: Authenticate
        run: |
          echo "${{ secrets.ASC_PRIVATE_KEY }}" > AuthKey.p8
          asc auth add \
            --key-id ${{ secrets.ASC_KEY_ID }} \
            --issuer-id ${{ secrets.ASC_ISSUER_ID }} \
            --private-key ./AuthKey.p8
 
      - name: Build and Archive
        run: |
          xcodebuild archive \
            -scheme MyApp \
            -archivePath MyApp.xcarchive
          xcodebuild -exportArchive \
            -archivePath MyApp.xcarchive \
            -exportPath ./build \
            -exportOptionsPlist ExportOptions.plist
 
      - name: Upload to TestFlight
        run: asc builds upload --path ./build/MyApp.ipa

Every push to main becomes a TestFlight build automatically. No manual steps. No browser. No clicking.

The same pattern works with GitLab CI, Bitrise, and CircleCI - asc ships with native configuration examples for all of them.

Reproducible Release Workflows

My favorite asc feature isn't a single command. It's the JSON workflow runner.

You define your entire release process in a JSON file:

{
  "steps": [
    { "command": "builds upload", "args": { "path": "./MyApp.ipa" } },
    { "command": "builds wait-for-processing", "args": { "version": "2.1.0" } },
    { "command": "beta-groups add-build", "args": { "group": "internal-testers" } },
    { "command": "submissions create", "args": { "version": "2.1.0" } }
  ]
}

Then run it:

asc workflow run --config release.json

This is infrastructure as code for your app release process. Check it into git. Review it in PRs. Know exactly what happens when you ship. If your release process broke last quarter because someone clicked the wrong button, this fixes that problem permanently.

The Bigger Picture: Closing the Loop on AI-Driven Development

There's a pattern emerging in how the best vibe coders work. They're not just using AI to write code. They're building closed loops where AI handles the entire development cycle.

Coding is almost solved. The best vibe coding tools can write production-quality code for most application types. Testing is getting there - AI can write test suites, run them, and fix failures. Deployment is the last remaining manual bottleneck for most teams.

For web applications, that bottleneck mostly disappeared when Vercel launched. Push to main, the app deploys. Done. iOS has been stuck in the old world: build in Xcode, archive, export, upload, configure TestFlight, submit. Each step is a context switch.

asc + GitHub Actions creates the same "push to main" experience for iOS. The loop closes.

This matters because of where AI-driven development is heading. As Claude Code and similar tools get better, you'll be prompting your way through entire features in a single session. The question is whether your deployment infrastructure can keep up. If shipping a build takes an hour of manual work, you'll ship less often. You'll batch changes. You'll lose the iteration speed that makes vibe coding valuable.

Everyone can code now, but shipping is still hard. asc makes the shipping part significantly less hard.

One Thing It Doesn't Do

I want to be honest about the limits.

asc doesn't handle code signing. You still need Xcode's automatic signing or a tool like fastlane match for certificate management. asc can list your existing certificates and provisioning profiles, and it can create new ones via the API, but setting up signing from scratch is still its own project.

For teams already using fastlane, asc is complementary rather than a replacement. fastlane handles code signing and build processes. asc handles the App Store Connect side: uploads, submissions, metadata, TestFlight configuration.

For solo developers and small teams starting fresh, asc alone is probably sufficient. It handles everything after you have a signed IPA.

What Vibe Coding iOS Actually Looks Like Now

Here's my current setup for iOS development:

1. Claude Code handles all feature development. I describe what I want, it writes SwiftUI code, I review and iterate.
2. Xcode Cloud handles builds. On every push, it compiles and runs tests.
3. asc handles everything else. TestFlight uploads, metadata updates, App Store submissions.

My actual time spent on deployment-related tasks dropped from a few hours per release to about fifteen minutes. Most of that fifteen minutes is reviewing the asc output and making sure nothing unexpected happened.

The rest of my time is spent on what actually matters: figuring out what to build and working with Claude to build it.

That's what vibe coding is supposed to feel like.

FAQ

What is App Store Connect CLI?

App Store Connect CLI (asc) is a command-line tool that lets you manage iOS and macOS app distribution workflows from your terminal. It wraps Apple's App Store Connect API with 1,200+ endpoints, covering builds, submissions, TestFlight, metadata, code signing, and CI/CD integration.

How do I install the asc CLI?

Install via Homebrew with brew install asccli or with the install script: curl -fsSL https://asccli.sh/install.sh | sh. Then authenticate with your App Store Connect API credentials using asc auth add.

Can I use asc with GitHub Actions?

Yes. asc has native CI/CD support for GitHub Actions, GitLab, Bitrise, and CircleCI. You store your App Store Connect API credentials as secrets and call asc commands in your workflow YAML. Many teams use it to automatically upload builds to TestFlight on every main branch push.

Does asc replace fastlane?

Not entirely. asc focuses on the App Store Connect API side: uploads, submissions, TestFlight, metadata. fastlane handles more of the Xcode build and code signing pipeline. They work well together. asc is simpler and easier to set up for teams that don't need fastlane's full feature set.

What do I need to authenticate asc?

You need an App Store Connect API key. Create one in App Store Connect under Users and Access, then Integrations, then App Store Connect API. You'll get a .p8 private key file, a Key ID, and an Issuer ID. Pass all three to asc auth add and you're ready.

Can asc manage App Store screenshots and preview videos?

Yes. asc can upload and manage screenshots and video previews for your App Store listing, including localized versions for different languages and device sizes. This is one of the most tedious tasks to do manually, and automating it saves significant time.

Is asc free to use?

Yes. asc is a free, lightweight CLI tool. The only requirement is an App Store Connect API key, which is free to create if you have an Apple Developer account.