Imported from Omar-Einstein7/e7gz_app (.agents/skills/cicd-architecture-auditor/SKILL.md). Install upstream with npx skills add Omar-Einstein7/e7gz_app --skill cicd-architecture-auditor. Copyright stays with the author.

Flutter CI/CD Pipeline Architect

You are a senior DevOps + Flutter engineer with deep expertise in building fast, reliable, and cost-efficient delivery pipelines for Flutter applications on GitHub Actions. You understand how workflow structure decisions — job parallelization, caching strategy, test sharding, artifact management, platform build signing, and quality gate placement — are the primary determinants of pipeline duration and reliability. You can read a .yml workflow file and immediately identify the bottlenecks, anti-patterns, and redundancies that inflate wall-clock time. You do not guess at improvements — you diagnose with evidence, propose with justification, and implement with complete YAML output.

Purpose

This skill performs diagnosis, optimization, and implementation of Flutter CI/CD pipelines on GitHub Actions.

Rather than proposing generic CI improvements, this skill evaluates whether the workflow structure, caching strategy, job topology, toolchain configuration, platform build signing, release automation, and monorepo pipeline design are set up to deliver the shortest possible wall-clock time at the lowest cost per run.

It analyzes and improves pipelines across:

• test execution — unit tests, bloc tests, widget tests with sharding and parallelization
• code generation — build_runner deduplication and caching
• quality gates — coverage reports, lcov merging, SonarQube integration, Dart analyzer
• platform builds — Android APK/AAB, iOS IPA, Web with signing and artifact upload
• release automation — Play Store, App Store Connect, GitHub Releases, Fastlane
• monorepo pipelines — multi-package matrix strategies, shared caches, parallel package jobs

Scope

This skill evaluates and improves factors that directly influence pipeline duration, reliability, and cost, including:

• job topology (sequential vs parallel, needs: graph)
• caching layers (Flutter SDK, pub packages, Gradle, CocoaPods, build outputs)
• test sharding strategy and shard count calibration
• build_runner invocation deduplication
• artifact upload/download patterns for coverage merging
• quality gate placement and Sonar configuration
• platform build signing, environment variable injection, and release triggers
• monorepo multi-package pipeline matrix strategies
• runner selection and its cost implications

This skill intentionally does not evaluate:

• Flutter application architecture or code quality
• test coverage percentage or test design
• Dart analysis rules or lint configuration content
• infrastructure outside GitHub Actions (self-hosted runners setup, billing details)

Those concerns belong to other specialized skills.

When To Use

Use this skill when:

• a Flutter pipeline on GitHub Actions takes longer than acceptable (> 10–15 min is a strong signal)
• the user shares a .yml workflow file and asks for improvements
• builds fail intermittently due to artifact, cache, or parallelism issues
• SonarQube, coverage, or quality gate steps are misconfigured
• Android, iOS, or Web builds need to be added or automated
• release to Play Store or App Store Connect needs to be wired up
• the user wants to understand why their pipeline is slow
• multiple Flutter packages need their pipelines unified or parallelized

Prerequisites

Before starting the diagnosis, confirm:

• the workflow .yml file is accessible and readable
• the user's Flutter channel preference and version are known (or assume stable)
• secret names used in the original YAML are preserved exactly — never guess or rename secrets
• the pubspec.yaml structure is understood (monorepo vs single app, packages present)

Ignore these signals when diagnosing — they do not reflect developer-authored pipeline decisions:

• *.g.dart, *.freezed.dart, *.mocks.dart — generated file indicators in test output
• cache miss on first run — expected behavior, not a misconfiguration

Pipeline Optimization Principles

The agent must evaluate every workflow against these principles. They form the theoretical basis for every finding.

Job Parallelization

Independent units of work must run in separate jobs: that execute concurrently. A single monolithic job with 20 sequential steps is always slower than three parallel jobs connected with needs:.

# Correct — parallel jobs connected with needs:
jobs:
  test-app:      # starts immediately
  test-package:  # starts immediately, parallel to test-app
  sonar:
    needs: [test-app, test-package]   # waits for both

Cache Layering

Every cacheable artifact must be explicitly cached at the correct layer. The subosito/flutter-action cache: true only caches the Flutter SDK binary — it does not cache pub packages. Missing the pub cache layer costs 1–3 min per job on every run.

# Required — pub cache is separate from SDK cache
- uses: actions/cache@v4
  with:
    path: |
      ~/.pub-cache
      .dart_tool
    key: pub-${{ runner.os }}-${{ hashFiles('**/pubspec.lock') }}

Test Sharding

A single runner executing 10,000+ tests sequentially will always be the pipeline bottleneck. Flutter's native --total-shards / --shard-index flags (Flutter ≥ 3.7) distribute test files across N runners that execute in parallel.

strategy:
  fail-fast: false
  matrix:
    shard: [0, 1, 2, 3]
steps:
  - run: flutter test --total-shards=4 --shard-index=${{ matrix.shard }}

No Redundant Toolchain Operations

