dotnet-add-ci

Add starter CI/CD workflows to an existing .NET project. Detects the hosting platform (GitHub Actions or Azure DevOps) and generates an appropriate starter workflow for build, test, and pack.

Scope

Platform detection (GitHub Actions vs Azure DevOps)
Starter build/test/pack workflow generation
Basic CI workflow templates for .NET projects

Out of scope

Advanced CI/CD patterns (reusable workflows, matrix builds, deployment) -- see [skill:dotnet-gha-patterns] and [skill:dotnet-ado-patterns]

Prerequisites: Run [skill:dotnet-version-detection] first to determine SDK version for the workflow. Run [skill:dotnet-project-analysis] to understand solution structure.

Cross-references: [skill:dotnet-project-structure] for build props layout, [skill:dotnet-scaffold-project] which generates the project structure these workflows build.

Platform Detection

Detect the CI platform from existing repo indicators:

Indicator	Platform
`.github/` directory exists	GitHub Actions
`azure-pipelines.yml` exists	Azure DevOps
`.github/workflows/` has YAML files	GitHub Actions (already configured)
Neither	Ask the user which platform to target

GitHub Actions Starter Workflow

Create

.github/workflows/build.yml

yaml

name: Build and Test

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

permissions:
  contents: read

env:
  DOTNET_NOLOGO: true
  DOTNET_CLI_TELEMETRY_OPTOUT: true
  DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          global-json-file: global.json

      - name: Restore
        run: dotnet restore --locked-mode

      - name: Build
        run: dotnet build --no-restore -c Release

      - name: Test
        run: dotnet test --no-build -c Release --logger trx --results-directory TestResults

      - name: Upload test results
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: test-results
          path: TestResults/**/*.trx

Key Decisions Explained

global-json-file
— uses the repo's
```
global.json
```
to install the exact SDK version. If the project has no
```
global.json
```
, replace with
```
dotnet-version: '10.0.x'
```
(or the appropriate version)
--locked-mode
— ensures
```
packages.lock.json
```
files are respected; fails if they're out of date. If the project doesn't use lock files, replace with plain
```
dotnet restore
```
-c Release
— builds in Release mode so
```
ContinuousIntegrationBuild
```
takes effect
permissions: contents: read
— principle of least privilege
Environment variables — suppress .NET CLI noise in logs

Adding NuGet Pack (Libraries)

For projects that publish to NuGet, add a pack step:

yaml

      - name: Pack
        run: dotnet pack --no-build -c Release -o artifacts

      - name: Upload packages
        uses: actions/upload-artifact@v4
        with:
          name: nuget-packages
          path: artifacts/*.nupkg

Azure DevOps Starter Pipeline

Create

azure-pipelines.yml

at the repo root:

yaml

trigger:
  branches:
    include:
      - main

pr:
  branches:
    include:
      - main

pool:
  vmImage: 'ubuntu-latest'

variables:
  DOTNET_NOLOGO: true
  DOTNET_CLI_TELEMETRY_OPTOUT: true
  DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true
  buildConfiguration: 'Release'

steps:
  - task: UseDotNet@2
    displayName: 'Setup .NET SDK'
    inputs:
      useGlobalJson: true

  - script: dotnet restore --locked-mode
    displayName: 'Restore'

  - script: dotnet build --no-restore -c $(buildConfiguration)
    displayName: 'Build'

  - task: DotNetCoreCLI@2
    displayName: 'Test'
    inputs:
      command: 'test'
      arguments: '--no-build -c $(buildConfiguration) --logger trx'
      publishTestResults: true

Adding NuGet Pack (Libraries)

yaml

  - script: dotnet pack --no-build -c $(buildConfiguration) -o $(Build.ArtifactStagingDirectory)
    displayName: 'Pack'

  - task: PublishBuildArtifacts@1
    displayName: 'Publish NuGet packages'
    inputs:
      pathToPublish: '$(Build.ArtifactStagingDirectory)'
      artifactName: 'nuget-packages'

Adapting the Starter Workflow

Multi-TFM Projects

If the project multi-targets, the default workflow works without changes —

dotnet build

and

dotnet test

handle all TFMs automatically. No matrix is needed for the starter.

Windows-Only Projects (MAUI, WPF, WinForms)

Change the runner:

yaml

# GitHub Actions
runs-on: windows-latest

# Azure DevOps
pool:
  vmImage: 'windows-latest'

Solution Filter

If the repo has multiple solutions or uses solution filters:

yaml

      - name: Build
        run: dotnet build MyApp.slnf --no-restore -c Release

Verification

After adding the workflow, verify locally:

bash

# GitHub Actions — validate YAML syntax
# Install: gh extension install moritztomasi/gh-workflow-validator
gh workflow-validator .github/workflows/build.yml

# Or simply verify the build steps work locally
dotnet restore --locked-mode
dotnet build --no-restore -c Release
dotnet test --no-build -c Release

Push a branch and open a PR to trigger the workflow.

What's Next

This starter covers build-test-pack. For advanced scenarios, see the CI/CD depth skills:

Reusable composite actions and workflow templates
Matrix builds across OS/TFM combinations
Deployment pipelines with environment gates
NuGet publishing with signing
Container image builds
Code coverage reporting and enforcement

dotnet-add-ci

NPX Install

Tags

SKILL.md Content

dotnet-add-ci

Scope

Out of scope

Platform Detection

GitHub Actions Starter Workflow

Key Decisions Explained

Adding NuGet Pack (Libraries)

Azure DevOps Starter Pipeline

Adding NuGet Pack (Libraries)

Adapting the Starter Workflow

Multi-TFM Projects

Windows-Only Projects (MAUI, WPF, WinForms)

Solution Filter

Verification

What's Next

References