iOS Build Configuration & CI/CD

Comprehensive iOS build automation and CI/CD pipeline setup that integrates all quality checks, testing, and deployment into a seamless automated workflow.

When to Use This Skill

Use this skill when:

• Setting up multiple build configurations (Debug, Staging, Release)
• Automating code signing with Fastlane Match
• Creating CI/CD pipelines (GitHub Actions, GitLab CI, Bitbucket)
• Configuring TestFlight automated distribution
• Setting up App Store submission automation
• Integrating crash reporting (Crashlytics, Sentry)
• Implementing feature flags for gradual rollouts
• Automating quality checks and testing in CI/CD
• Managing environment-specific configurations
• Setting up one-command deployment workflows

Core Capabilities

1. Build Configuration Management

   • Multiple build schemes (Debug/Staging/Release)
   • Environment-specific settings
   • Bundle ID management
   • Compiler optimization configuration

2. Code Signing Automation

   • Fastlane Match setup
   • Certificate management
   • Provisioning profile automation
   • Team management

3. CI/CD Pipeline Creation

   • GitHub Actions workflows
   • GitLab CI pipelines
   • Bitbucket Pipelines
   • Automated quality gates

4. Fastlane Configuration

   • Test lanes
   • Build lanes
   • Deployment lanes
   • Quality check integration

5. Crash Reporting Setup

   • Firebase Crashlytics integration
   • Error tracking
   • Breadcrumb logging
   • User identification

6. Feature Flag Infrastructure

   • Local feature flags
   • Remote config readiness
   • SwiftUI integration
   • Debug UI

Available Scripts

setup_build_schemes.py

Generate complete build configuration setup with Debug, Staging, and Release environments.

Usage:

python setup_build_schemes.py com.example.app [project-directory]

Output:

• .xcconfig files for each configuration
• Environment.swift for runtime access
• Configuration summary JSON

Example:

python setup_build_schemes.py com.mortgage.calculator .

generate_fastlane_config.py

Generate comprehensive Fastlane configuration with lanes for testing, building, and deployment.

Usage:

python generate_fastlane_config.py <app-id> <apple-id> <team-id> <itc-team-id> [certs-repo]

Output:

• Fastfile with complete lane definitions
• Appfile with app credentials
• Matchfile for code signing
• Gymfile and Scanfile for build/test config

Example:

python generate_fastlane_config.py \\
  com.mortgage.calculator \\
  dev@example.com \\
  ABC123 \\
  12345 \\
  https://github.com/org/certs.git

Generated Lanes:

• fastlane test - Run all tests with coverage
• fastlane quality - Run all quality checks (integrates existing skills)
• fastlane beta - Build and deploy to TestFlight
• fastlane release - Submit to App Store
• fastlane certificates - Sync code signing

create_github_workflow.py

Generate GitHub Actions workflows for complete CI/CD automation.

Usage:

python create_github_workflow.py <workflow-type>

Workflow Types:

• ci - Complete CI workflow with quality checks and tests
• testflight - TestFlight deployment workflow
• release - App Store release workflow
• all - Generate all workflows

Output:

• .github/workflows/ci.yml - Main CI pipeline
• .github/workflows/testflight.yml - TestFlight deployment
• .github/workflows/release.yml - App Store submission

Example:

python create_github_workflow.py all

Key Features:

• Parallel quality checks (Code Quality Auditor, Architecture Review)
• Matrix testing across devices
• Code coverage enforcement (80% threshold)
• Automatic TestFlight deployment on main branch
• Manual App Store release on tags

setup_crashlytics.py

Generate Firebase Crashlytics integration code and configuration.

Usage:

python setup_crashlytics.py

Output:

• CrashlyticsManager.swift - Complete crash reporting manager
• AppDelegate-Integration.swift - App integration code
• upload-symbols-build-phase.sh - Xcode build phase script
• Podfile-snippet.rb - CocoaPods dependencies

Features:

• Error tracking and logging
• User identification
• Custom keys and breadcrumbs
• Environment-aware configuration
• Test crash methods for validation

create_feature_flags.py