Every extra toolchain invocation adds minutes. flutter clean invalidates cache and is never appropriate in CI where the workspace is already clean. dart run build_runner and flutter packages pub run build_runner are identical — only one should run.

Setup Locality

Heavy tool setup (Java, Ruby, CocoaPods) should be placed only in the job that needs it. Java is needed only for SonarQube. Setting it up before running tests wastes 30–90 seconds per run.

Fail-Fast Discipline

Matrix shards must always set fail-fast: false. Without it, a single flaky test in one shard cancels all sibling runners, destroying their accumulated coverage data and preventing the merge job from completing.

Signing Secrets Hygiene

Platform builds require keystore files and certificates that must be stored as base64-encoded secrets and decoded at build time. Never embed signing credentials as literal values in YAML. Release jobs must be gated on all quality jobs and triggered only on version tags or main branch pushes.

Analysis Workflow

The agent must follow this workflow sequentially when reviewing a pipeline. Each step maps to one or more output sections.

Step 1 — Classify job topology

Feeds: Pipeline Score, Job Topology Issues, Optimization Findings

Diagnostic commands:

# Count top-level job keys in the workflow
grep -c "^  [a-zA-Z][a-zA-Z0-9_-]*:" .github/workflows/ci.yml

# Identify needs: relationships (or their absence)
grep -n "needs:" .github/workflows/ci.yml

# List all job names
yq '.jobs | keys | .[]' .github/workflows/ci.yml

# Check for concurrency group cancellation
grep -n "concurrency:" .github/workflows/ci.yml

Count the number of jobs: in the workflow. If there is only one job, the entire pipeline is sequential — this is the most impactful structural problem.

Check for needs: relationships between jobs. If no needs: exists, no parallelism is happening regardless of how the steps are organized.

Identify which steps are candidates for parallel jobs:

• Test steps for the main app and for packages are independent — always parallelize
• Build steps (Android, iOS, Web) are independent of each other — always parallelize
• SonarQube / coverage merge must wait for all test jobs — use needs:

VIOLATION — single sequential job:

jobs:
  ci:
    runs-on: ubuntu-latest
    steps:
      - run: flutter test
      - run: flutter build apk --release  # blocked by tests
      - run: sonar-scanner                # blocked by build

CORRECT — parallel jobs with needs: fan-in:

jobs:
  test-app:
    runs-on: ubuntu-latest
    # starts immediately
  build-android:
    runs-on: ubuntu-latest
    # starts immediately, parallel to test-app
  sonar:
    runs-on: ubuntu-latest
    needs: [test-app, build-android]   # waits for both

Flag these patterns:

• Single job containing test steps, build steps, and Sonar — all run sequentially with no concurrency — HIGH
• Test steps for app and for package in the same job — package tests block app tests — HIGH
• Build steps for Android and iOS in the same job — iOS build blocks Android build completion — MEDIUM
• needs: forming a linear chain (A → B → C) rather than a fan-in list ([A, B] → C) — misses parallelism opportunity — MEDIUM

Step 2 — Audit caching configuration

Feeds: Pipeline Score, Caching Issues, Optimization Findings

Diagnostic commands:

# Check Flutter action cache configuration
grep -n "flutter-action\|cache:" .github/workflows/ci.yml

# Check for explicit pub cache steps
grep -n "pub-cache\|\.pub-cache\|dart_tool" .github/workflows/ci.yml

# Detect flutter clean (cache destroyer)
grep -n "flutter clean" .github/workflows/ci.yml

# Inspect cache key strategy
grep -n "hashFiles\|pubspec.lock" .github/workflows/ci.yml

Check whether subosito/flutter-action is used with cache: true. This caches the SDK binary only.

Check for an explicit actions/cache step targeting ~/.pub-cache and .dart_tool. If absent, pub packages are re-downloaded on every run.

Check the cache key. A key that does not include hashFiles('**/pubspec.lock') will either never invalidate (stale packages) or always miss (no benefit).

Check for platform-specific caches: Gradle (~/.gradle/caches), CocoaPods (ios/Pods).

VIOLATION — SDK cache only, no pub cache, flutter clean present:

- uses: subosito/flutter-action@v2
  with:
    flutter-version: '3.24.0'
    channel: stable
    # No cache: true — SDK re-downloaded each run
- run: flutter clean        # Destroys .dart_tool on every run
- run: flutter pub get      # No cache — 1–3 min network fetch every run

CORRECT — layered pub cache with correct key:

- uses: subosito/flutter-action@v2
  with:
    flutter-version: '3.24.0'
    channel: stable
    cache: true                   # Caches Flutter SDK binary
- uses: actions/cache@v4
  with:
    path: |
      ~/.pub-cache
      .dart_tool
    key: pub-${{ runner.os }}-${{ hashFiles('**/pubspec.lock') }}
    restore-keys: pub-${{ runner.os }}-
- run: flutter pub get
# No flutter clean — workspace is clean at checkout

Flag these patterns:

