home / skills / willsigmon / sigstack / bitrise-expert

bitrise-expert skill

safe

This skill streamlines iOS CI/CD with Bitrise by managing macOS runners, auto code signing, and TestFlight deployment across projects.

npx playbooks add skill willsigmon/sigstack --skill bitrise-expert

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

2.4 KB

---
name: Bitrise Expert
description: Bitrise CI/CD - iOS builds, automated testing, deployment, managed macOS runners
allowed-tools: Read, Edit, Bash, WebFetch
model: sonnet
---

# Bitrise CI/CD Expert

Mobile-focused CI/CD platform with managed macOS infrastructure.

## Pricing (2026)

| Plan | Credits/mo | Price |
|------|------------|-------|
| Hobby | 300 | Free |
| Starter | 500 | $35/mo |
| Teams | 1,500 | $90/mo |
| Enterprise | Custom | Custom |

## Key Features
- Managed macOS with latest Xcode (within 24 hours)
- Automatic code signing
- 300+ integrations
- Native Apple Silicon support

## bitrise.yml Configuration

### Basic iOS Build
```yaml
format_version: "13"
default_step_lib_source: https://github.com/bitrise-io/bitrise-steplib.git

workflows:
  primary:
    steps:
    - git-clone@8: {}
    - cache-pull@2: {}
    - cocoapods-install@2: {}

    - xcode-test@5:
        inputs:
        - project_path: App.xcworkspace
        - scheme: App

    - xcode-archive@5:
        inputs:
        - project_path: App.xcworkspace
        - scheme: App
        - distribution_method: app-store

    - deploy-to-bitrise-io@2: {}
    - cache-push@2: {}
```

### TestFlight Deployment
```yaml
workflows:
  deploy:
    steps:
    - certificate-and-profile-installer@1: {}
    - xcode-archive@5:
        inputs:
        - distribution_method: app-store
    - deploy-to-itunesconnect-deliver@2:
        inputs:
        - connection: api_key
        - api_key_path: $BITRISEIO_API_KEY_PATH
        - submit_to_testflight: "yes"
```

## Code Signing

### Automatic (Recommended)
1. Connect Apple Developer account
2. Bitrise generates profiles automatically
3. No manual certificate management

### Manual
```yaml
- certificate-and-profile-installer@1:
    inputs:
    - certificate_url: $BITRISE_CERTIFICATE_URL
    - certificate_passphrase: $BITRISE_CERTIFICATE_PASSPHRASE
    - provisioning_profile_url: $BITRISE_PROVISION_URL
```

## Triggers

```yaml
trigger_map:
- push_branch: main
  workflow: deploy
- pull_request_source_branch: "*"
  workflow: primary
```

## Caching

```yaml
- cache-pull@2: {}  # At start

# After dependencies
- cache-push@2:
    inputs:
    - cache_paths: |
        ./Pods -> ./Podfile.lock
        ~/.cocoapods -> ./Podfile.lock
```

## Advantages over Xcode Cloud
- Android + iOS in one platform
- More Xcode version options
- External tool integrations
- Self-hosted runner option

Use when: iOS CI/CD, TestFlight automation, multi-platform mobile builds

Overview

This skill encapsulates Bitrise CI/CD expertise for mobile apps, with a focus on iOS builds, automated testing, signing, and TestFlight deployment. It highlights managed macOS runners, Apple Silicon support, and practical bitrise.yml patterns to get pipelines running quickly. Pricing tiers and the platform advantages over Xcode Cloud are summarized to guide platform selection. The skill is practical for teams needing multi-platform CI and fast Xcode updates.

How this skill works

The skill inspects and produces Bitrise workflow patterns and configuration snippets (bitrise.yml) for common mobile CI tasks: clone, dependency install, test, archive, and deploy. It explains automatic and manual code signing flows, trigger maps for branch-based workflows, and caching strategies to speed builds. Example workflows for basic iOS builds and TestFlight deployment are included, plus notes on managed macOS runners and integration points.

When to use it

Set up CI for iOS apps that require managed macOS runners and frequent Xcode updates.
Automate TestFlight submissions and app-store archives with API key-based deployment.
Run combined Android and iOS pipelines from a single CI platform.
Adopt caching and dependency steps to reduce build times for teams using CocoaPods.
Choose Bitrise when you need third-party integrations and optional self-hosted runners.

Best practices

Use the recommended automatic code signing by connecting your Apple Developer account to avoid manual certificate churn.
Keep bitrise.yml modular: separate workflows for PR testing (primary) and releases (deploy).
Cache CocoaPods and other dependencies; push cache after installs and pull at workflow start.
Pin step versions (e.g., xcode-archive@5) to ensure reproducible pipelines and predictable upgrades.
Store sensitive values in Bitrise Secrets and use API key-based deliver uploads for TestFlight.

Example use cases

Basic iOS CI: git-clone, cocoapods-install, xcode-test, xcode-archive, deploy-to-bitrise-io.
Automated TestFlight release: certificate-and-profile-installer, xcode-archive, deploy-to-itunesconnect-deliver with API key.
Multi-platform mobile pipeline: run Android and iOS workflows in the same project with platform-specific steps.
Fast iteration: leverage managed macOS runners with the latest Xcode updates within 24 hours.
Enterprise: migrate to self-hosted runners for on-prem macOS builds while keeping Bitrise orchestration.

FAQ

How does automatic code signing work?

Connect your Apple Developer account and Bitrise will generate and manage provisioning profiles and certificates automatically, removing manual certificate handling.

Can I deploy to TestFlight automatically?

Yes — include deploy-to-itunesconnect-deliver in your deploy workflow and provide an API key via Bitrise secrets to submit builds to TestFlight.