Generate complete feature flag infrastructure with local and remote config support.

Usage:

python create_feature_flags.py

Output:

• FeatureFlagManager.swift - Feature flag manager
• FeatureFlags-Usage-Examples.swift - Integration examples

Features:

• Type-safe feature definitions
• SwiftUI property wrapper
• View modifiers for conditional rendering
• Persistence with UserDefaults
• Debug UI for testing
• Firebase Remote Config ready

Reference Documentation

build-configurations.md

Complete guide to iOS build configurations:

• Configuration settings by environment
• Xcode scheme setup
• .xcconfig file management
• Code signing configuration
• Environment management in code
• Best practices and troubleshooting

When to read: Setting up or modifying build configurations, understanding environment management, troubleshooting build settings.

cicd-workflows.md

Comprehensive CI/CD pipeline examples:

• Complete workflow architecture
• GitHub Actions examples (CI, TestFlight, Release)
• GitLab CI configuration
• Bitbucket Pipelines setup
• Best practices (caching, parallel execution, secrets)
• Quality gates and failure handling

When to read: Creating new CI/CD pipelines, optimizing existing workflows, adding quality gates, setting up deployment automation.

fastlane-reference.md

Complete Fastlane reference:

• All common lane patterns
• Essential actions (build_app, run_tests, match, upload_to_testflight)
• Configuration files (Appfile, Matchfile, Gymfile)
• Advanced patterns (parameterized lanes, error handling)
• Plugins and best practices
• Troubleshooting guide

When to read: Writing or debugging Fastlane lanes, understanding Fastlane actions, configuring code signing with Match.

Integration with Existing Skills

This skill is designed to automate all your existing iOS skills in a CI/CD pipeline:

1. iOS Code Quality Auditor

lane :audit_quality do
  sh("python3 ../ios-code-quality-auditor/scripts/audit_code.py .")
end

CI Integration:

- name: Run Code Quality Audit
  run: python3 ios-code-quality-auditor/scripts/audit_code.py .

2. SwiftUI Architecture Review

lane :audit_architecture do
  sh("python3 ../swiftui-architecture-review/scripts/analyze_architecture.py .")
end

CI Integration:

- name: Architecture Review
  run: python3 swiftui-architecture-review/scripts/analyze_architecture.py .

3. iOS Testing Suite Generator

lane :test do
  run_tests(
    scheme: "MortgageCalculator",
    code_coverage: true
  )
end

CI Integration:

- name: Run Tests
  run: xcodebuild test -scheme MortgageCalculator -enableCodeCoverage YES

4. App Store Submission

lane :validate_submission do
  sh("python3 ../app-store-submission/scripts/validate_submission.py .")
end

CI Integration:

- name: App Store Validation
  run: python3 app-store-submission/scripts/validate_submission.py .

5. PDF Generation & Export

- name: Verify PDF Export
  run: |
    xcodebuild test \\
      -scheme MortgageCalculator \\
      -testPlan PDFExportTests

Complete Workflow Example

Initial Setup

1. Set up build configurations:

python scripts/setup_build_schemes.py com.mortgage.calculator .

2. Generate Fastlane config:

python scripts/generate_fastlane_config.py \\
  com.mortgage.calculator \\
  dev@example.com \\
  ABC123DEF4 \\
  12345

3. Create CI/CD workflows:

python scripts/create_github_workflow.py all

4. Set up crash reporting:

python scripts/setup_crashlytics.py

5. Add feature flags:

python scripts/create_feature_flags.py

Automated Pipeline Flow

Developer pushes code
    ↓
GitHub Actions triggers
    ↓
Quality Checks (parallel):
  • iOS Code Quality Auditor ✓
  • SwiftUI Architecture Review ✓
  • SwiftLint ✓
    ↓
Tests (parallel):
  • Unit Tests ✓
  • UI Tests ✓
  • Coverage Check (80%+) ✓
    ↓
Build:
  • Debug (develop branch)
  • Release (main branch)
    ↓
Validation:
  • App Store Pre-flight ✓
  • PDF Export Verification ✓
    ↓