• No actions/cache for ~/.pub-cache — pub packages fetched from network on every run, 1–3 min wasted per job — HIGH
• Cache key uses a static string instead of hashFiles('**/pubspec.lock') — cache never invalidates properly — MEDIUM
• flutter clean step present — explicitly destroys .dart_tool and negates all caching — HIGH
• No Gradle cache on Android build jobs — Gradle re-downloads dependencies on every build, 2–4 min wasted — MEDIUM
• No CocoaPods cache on iOS build jobs — pod install re-runs on every macOS runner, 3–6 min wasted — MEDIUM

Step 3 — Detect redundant toolchain invocations

Feeds: Pipeline Score, Redundancy Findings, Optimization Findings

Diagnostic commands:

# Find all build_runner invocations
grep -n "build_runner" .github/workflows/ci.yml

# Detect both invocation styles in the same job
grep -n "dart run build_runner\|flutter packages pub run build_runner" .github/workflows/ci.yml

# Detect flutter clean and redundant pub get
grep -n "flutter clean\|flutter pub get" .github/workflows/ci.yml

# Find flutter analyze placement
grep -n "flutter analyze\|dart analyze" .github/workflows/ci.yml

Scan for duplicate build_runner invocations in the same job. flutter packages pub run X is a wrapper that calls dart run X. Running both doubles code generation time (4–10 min wasted).

Scan for flutter clean before test or build steps. In CI, the workspace is always clean at checkout.

Check whether flutter analyze is embedded in the same job as flutter test when it could run in parallel.

VIOLATION — redundant build_runner and flutter clean:

steps:
  - run: flutter clean                   # Pointless — workspace is fresh
  - run: flutter pub get
  - run: dart run build_runner build --delete-conflicting-outputs
  - run: flutter packages pub run build_runner build --delete-conflicting-outputs
    # Above two commands are identical — 4–10 min wasted running both
  - run: flutter test

CORRECT — single build_runner invocation, no flutter clean:

steps:
  - run: flutter pub get
  - run: dart run build_runner build --delete-conflicting-outputs
  - run: flutter test

Flag these patterns:

• dart run build_runner and flutter packages pub run build_runner both present in the same job — remove one — HIGH
• flutter clean present anywhere before tests or code generation — HIGH
• flutter analyze embedded in the same job as flutter test when it could run in parallel — MEDIUM
• flutter pub get called more than once in the same job — MEDIUM

Step 4 — Evaluate test sharding and parallelism

Feeds: Pipeline Score, Test Execution Issues, Optimization Findings

Diagnostic commands:

# Check for native sharding flags
grep -n "total-shards\|shard-index" .github/workflows/ci.yml

# Inspect matrix strategy and fail-fast setting
grep -n "matrix:\|fail-fast:\|strategy:" .github/workflows/ci.yml

# Check reporter configuration
grep -n "reporter\|--reporter" .github/workflows/ci.yml

# Confirm Flutter version supports sharding (≥ 3.7)
grep -n "flutter-version:" .github/workflows/ci.yml

Identify how tests are run. If a single flutter test step runs with no --total-shards flag, all tests run sequentially in one runner.

Use the time estimation table in the Reference Guide to estimate current and potential runtime.

Check whether fail-fast: false is set on matrix strategies. If absent, one flaky test cancels all sibling runners and destroys accumulated coverage data.

Check the reporter flag. --reporter expanded on 10,000+ tests floods the runner's output buffer.

VIOLATION — no sharding, no fail-fast:

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - run: flutter test --coverage --reporter expanded
        # Single runner, 10,000+ tests, no parallelism
        # --reporter expanded floods output on large suites

CORRECT — native sharding with fail-fast: false:

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false          # Prevent one flaky shard from cancelling siblings
      matrix:
        shard: [0, 1, 2, 3]
    steps:
      - run: |
          flutter test \
            --total-shards=4 \
            --shard-index=${{ matrix.shard }} \
            --coverage \
            --reporter compact
      - uses: actions/upload-artifact@v4
        with:
          name: coverage-${{ matrix.shard }}
          path: coverage/lcov.info

Flag these patterns:

• flutter test with no --total-shards on a suite with 3,000+ tests — severe throughput bottleneck — HIGH
• Matrix strategy without fail-fast: false — single failure cancels all shards and coverage data is lost — HIGH
• --reporter expanded on a suite with 5,000+ tests — excessive log output slows the runner — MEDIUM
• Shard count too low for test volume (e.g., 2 shards for 15,000 tests) — suboptimal parallelism — MEDIUM

Step 5 — Audit coverage merge and quality gate placement

Feeds: Pipeline Score, Quality Gate Issues, Optimization Findings

Diagnostic commands:

# Find all coverage artifact upload/download steps
grep -n "upload-artifact\|download-artifact\|lcov.info" .github/workflows/ci.yml

# Check lcov installation and merge commands
grep -n "lcov\|genhtml\|add-tracefile" .github/workflows/ci.yml

# Find SonarQube configuration
grep -n "sonar\|SonarQube\|sonar-scanner" .github/workflows/ci.yml

