skillZs
★ LIVE SKILL TAGS ★
>>> LIVE SKILLS INDEX <<<
* OPEN SOURCE *
NO LOGIN, NO TRACKING
※ REAL INSTALL DATA ※
← back to all skills
pluginagentmarketplace/custom-plugin-game-developer67 installs

ci-cd-automation

Continuous integration and deployment pipelines, automated testing, build automation, and team workflows for game development.

How do I install this agent skill?

npx skills add https://github.com/pluginagentmarketplace/custom-plugin-game-developer --skill ci-cd-automation
view source ↗

Is this agent skill safe to install?

  • Gen Agent Trust Hubpass

    The skill provides documentation, configuration templates, and helper scripts for automating CI/CD pipelines in game development (Unity and Unreal Engine). No security issues or malicious patterns were detected.

  • Socketpass

    No alerts

  • Snykpass

    Risk: LOW · No issues

  • Runlayerpass

    2/4 files flagged

What does this agent skill do?

CI/CD Automation

Pipeline Architecture

┌─────────────────────────────────────────────────────────────┐
│                    CI/CD PIPELINE STAGES                     │
├─────────────────────────────────────────────────────────────┤
│  TRIGGER: [Push] [PR] [Tag] [Schedule] [Manual]             │
│                              ↓                               │
│  VALIDATE (< 5 min):                                         │
│  Lint → Compile Check → Asset Validation                    │
│                              ↓                               │
│  TEST (10-30 min):                                           │
│  Unit Tests → Integration → PlayMode Tests                  │
│                              ↓                               │
│  BUILD (Parallel):                                           │
│  [Windows] [Linux] [macOS] [WebGL] [Android] [iOS]         │
│                              ↓                               │
│  DEPLOY:                                                     │
│  [Dev auto] → [Staging gate] → [Prod approval]             │
└─────────────────────────────────────────────────────────────┘

GitHub Actions for Unity

# ✅ Production-Ready: Unity CI/CD Pipeline
name: Unity Build Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]
  workflow_dispatch:
    inputs:
      buildType:
        description: 'Build type'
        required: true
        default: 'development'
        type: choice
        options:
          - development
          - release

env:
  UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          lfs: true

      - uses: actions/cache@v3
        with:
          path: Library
          key: Library-${{ hashFiles('Assets/**', 'Packages/**', 'ProjectSettings/**') }}
          restore-keys: Library-

      - uses: game-ci/unity-test-runner@v4
        with:
          testMode: all
          artifactsPath: test-results
          checkName: Test Results

      - uses: actions/upload-artifact@v3
        if: always()
        with:
          name: Test Results
          path: test-results

  build:
    needs: test
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        targetPlatform:
          - StandaloneWindows64
          - StandaloneLinux64
          - WebGL
    steps:
      - uses: actions/checkout@v4
        with:
          lfs: true

      - uses: actions/cache@v3
        with:
          path: Library
          key: Library-${{ matrix.targetPlatform }}-${{ hashFiles('Assets/**', 'Packages/**') }}

      - uses: game-ci/unity-builder@v4
        with:
          targetPlatform: ${{ matrix.targetPlatform }}
          versioning: Semantic
          buildMethod: BuildScript.PerformBuild

      - uses: actions/upload-artifact@v3
        with:
          name: Build-${{ matrix.targetPlatform }}
          path: build/${{ matrix.targetPlatform }}
          retention-days: 14

  deploy-staging:
    needs: build
    if: github.ref == 'refs/heads/develop'
    runs-on: ubuntu-latest
    environment: staging
    steps:
      - uses: actions/download-artifact@v3
        with:
          name: Build-WebGL
          path: build/

      - name: Deploy to Staging
        run: |
          # Deploy to staging server
          aws s3 sync build/ s3://game-staging-bucket/

Unreal Engine Pipeline

# ✅ Production-Ready: Unreal CI/CD
name: Unreal Build Pipeline

on:
  push:
    branches: [main]

jobs:
  build:
    runs-on: [self-hosted, unreal]
    steps:
      - uses: actions/checkout@v4
        with:
          lfs: true

      - name: Build Development
        run: |
          & "$env:UE_ROOT/Engine/Build/BatchFiles/RunUAT.bat" `
            BuildCookRun `
            -project="${{ github.workspace }}/MyGame.uproject" `
            -platform=Win64 `
            -clientconfig=Development `
            -build -cook -stage -pak -archive `
            -archivedirectory="${{ github.workspace }}/Build"

      - uses: actions/upload-artifact@v3
        with:
          name: UnrealBuild-Win64
          path: Build/

Build Optimization

BUILD TIME OPTIMIZATION:
┌─────────────────────────────────────────────────────────────┐
│  STRATEGY              │ TIME SAVINGS │ EFFORT            │
├────────────────────────┼──────────────┼───────────────────┤
│  Library caching       │ 30-50%       │ Low               │
│  Parallel builds       │ 40-60%       │ Low               │
│  Self-hosted runners   │ 20-40%       │ Medium            │
│  Incremental builds    │ 50-80%       │ Medium            │
│  Asset bundles split   │ 30-50%       │ High              │
└─────────────────────────────────────────────────────────────┘

Automated Testing

// ✅ Production-Ready: PlayMode Test
[TestFixture]
public class PlayerMovementTests
{
    private GameObject _player;
    private PlayerController _controller;

    [UnitySetUp]
    public IEnumerator SetUp()
    {
        var prefab = Resources.Load<GameObject>("Prefabs/Player");
        _player = Object.Instantiate(prefab);
        _controller = _player.GetComponent<PlayerController>();
        yield return null;
    }

    [UnityTest]
    public IEnumerator Player_MovesForward_WhenInputApplied()
    {
        var startPos = _player.transform.position;

        _controller.SetInput(Vector2.up);
        yield return new WaitForSeconds(0.5f);

        Assert.Greater(_player.transform.position.z, startPos.z);
    }

    [UnityTearDown]
    public IEnumerator TearDown()
    {
        Object.Destroy(_player);
        yield return null;
    }
}

🔧 Troubleshooting

┌─────────────────────────────────────────────────────────────┐
│ PROBLEM: Build times too long (>30 min)                     │
├─────────────────────────────────────────────────────────────┤
│ SOLUTIONS:                                                   │
│ → Enable Library folder caching                             │
│ → Use self-hosted runners with SSDs                         │
│ → Parallelize platform builds                               │
│ → Split large asset bundles                                 │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│ PROBLEM: Flaky tests causing failures                       │
├─────────────────────────────────────────────────────────────┤
│ SOLUTIONS:                                                   │
│ → Use test timeouts                                         │
│ → Isolate tests properly                                    │
│ → Add retry logic for network tests                         │
│ → Quarantine unstable tests                                 │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│ PROBLEM: Cache not restoring correctly                      │
├─────────────────────────────────────────────────────────────┤
│ SOLUTIONS:                                                   │
│ → Check cache key hash inputs                               │
│ → Verify cache path is correct                              │
│ → Use restore-keys for partial matches                      │
│ → Check cache size limits                                   │
└─────────────────────────────────────────────────────────────┘

Deployment Strategies

StrategyRollback TimeRiskBest For
Blue-GreenInstantLowWeb builds
CanaryMinutesLowMobile apps
RollingMinutesMediumGame servers
Big BangHoursHighConsole releases

Use this skill: When setting up build pipelines, automating testing, or improving team workflows.

Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.

<a href="https://skillzs.dev/skills/pluginagentmarketplace/custom-plugin-game-developer/ci-cd-automation">View ci-cd-automation on skillZs</a>