Development Skills

Lightweight planning space for rough ideas and exploration. Detects existing docs structure (ADR, design, plans) and creates temporary whiteboard docs in docs/whiteboards/ that can be refined into formal docs later. Use during Planning, Brainstorming or discussing changes/modifications mid-plan.

Use when warnings/errors occur during git operations, package management, builds, or when reviewing completed work for standards violations. Fix immediately unless impact doubles delivery time.

Manages session types, state tracking, and transition enforcement for all development work. Wraps other skills with session awareness.

Use when writing or editing markdown to proactively enforce linting rules and spelling standards, preventing violations before commit.

Use for autonomous agent/human pair programming with the agent as primary implementer and human as supervisor. Enables high autonomy between checkpoints with automated review loops before human review.

Use when user integrates agents into repository, asks to set up agent guidance/rules/onboarding, or repo missing agent-specific onboarding docs (AGENTS.md). Ensures fresh agent context can apply all repo standards and external skills.

Use when user creates/modifies CI/CD pipelines, mentions deployment automation, quality gates, or release processes. Applies to all repositories by default to ensure platform-specific best practices (dependency scanning, secret detection, protected branches).

Use when setting up multi-identity Git/GitHub workflows or when phase transitions require role-specific personas for commits and operations.

Use when organizing code structure, creating new features, or reviewing file placement to keep related code together by scope and reduce cognitive load.

Use when defining or enforcing cross-language security processes including SCA, SBOM/container scanning, SAST strategy, dependency update governance, release gates, and exception handling.

Use when adding health checks or readiness/liveness endpoints to a .NET service - standardise on the AspNetCore.Diagnostics.HealthChecks open-source ecosystem.

Use when starting a new project from scratch to establish proper foundation with quality gates, repository structure, CI/CD, and development standards before any feature work begins.

Use this skill at the start of any session to load the skill inventory, apply trigger rules, and establish the required planning workflow.

Use when user mentions architectural boundaries, layering, dependency rules, project structure constraints, or asks to define/review/enforce architecture. For new apps, check if production quality/best practices/specific pattern requested.

Use when planning release, deployment, or infrastructure changes. Produces risk assessment with failure modes, impact rating, rollback procedures, and prerequisite execution criteria before deployment.

Use when setting up or optimizing local development environments for fast feedback loops. Applies to any project where iteration speed matters. Covers hot reload, incremental builds, test filtering, IDE optimization, and multi-service local development patterns.

Route agents to the correct process skill based on context and preconditions. Use when uncertain which process skill applies or when starting new work.

Use when planning release versions, creating tags, or establishing versioning strategies. Applies semantic versioning principles, manages pre-release workflows, handles hotfix lineage, and creates release cadence plans with proper changelog documentation.

Use this skill whenever preparing local or CI execution to build and test only the impacted components identified by change impact analysis, while preserving quality gates and correctness.

Use when implementing or refactoring C# code and you must apply best practices aligned to the project's effective C# language version and .NET target/runtime. Detect the language/runtime, prefer the newest supported features, and consult version-specific references progressively from C# 10 upward.

Use when deploying software to production or staging environments to ensure complete traceability of what was deployed, when, by whom, and from which source. Essential for audit compliance, incident investigation, and rollback decisions.

Use when user creates/modifies/reviews documentation (Markdown, ADRs, plans, READMEs). Applies same rigor as code with lint, spell, format validation, review processes, and CI automation.

Use when designing, implementing, maintaining, or reviewing .NET features, projects, and codebases. Covers architecture, runtime/framework choices, SDK/tooling, packaging, deployment strategy, and version-aware best practices, including code review and ongoing maintenance scenarios.

Use when work is tied to a ticketing system work item and requires comment approval, sub-task tracking, or CLI-based delivery workflows.

Use when entering any repository, creating a new repository, or performing repository migration. Automatically enforces prerequisite skill loading and verification before any implementation begins.

Use this skill when bootstrapping or migrating a repository to ensure the minimum documentation set (including AGENTS.md) is created and aligned before implementation work proceeds.

Use when setting up or reviewing logging in a .NET app - standardise on ILogger with Serilog as the provider and ensure startup exceptions are logged as Critical.

Use this skill when deploying to ensure only modified and impacted components are deployed, with explicit version/tag inputs and environment traceability preserved.

Use when starting a new feature or an unclear task and you need to elicit requirements - gather them through interactive questions and capture work items without committing design documents.

Use when adding or configuring Entity Framework Core - isolate migrations in a dedicated project excluded from coverage and enforce attribute-linked dedicated type-configuration classes.