# Check fetch-depth scope (should be sonar job only)
grep -n "fetch-depth:" .github/workflows/ci.yml

Check whether coverage from parallel shards is uploaded as artifacts and merged in a dedicated downstream job. If only one shard's lcov.info is reported to Sonar, coverage data is incomplete.

Check whether lcov is installed before any lcov commands run.

Check the SonarQube job for fetch-depth: 0 (required for SCM blame — but should appear only on the Sonar job).

VIOLATION — no artifact upload, partial coverage to Sonar:

test:
  strategy:
    matrix:
      shard: [0, 1, 2, 3]
  steps:
    - run: flutter test --total-shards=4 --shard-index=${{ matrix.shard }} --coverage
    # No artifact upload — only the last shard's lcov.info survives
sonar:
  needs: [test]
  steps:
    - run: sonar-scanner  # Receives only one shard's coverage — data is 25% of reality

CORRECT — per-shard upload, merged before Sonar:

test:
  strategy:
    fail-fast: false
    matrix:
      shard: [0, 1, 2, 3]
  steps:
    - run: flutter test --total-shards=4 --shard-index=${{ matrix.shard }} --coverage
    - uses: actions/upload-artifact@v4
      with:
        name: coverage-shard-${{ matrix.shard }}
        path: coverage/lcov.info

sonar:
  needs: [test]
  steps:
    - uses: actions/checkout@v4
      with:
        fetch-depth: 0            # Required for SCM blame — Sonar job only
    - uses: actions/download-artifact@v4
      with:
        pattern: coverage-shard-*
        path: coverage/shards
    - run: |
        sudo apt-get install -y lcov
        lcov $(find coverage/shards -name '*.info' | sed 's/^/-a /') \
          -o coverage/merged.info
    - run: sonar-scanner

Flag these patterns:

• Parallel test shards produce lcov.info but no artifact upload — only one shard's coverage reaches the merge job — HIGH
• lcov --add-tracefile called without lcov being installed first — step fails — HIGH
• fetch-depth: 0 on every job, not just Sonar — full git history fetched unnecessarily on all runners — MEDIUM
• actions/setup-java in a job that runs only flutter test — adds 30–60s before tests start — MEDIUM

Step 6 — Validate secrets and environment variable hygiene

Feeds: Pipeline Score, Security and Configuration Findings

Diagnostic commands:

# Scan for potential literal credentials in run steps
grep -n "echo.*KEY\|echo.*SECRET\|echo.*TOKEN\|echo.*PASSWORD" .github/workflows/ci.yml

# Find all env: blocks and their scope
grep -n "^    env:\|^  env:\|^env:" .github/workflows/ci.yml

# Verify all sensitive values reference secrets
grep -n "TOKEN\|PASSWORD\|KEY\|SECRET\|CERT\|STORE" .github/workflows/ci.yml | grep -v "secrets\."

# Check for .env file creation with fallback values
grep -n "\.env\|dotenv" .github/workflows/ci.yml

Scan for literal credential values in run: steps rather than ${{ secrets.NAME }} references.

Check whether tokens are scoped to the step that needs them via step-level env:, not exported to all steps in the job via job-level env:.

VIOLATION — literal credential and overly broad env scope:

jobs:
  sonar:
    env:
      SONAR_TOKEN: actual-token-abc123   # Literal value — exposed in workflow file
      KEYSTORE_PASSWORD: mypass123       # Exposed to all steps in job
    steps:
      - run: sonar-scanner
      - run: flutter test                # Has KEYSTORE_PASSWORD unnecessarily

CORRECT — secrets references, step-level scope:

jobs:
  sonar:
    steps:
      - name: Run SonarQube analysis
        env:                             # Token scoped to this step only
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
          SONAR_HOST_URL: ${{ secrets.SONAR_HOST_URL }}
        run: sonar-scanner

Flag these patterns:

• Literal secret value in a run: step or env: block — credential exposed in workflow file and run logs — HIGH
• env: at job level exposing a token only needed in one step — unnecessarily broad exposure — MEDIUM
• .env file created with placeholder fallback values that diverge from actual secrets — test behavior diverges from production — LOW

Step 7 — Audit platform build configuration

Feeds: Pipeline Score, Build Configuration Issues, Optimization Findings

Diagnostic commands:

# Find all flutter build invocations
grep -n "flutter build apk\|flutter build appbundle\|flutter build ipa\|flutter build web" .github/workflows/ci.yml

# Check for signing secret injection
grep -n "KEYSTORE\|KEY_ALIAS\|SIGNING\|CERTIFICATE\|PROVISIONING\|MATCH" .github/workflows/ci.yml

# Check runner OS for build jobs
grep -n "runs-on:" .github/workflows/ci.yml

# Detect artifact upload after build
grep -n "upload-artifact" .github/workflows/ci.yml

Check whether Android builds inject keystore secrets correctly. A release APK or AAB built without signing secrets will be invalid for Play Store upload.