Deploy (conditional):
  • TestFlight (main branch)
  • App Store (tagged release)
    ↓
Monitor:
  • Crashlytics tracking
  • Feature flag management
    ↓
Notify Team (Slack/Email)

One-Command Deployment

After setup, deployment becomes simple:

# Deploy to TestFlight
fastlane beta

# Release to App Store
fastlane release

# Run all quality checks
fastlane quality

# Test everything
fastlane test

Best Practices

1. Separate Configurations

Maintain distinct configurations for each environment with unique bundle IDs:

• com.example.app.debug (Debug)
• com.example.app.staging (Staging)
• com.example.app (Release)

This allows installing multiple builds simultaneously for testing.

2. Automate Code Signing

Use Fastlane Match to manage certificates and profiles in a git repository:

• One source of truth for all certificates
• Easy team onboarding
• No manual certificate management
• Works seamlessly in CI/CD

3. Quality Gates

Fail builds early on quality issues:

• Code quality audit must pass
• Architecture review must pass
• Tests must pass with 80%+ coverage
• App Store validation must pass

4. Incremental Build Numbers

Always increment build numbers automatically:

increment_build_number(
  build_number: latest_testflight_build_number + 1
)

5. Feature Flags for Rollouts

Use feature flags to:

• Gradually roll out new features
• A/B test implementations
• Kill switches for problematic features
• Environment-specific features

6. Monitor Crashes

Integrate Crashlytics from day one:

• Track errors in production
• Identify crash patterns
• Monitor user impact
• Fix issues proactively

7. Document Your Pipeline

Maintain a CI/CD documentation file:

• Required secrets
• Deployment process
• Rollback procedures
• Emergency contacts

Secrets Management

Required secrets for GitHub Actions:

# Code Signing
MATCH_PASSWORD              # Password for certificates repo
MATCH_GIT_BASIC_AUTHORIZATION  # Git access token

# Apple Developer
APPLE_ID                    # Apple ID email
APPLE_ID_PASSWORD          # Apple ID password
APP_SPECIFIC_PASSWORD      # App-specific password

# Notifications (optional)
SLACK_WEBHOOK              # Slack webhook URL

Set these in: Repository Settings → Secrets and variables → Actions

Troubleshooting

Build Failures

Issue: Code signing errors

# Reset Match certificates
fastlane match appstore --force

Issue: Tests failing in CI but passing locally

# Check simulator availability
xcrun simctl list devices

# Clean derived data
rm -rf ~/Library/Developer/Xcode/DerivedData

Issue: Wrong configuration being built

# Verify scheme configuration
xcodebuild -list -project MortgageCalculator.xcodeproj

Deployment Failures

Issue: TestFlight upload timeout

# Increase timeout in Fastfile
upload_to_testflight(
  skip_waiting_for_build_processing: true
)

Issue: App Store Connect authentication

# Verify credentials
fastlane spaceauth -u dev@example.com

Quick Start Checklist

• Run setup_build_schemes.py to create configurations
• Run generate_fastlane_config.py to setup Fastlane
• Run create_github_workflow.py all for CI/CD
• Add required GitHub secrets
• Test locally with fastlane test
• Commit and push workflows
• Verify CI pipeline runs
• Deploy to TestFlight with fastlane beta
• Set up Crashlytics with setup_crashlytics.py
• Add feature flags with create_feature_flags.py

Real-World Example: Mortgage Calculator App

Before automation:

• ✗ Manual testing before each commit
• ✗ Remembering to run quality checks
• ✗ Time-consuming TestFlight uploads
• ✗ Manual App Store submissions
• ✗ Certificate management headaches

After automation:

• ✓ Push code → automatic quality validation
• ✓ Merge to main → automatic TestFlight deployment
• ✓ Tag release → automatic App Store submission
• ✓ Crashlytics tracks production issues
• ✓ Feature flags enable safe rollouts
• ✓ One command deploys everything: fastlane beta

Time savings: ~2 hours per week Quality improvement: 100% consistent quality checks Deployment confidence: Every release fully validated