Use when mapping between DTOs, contracts, and persistence models in .NET - prefer source-generated mappers with explicit boundary conversions over reflection-based mapping.

Use this skill whenever changes affect a deployable component or library to determine the correct semantic version bump based on conventional commits, scope, and observed impact.

Use when implementing or reviewing a .NET testing approach with unit, system, and E2E tiers, BDD practices, architecture enforcement, contract versioning, and strict observability rules.

Use when modelling domain types or designing API/persistence boundaries in .NET - prevent primitive obsession by enforcing strongly-typed IDs and value objects.

Use this skill whenever deploying or auditing environments to ensure each environment can be mapped to explicit component versions and tags, preserving immutable provenance.

Use when creating or modifying CI/CD pipelines to enforce quality gates (coverage thresholds, security scans, test requirements, performance benchmarks). Ensures code quality standards are automatically enforced before merge or deployment.

Use when refactoring legacy codebases, introducing changes to systems without comprehensive test coverage, or modernising established production systems. Provides risk-managed strategies for incremental improvement.

Use when implementing or configuring static analysis for security, including SAST tools, security linting, secrets detection, and vulnerability threshold management. Covers tool selection, CI integration, IDE setup, and suppression policies.

Use when an agent is asked to autonomously manage a work item and must resolve task board source, platform CLI, or step updates across GitHub, Azure DevOps, or Jira.

Use when writing or reviewing .NET unit/integration test assertions - standardise on open-source assertion libraries, preferring AwesomeAssertions.

Use when user proposes changes, refactoring, or feature additions; asks about impact, affected components, or what needs testing; or before making structural changes. Identifies blast radius and cascading effects.

Use when defining, reviewing, or improving a testing strategy in any stack; focuses on layered testing, incremental enforcement, data safety, architecture enforcement, contract versioning, and observability.

Use when starting new system or migration requiring minimal end-to-end slice for architecture validation. Defines simplest E2E flow in BDD format, establishes deployment pipeline, and validates technical decisions before full build-out.

Use when repository includes .NET Aspire usage, distributed application setup, or cross-component behavior validation. Produces BDD-style integration tests with health checks and observability verification.

Use when introducing new standards, tooling, practices, or asking for adoption/rollout guidance. Produces phased rollout plan with adoption criteria, risk assessment, and rollback triggers.

Use when user deploys changes, commits code, runs builds/tests, or requests selective validation. Ensures only impacted components are tested/deployed when appropriate, scoping quality gates to modified code.

Use when setting up a development environment, cloning a repository, or before running builds and tests. Validates runtime dependencies, SDK versions, environment variables, and service connectivity before attempting operations that would fail without them.

Use this skill when you need an end-to-end review workflow that coordinates both requesting and receiving feedback.

Use when user decides repository organization, where functionality should live, or reviews component boundaries. Determines cross-component ownership and placement (macro), delegates intra-component file layout to scoped-colocation (micro).

Prefer Specification Pattern for query composition and domain selection logic; avoid generic Repository Pattern duplication of ORM semantics.

Use when setting up or orchestrating monorepos with build tools like Nx, Turborepo, or Lerna. Covers workspace configuration, task pipelines, dependency graph management, caching strategies, and CI/CD integration patterns.

Use when setting up new repositories or auditing existing ones for security and best practice compliance. Covers branch protection, secret scanning, CI/CD security, documentation, and agent enablement.

Use when facing technical debt backlog requiring systematic prioritisation. Applies three-dimensional scoring (impact, risk, effort), categorises by debt type, identifies quick wins, and creates multi-horizon roadmaps for evidence-based remediation planning.

Prefer compile-time source generation over runtime evaluation for repetitive cross-cutting concerns (mapping, logging, regex, etc.).

Use this skill whenever writing or reviewing C# code to ensure use of modern language features, high performance, and robust API design.

Use when establishing observability foundations including structured logging, metrics, and distributed tracing using OpenTelemetry standards.

Use when creating or modifying any repository to establish automated quality enforcement (linting, spelling, tests, SAST, security). Applies by default unless user explicitly refuses. Ensures clean build policy with minimal developer friction.

Use when user modifies public interfaces/APIs, changes behavior of exposed methods, or requests compatibility checks. Validates breaking changes, requires user confirmation, enforces SemVer, and mandates ADR for pre-1.0 relaxations or v1+ exceptions.

Use this skill when bootstrapping a new repository or migrating an existing repo to conform to this skill library's standards, ensuring a clean, minimal foundation before feature work begins.

Use when adding tooling, scripts, or frameworks to a .NET project - bias against bespoke code in favour of mature open-source tools and composable libraries with clear ownership.