Check whether iOS builds run on macos runners. iOS can only be built on macOS. Check for certificate and provisioning profile injection via base64-decoded secrets or Fastlane Match.

Check whether Android, iOS, and Web builds run in parallel jobs. These are independent and should never share a job.

Check whether build artifacts (APK, AAB, IPA, web bundle) are uploaded via actions/upload-artifact for downstream release jobs.

VIOLATION — unsigned Android build, iOS on ubuntu, builds in same job:

jobs:
  build:
    runs-on: ubuntu-latest     # Cannot build iOS on ubuntu
    steps:
      - run: flutter build apk --release
        # No keystore setup — APK is unsigned and invalid for Play Store
      - run: flutter build ipa --release
        # Will fail — Xcode not available on ubuntu
      - run: flutter build web --release

CORRECT — parallel signed builds on correct runners:

jobs:
  build-android:
    runs-on: ubuntu-latest
    steps:
      - name: Decode keystore
        run: echo "${{ secrets.KEYSTORE_BASE64 }}" | base64 --decode > android/app/release.jks
      - name: Build release AAB
        env:
          KEY_ALIAS: ${{ secrets.KEY_ALIAS }}
          KEY_PASSWORD: ${{ secrets.KEY_PASSWORD }}
          STORE_PASSWORD: ${{ secrets.STORE_PASSWORD }}
        run: flutter build appbundle --release
      - uses: actions/upload-artifact@v4
        with:
          name: app-release-aab
          path: build/app/outputs/bundle/release/app-release.aab

  build-ios:
    runs-on: macos-latest      # Required for iOS builds
    steps:
      - uses: webfactory/ssh-agent@v0.9.0
        with:
          ssh-private-key: ${{ secrets.MATCH_SSH_KEY }}
      - run: bundle exec fastlane match appstore --readonly
      - run: flutter build ipa --release --export-options-plist=ios/ExportOptions.plist
      - uses: actions/upload-artifact@v4
        with:
          name: app-release-ipa
          path: build/ios/ipa/*.ipa

  build-web:
    runs-on: ubuntu-latest
    steps:
      - run: flutter build web --release --dart-define=ENV=production
      - uses: actions/upload-artifact@v4
        with:
          name: web-build
          path: build/web/

Flag these patterns:

• Android release build with no keystore setup or signing secrets — APK/AAB will be unsigned and rejected by Play Store — HIGH
• iOS build running on ubuntu-latest — will always fail, Xcode unavailable — HIGH
• Android, iOS, and Web builds in the same sequential job — builds cannot execute in parallel — MEDIUM
• Build artifacts not uploaded via actions/upload-artifact — downstream release job cannot access the binary — MEDIUM
• No flutter build appbundle for Play Store — Play Store requires AAB format, not APK — LOW

Step 8 — Evaluate release automation

Feeds: Pipeline Score, Release Configuration Issues, Optimization Findings

Diagnostic commands:

# Find release job definitions and triggers
grep -n "deploy\|release\|publish\|upload" .github/workflows/ci.yml

# Check tag-based trigger configuration
grep -n "tags:\|startsWith.*refs/tags\|on:.*push" .github/workflows/ci.yml

# Verify release jobs are gated on quality jobs
grep -n "needs:" .github/workflows/ci.yml | grep -i "deploy\|release\|publish"

# Find Fastlane or store upload commands
grep -n "fastlane\|supply\|pilot\|gh release\|firebase appdistribution" .github/workflows/ci.yml

Check whether release jobs exist and are gated on all quality jobs with needs:. A release job that runs without passing tests and a successful build is a delivery risk.

Check whether releases are triggered on version tags or main branch pushes only. Release jobs should never trigger on feature branch pushes or pull requests.

Check whether build artifacts are passed from build jobs to release jobs via actions/download-artifact. If no artifact download exists in the release job, it may be rebuilding the binary — wasting time and introducing inconsistency risk.

VIOLATION — release not gated, no tag trigger, rebuilds binary:

jobs:
  deploy-android:
    runs-on: ubuntu-latest
    # No needs: — runs even if tests fail
    # No if: condition — runs on every push including feature branches
    steps:
      - run: flutter build apk --release  # Rebuilds — should use artifact from build job
      - run: bundle exec fastlane supply

CORRECT — gated release with tag trigger and artifact download:

jobs:
  deploy-android:
    runs-on: ubuntu-latest
    needs: [test, build-android]          # Gated on test and build success
    if: startsWith(github.ref, 'refs/tags/v')  # Only on version tags
    steps:
      - uses: actions/download-artifact@v4
        with:
          name: app-release-aab           # Reuse artifact from build job
          path: build/app/outputs/bundle/release/
      - name: Upload to Play Store
        env:
          SUPPLY_JSON_KEY_DATA: ${{ secrets.PLAY_STORE_JSON_KEY }}
        run: |
          bundle exec fastlane supply \
            --aab build/app/outputs/bundle/release/app-release.aab \
            --track internal

  create-github-release:
    runs-on: ubuntu-latest
    needs: [deploy-android, deploy-ios]
    if: startsWith(github.ref, 'refs/tags/v')
    steps:
      - uses: actions/download-artifact@v4
        with:
          pattern: app-release-*
          merge-multiple: true
          path: release-assets/
      - run: |
          gh release create "${{ github.ref_name }}" \
            release-assets/* \
            --title "Release ${{ github.ref_name }}" \
            --generate-notes
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Flag these patterns:

• Release job not gated on test and build jobs with needs: — release proceeds even if tests fail — HIGH
• Release job triggers on every push including feature branches — unintended pre-release deployments — HIGH
• Release job rebuilds the binary instead of downloading the build artifact — inconsistent binary, wasted build time — MEDIUM
• No automated versioning — pubspec.yaml version not extracted and passed to store upload — LOW

Step 9 — Evaluate monorepo multi-package pipeline

Feeds: Pipeline Score, Monorepo Configuration Issues, Optimization Findings

Diagnostic commands:

# Detect monorepo structure
ls packages/ 2>/dev/null && echo "Monorepo detected" || echo "Single app"

# Check if pipeline references packages directory
grep -n "packages/" .github/workflows/ci.yml

# Look for matrix strategy over packages
grep -n "matrix:" .github/workflows/ci.yml

# Detect sequential package loops (anti-pattern)
grep -n "for.*package\|for.*packages\|cd packages" .github/workflows/ci.yml

Check whether the project is a monorepo by detecting a packages/ directory in the repository root. If confirmed, evaluate whether the pipeline handles each package in isolation or treats all packages as a single sequential unit.

Check whether packages are tested in a shell for loop — this is equivalent to a single-threaded test runner across all packages. Each package is an independent unit and must run in its own matrix job.

Check whether packages share a pub cache key. Monorepo packages often have different pubspec.lock files — the cache key must incorporate each package's lock file separately.

VIOLATION — sequential package loop:

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - run: |
          for package in packages/*/; do
            cd "$package"
            flutter pub get
            flutter test --coverage
            cd ../..
          done
          # package_a blocks package_b — no parallelism

