Index of every page on this site: llms.txt
All skills
wshaddix avatar

/dotnet-add-ci

@09da68d
Run it yourself

Adding CI/CD to a .NET project. GitHub Actions vs Azure DevOps detection, workflow templates.

  • 1 file
  • 6.1 KB
  • Updated 9 months ago
  • GitHub
Use this Skill: https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-add-ci

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈27 tokens for metadata: the name and description. ≈1.5k when used: this file.

Description uses 1.4% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈109 characters, or 1.4%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

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 boundary: This skill provides starter templates only. For advanced CI/CD patterns — composable reusable workflows, matrix builds, deployment pipelines, release automation, and environment promotion — see [skill:dotnet-gha-patterns], [skill:dotnet-ado-patterns], and related CI/CD depth skills.

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:

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:

      - 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:

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)

  - 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:

# GitHub Actions
runs-on: windows-latest

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

Solution Filter

If the repo has multiple solutions or uses solution filters:

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

Verification

After adding the workflow, verify locally:

# 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

References

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

No third-party reports yet.

Signed by skilld at 09da68d. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub last month.

Dormantupdated 9 months ago

README badge

README badge for wshaddix/dotnet-skills/dotnet-add-ci