CORRECT — matrix strategy over packages:

jobs:
  test-packages:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        package: [package_a, package_b, package_c]
    steps:
      - uses: actions/checkout@v4
      - uses: subosito/flutter-action@v2
        with:
          flutter-version: '3.24.0'
          cache: true
      - uses: actions/cache@v4
        with:
          path: ~/.pub-cache
          key: pub-${{ runner.os }}-${{ matrix.package }}-${{ hashFiles(format('packages/{0}/pubspec.lock', matrix.package)) }}
      - run: |
          cd packages/${{ matrix.package }}
          flutter pub get
          flutter test --coverage
      - uses: actions/upload-artifact@v4
        with:
          name: coverage-${{ matrix.package }}
          path: packages/${{ matrix.package }}/coverage/lcov.info

Flag these patterns:

• Monorepo detected but packages tested in a sequential shell loop — packages execute one after another — HIGH
• Monorepo packages share a single cache key that doesn't incorporate each package's pubspec.lock — stale cache hits across packages — MEDIUM
• Sonar job receives coverage only from the root app, not from packages under packages/ — package coverage missing from quality gate — MEDIUM
• No melos or equivalent tool for coordinating monorepo commands — each job duplicates boilerplate setup — LOW

Evaluation Criteria

Evaluate the pipeline across the following six dimensions. Each dimension contributes to the final Pipeline Efficiency Score.

Job Topology

Whether independent work units run in parallel jobs connected with needs:.

Signals of good topology:

• Test jobs for app and packages run concurrently with no needs: between them
• Build jobs (Android, iOS, Web) run concurrently
• Quality gate and Sonar jobs use needs: to wait for all test/build jobs
• concurrency: group cancels in-progress runs on new push

Signals of poor topology:

• Single job containing all steps from checkout to Sonar
• Test and build steps in the same sequential job
• needs: forms a linear chain rather than a fan-in

Caching Strategy

Whether all cacheable artifacts are explicitly cached at each layer.

Signals of good caching:

• Flutter SDK cached via subosito/flutter-action cache: true
• Pub packages cached via actions/cache with hashFiles('**/pubspec.lock') key
• Gradle and CocoaPods caches present on Android and iOS jobs
• flutter clean is absent from all jobs

Signals of poor caching:

• flutter clean present — actively destroys cache
• No explicit pub cache — packages re-downloaded every run
• Static cache key — never invalidates when dependencies change

Test Execution Efficiency

Whether tests are distributed across runners to minimize wall-clock time.

Signals of good test efficiency:

• Native sharding with --total-shards / --shard-index on suites > 3,000 tests
• Shard count calibrated to test volume
• fail-fast: false on all matrix strategies
• --reporter compact or json on large suites
• Coverage artifacts uploaded per shard and merged downstream

Signals of poor test efficiency:

• Single flutter test with no sharding on 5,000+ tests
• fail-fast absent or true on test matrix
• Coverage from only one shard reported to Sonar

Toolchain Hygiene

Whether each tool is invoked exactly once, in the right job, with no redundancy.

Signals of good toolchain hygiene:

• build_runner invoked once per package per job using dart run build_runner
• Java setup only in the Sonar job
• flutter pub get called exactly once per job
• flutter clean absent everywhere

Signals of poor toolchain hygiene:

• dart run build_runner and flutter packages pub run build_runner both present
• Java setup in a test-only job
• flutter clean followed immediately by build_runner

Platform Build and Release Automation

Whether platform builds are correctly signed and release automation is gated on quality.

Signals of good build and release configuration:

• Android builds inject keystore secrets at build time
• iOS builds run on macos-latest
• Android, iOS, and Web builds execute in parallel jobs
• Release jobs use needs: to gate on test and build success
• Release jobs trigger only on version tags or main branch

Signals of poor build and release configuration:

• Android release build with no signing secrets — produces unsigned APK/AAB
• iOS build on ubuntu runner — always fails
• Release job not gated on test or build jobs — deploys despite test failures
• Release job rebuilds the binary instead of downloading the build artifact

Quality Gate Configuration

Whether coverage, linting, and Sonar are correctly wired to receive complete data.

Signals of good quality gate configuration:

• All shard lcov.info files uploaded, downloaded, and merged before Sonar
• fetch-depth: 0 on Sonar job only
• lcov installed before any lcov commands
• Coverage exclusions remove generated files (*.g.dart, *.freezed.dart)

Signals of poor quality gate configuration:

• Only one shard's coverage reaches Sonar — reported coverage is artificially low
• fetch-depth: 0 on every job
• lcov commands run before installation
• No coverage path correction for packages under packages/

Pipeline Maturity Levels

Classify the pipeline into one of these maturity levels. The level directly determines the base Pipeline Efficiency Score range.

Level 1 — Sequential Monolithic Pipeline

Score range: 1–3

All steps run in a single job with no parallelism. Tests, builds, code generation, and Sonar execute one after another. No pub cache beyond the SDK. No test sharding. flutter clean present. build_runner invoked redundantly. Wall-clock time is the sum of every step. Optimizing any single step has marginal impact because the bottleneck immediately shifts to the next sequential step.

Level 2 — Partially Parallel Pipeline

Score range: 4–5

Some parallelism exists but significant sequential coupling remains. Test and quality jobs may be split, but test sharding is absent. Pub cache is configured for some jobs but not all. build_runner may be deduplicated but flutter clean still appears. Coverage from a single runner is reported to Sonar. Improvement requires restructuring the job graph rather than tuning individual steps.

Level 3 — Parallel and Cached Pipeline

Score range: 6–8

Clear job separation with parallel execution of independent units. Pub cache consistently applied. Test sharding reduces the test bottleneck significantly. Coverage artifacts uploaded per shard and merged. flutter clean absent. build_runner runs once per package. Score within this band depends on shard count calibration, quality gate completeness, signing configuration, and toolchain hygiene consistency.

Level 4 — Optimized Delivery Pipeline

Score range: 9–10

Pipeline explicitly designed for minimum wall-clock time. All independent jobs run concurrently. Shard count calibrated to test volume. Every cache layer configured with correct key invalidation. Coverage from all shards merged before Sonar. Java and platform tools scoped to the jobs that need them. Concurrency groups cancel stale PR runs. Platform builds signed correctly on the correct runners. Release jobs gated on all quality checks and triggered only on main or version tags. Monorepo packages tested in parallel matrix jobs.

Output Format

The Pipeline Efficiency Score (1–10) is derived from the Maturity Level band adjusted by evidence:

• Start from the midpoint of the detected Maturity Level range
• +0.5 if pub cache is correctly configured on all jobs
• +0.5 if test sharding is present and fail-fast: false is set
• +0.5 if platform builds use signing secrets correctly on the correct runners
• -0.5 if no parallel jobs exist (single jobs: entry)
• -0.5 if flutter clean is present in any job
• -0.5 if build_runner is invoked redundantly in the same job
• -0.5 if release jobs are not gated on all quality and build jobs
• -0.5 if monorepo packages are tested sequentially rather than in a matrix
• -1 for each HIGH severity finding beyond the first

Round to the nearest 0.5. Minimum 1, maximum 10.

# Flutter CI/CD Pipeline Audit Report

## Pipeline Efficiency Score

X / 10

## Pipeline Maturity Level

Level [1–4] — [Label]

## Pipeline Overview

[Summarize how the current pipeline structure delivers — or fails to deliver — fast, reliable
execution across tests, builds, quality gates, and releases. 2–4 sentences grounded in
evidence from the workflow YAML.]

## Pipeline Strengths

- [strength 1 — e.g., pub cache correctly configured with pubspec.lock hash key]
- [strength 2 — e.g., SonarQube scoped to its own job with fetch-depth: 0]
- [strength 3 — e.g., fail-fast: false present on test matrix]

## Optimization Findings

### Finding 1

**Severity:** HIGH / MEDIUM / LOW

**Problem**
[Describe the anti-pattern observed with concrete reference to job name, step name, or YAML line.]

**Impact**
[Quantify the wall-clock cost or reliability risk.]

**Recommendation**
[Concrete, actionable change with the corrected YAML snippet if applicable.]

### Finding 2

[Repeat structure as needed]

## Job Topology Assessment

[Describe the current job graph. How many jobs exist? What runs in parallel?
What is the critical path? Where is the bottleneck job?]

## Caching Assessment

[Assess each cache layer: SDK, pub packages, Gradle, CocoaPods.
Note any missing layers and their estimated time cost per run.]

## Test Execution Assessment

[Assess current test structure: total test count if known, sharding present or absent,
estimated wall-clock time, recommended shard count with justification.]

## Quality Gate Assessment

[Assess coverage merge strategy, Sonar configuration, lcov setup, and analyzer placement.
Note whether Sonar receives complete or partial coverage data.]

## Toolchain Hygiene Assessment

[Assess build_runner invocations, flutter clean usage, tool setup locality,
and any redundant step sequences.]

## Platform Build Assessment

[Assess Android, iOS, and Web build configuration. Note signing secret injection,
runner selection correctness, and artifact upload for downstream release jobs.]

## Release Automation Assessment

[Assess whether release jobs exist, whether they are gated on quality, whether they
trigger correctly on tags or main branch, and whether they reuse build artifacts.]

## Wall-Clock Time Estimate

| Phase | Current | After Optimization |
|---|---|---|
| Setup + deps + code generation | X min | Y min |
| Tests | X min | Y min |
| Platform builds (parallel) | X min | Y min |
| Quality gates | X min | Y min |
| **Total (wall-clock)** | **X min** | **Y min** |

## Strategic Optimization Plan

1. [Highest priority — e.g., split test-app and test-package into parallel jobs]
2. [Second priority — e.g., add pub cache with pubspec.lock key to all jobs]
3. [Third priority — e.g., introduce --total-shards=4 with matrix strategy]
4. [Fourth priority — e.g., wire signing secrets and separate build jobs per platform]
5. [Fifth priority — e.g., gate release job on needs: [test, build-android, build-ios]]

## Complete Optimized Workflow

[Full corrected YAML. Always produce the complete file — never partial snippets.
Include inline comments on non-obvious decisions.]

Common Pitfalls

Avoid these mistakes when auditing a pipeline:

• Do not flag fetch-depth: 0 as wasteful on the Sonar job. Full git history is required by SonarQube for SCM blame, new code period detection, and PR decoration. Only flag it on jobs that do not run Sonar.
• Do not flag flutter pub get as redundant across separate parallel jobs. Each job runs in an isolated runner environment. pub get must run once per job.
• Do not recommend removing --delete-conflicting-outputs from build_runner. This flag prevents stale generated files from causing failures and is always appropriate in CI.
• Do not suggest splitting a workflow into multiple .yml files unless the user explicitly requests it. Splitting adds management overhead without reducing wall-clock time.
• Do not flag actions/cache restore-keys fallback as a cache miss. Partial cache restoration from a prefix is correct behavior and still saves significant time vs a cold run.
• Do not recommend self-hosted runners without the user explicitly raising infrastructure constraints.
• Do not flag || true after flutter analyze. This intentional pattern allows the analyzer to produce output for Sonar without failing the pipeline step. It is correct when Sonar is responsible for reporting lint issues.
• Do not rename secrets. Always preserve the exact secret names from the user's original YAML.
• Do not flag fastlane match --readonly as unnecessary. In CI, --readonly is correct — it prevents Match from attempting to create or regenerate certificates, which is a developer-only operation.
• Do not flag APK builds as wrong when AAB is also present. Some teams distribute APKs for testing alongside AABs for Play Store — both can be correct simultaneously.

Rules

The agent must:

• read the full workflow YAML before generating any findings — never diagnose from a partial view
• base every finding on a concrete reference to a job name, step name, or YAML pattern
• produce a complete replacement YAML whenever proposing structural changes — never partial snippets
• provide wall-clock time estimates (not GitHub Actions billing minutes)
• preserve all secret names exactly as they appear in the original workflow
• explain every removed step with the reason it was incorrect
• confirm Flutter version ≥ 3.7 before recommending --total-shards
• always check whether the project is a monorepo before evaluating the pipeline structure

The agent must NOT:

• suggest changes to Flutter application code, architecture, or test design
• recommend paid GitHub runners without explicitly stating the cost multiplication factor
• remove SonarQube, coverage, or quality gate steps without user confirmation
• assume --total-shards is available without confirming Flutter version ≥ 3.7
• guess at secret names, environment variable values, or package names not present in the YAML
• assume iOS builds can run on ubuntu-latest — always flag this as a build configuration error
• recommend Fastlane Match certificate regeneration in CI — --readonly is always correct in automated pipelines

Reference Guide

Load the relevant reference file based on what the user needs: