Development skills

Choose serialization formats for .NET APIs, messages, and stored data. Compare schema-based options such as Protobuf and MessagePack with JSON approaches, use System.Text.Json source generation for AOT scenarios, and plan compatible format changes.

• Choosing a format for an API or message
• Migrating from Newtonsoft.Json to System.Text.Json
• Preparing serialization for Native AOT

Build event-driven C# pipelines with R3, Cysharp’s reactive library. Learn how streams handle errors, async work, time and frame scheduling, and concurrent updates, plus how to connect streams with Task and IAsyncEnumerable or adapt code from Rx.NET.

• Composing UI or domain event streams in C#
• Choosing async behavior for stream operators
• Bridging Observable streams with Task or IAsyncEnumerable

Set up a consistent structure for modern .NET solutions. The skill covers XML solution files, shared build properties, centralized NuGet versions, SourceLink for source-level debugging, SDK pinning, and release-note-based version management across projects.

• Starting a new multi-project .NET solution
• Centralizing build properties and package versions
• Pinning the .NET SDK for consistent builds

Use this skill to add or review tracing, metrics, and logs in .NET code. It explains how to use built-in diagnostic APIs, configure OpenTelemetry collection in applications, propagate trace context, follow naming conventions, and keep instrumentation resilient and efficient.

• Adding traces to a .NET library
• Choosing metric instruments and dimensions
• Setting up exporters in an application

Organize .NET dependency injection registrations into reusable IServiceCollection extension methods. This keeps application startup files readable, groups services by feature, and lets tests reuse production setup while clarifying service lifetimes and scope handling.

• Cleaning up a large ASP.NET Core Program.cs
• Grouping registrations by application feature
• Reusing production service setup in tests

Organize .NET application settings with strongly typed options classes, then validate values as the app starts. Learn when to use data annotations or IValidateOptions, how option lifetimes behave, and how to handle changing configuration in services.

• Binding appsettings.json to typed settings classes
• Failing early when required configuration is invalid
• Adding cross-property or conditional validation

Manage repository-specific .NET CLI tools through `.config/dotnet-tools.json`. The skill covers installing, pinning, restoring, updating, and removing tools, so developers and CI pipelines can use the versions declared for a project.

• Pinning tool versions for a .NET repository
• Restoring the same tools in local development and CI
• Managing project-specific CLI tools

Use ILSpy to decompile .NET assemblies into readable code and inspect types or selected implementations. This helps explain how an API, NuGet package, framework component, or compiled binary behaves, with notes on locating assemblies and build formats that can limit readability.

• Inspecting how a .NET API works internally
• Reading implementation code from a NuGet package
• Exploring framework or project build assemblies

Use this skill to set up and maintain Entity Framework Core projects. It explains read-only query tracking, efficient loading of related data, bulk operations, migration workflows, and common database access pitfalls, with patterns for retries and separate migration services.

• Setting up Entity Framework Core in a new project
• Improving query performance and loading related data
• Managing database migrations safely

Improve database access in EF Core or Dapper by separating read and write models, limiting returned rows and columns, and avoiding N+1 queries. The skill explains when to use tracking, batching, SQL joins, projections, split queries, and purpose-built data stores.

• Optimizing slow EF Core or Dapper data access
• Designing separate read and write data models
• Preventing N+1 queries and oversized result sets

Choose .NET concurrency tools for the work at hand, from `async/await` for I/O to Channels for producer-consumer queues and Akka.NET for stateful entities. The skill offers an escalation path and guidance on avoiding shared mutable state, blocking, and unnecessary locks.

• Choosing a concurrency approach for a .NET feature
• Building a producer-consumer work queue with Channels
• Handling parallel I/O or CPU-bound collection work

Use modern C# practices when writing or refactoring code and designing APIs. Apply records, pattern matching, nullable types, async cancellation, value objects, and Span<T>/Memory<T> patterns to structure code and address performance-sensitive work.

• Refactoring C# code with modern language features
• Designing public APIs for libraries or services
• Modeling domains with strongly typed value objects

Configure Aspire AppHost to pass resource settings to applications as explicit environment variables. The skill keeps app code dependent on ordinary configuration and SDKs, making infrastructure settings easier to reproduce in production and tests without Aspire client or service discovery packages.

• Mapping Aspire resources to app configuration
• Keeping application projects free of Aspire clients
• Making development settings reproducible in production

Prepare C# and .NET libraries or applications for trimming and Native AOT, which removes unused code and can run without a JIT. The skill explains project settings, annotations, warning fixes, and alternatives for reflection-heavy code.

• Adding trimming or Native AOT support to a .NET project
• Resolving IL2xxx and IL3xxx compatibility warnings
• Making reflection-heavy code safer for trimming

Configure Akka.NET clusters to discover peers through Kubernetes, Azure, or static configuration and form clusters without fixed seed nodes. Set up management HTTP endpoints and health checks that load balancers and orchestrators can use to assess liveness and readiness.

• Forming Akka.NET clusters with dynamic service discovery
• Replacing fixed seed nodes in cloud deployments
• Adding liveness and readiness checks for orchestration

Build entity actors with Akka.Hosting using shared patterns for local tests and clustered production. Configure message routing, cluster sharding, durable reminders, and injectable time so actor behavior can be tested across execution modes.

• Building actors for domain entities such as orders
• Testing actor routing without a cluster
• Configuring clustered sharding for production

Choose suitable Akka.NET patterns for actor messaging, supervision, error handling, dependency injection, and distributing background work. Learn when to use local EventStream or cluster-wide DistributedPubSub, and how to make clustered systems testable in local mode.

• Choosing actor messaging across processes or cluster nodes
• Deciding how actors handle expected and unexpected errors
• Selecting Props or DependencyResolver for actor creation

Set up Akka.NET actor systems in .NET Aspire for local development and deployment. Configure clustering, SQL Server persistence, Akka.Management discovery, health checks, and Aspire orchestration so services and their dependencies can run together across multiple replicas.

• Starting an Akka.NET project with Aspire orchestration
• Configuring cluster discovery across replicas
• Adding SQL Server persistence to an actor system

Apply C# nullable reference types to make null intent clear in code and APIs. The guidance covers compiler flow analysis, nullable-analysis attributes, safe use of the null-forgiving operator, public API compatibility, C# 14's field keyword, and incremental migration of legacy projects.

• Introducing nullable reference types into a legacy project
• Designing API signatures that describe null behavior
• Choosing nullable-analysis attributes for helper methods

Diagnose slow performance, rising memory use, battery drain, hangs, and launch delays in Apple platform apps. The skill routes investigations to profiling tools such as Instruments or xctrace, and covers memory leaks, energy use, and optimization paths.

• Investigating an app that feels slow or freezes
• Diagnosing growing memory use or suspected leaks
• Finding causes of battery drain or device heat

Diagnose Swift Package Manager problems by inspecting package manifests, resolved versions, project references, and dependency graphs. It identifies version conflicts, duplicate symbols, Swift language mode mismatches, missing transitive modules, macro build issues, and platform incompatibilities, then suggests ways to resolve them.

• Investigating Swift Package Manager resolution failures
• Diagnosing a “No such module” build error
• Finding the cause of duplicate symbol linker errors

Collect and analyze app performance traces from the command line with xcprof. The skill reports which measurements were available, attributes hot work to app code, and ranks actionable findings for CPU, memory, network, energy, and other supported profiling tasks.

• Profiling CPU usage or a slow app action
• Checking memory allocations or leaks
• Comparing performance traces before and after a change

Get guidance for securing Apple app features, from storing secrets in Keychain and encrypting data with CryptoKit to adding passkeys, protecting AI agents from prompt injection, and managing app signing and provisioning profiles.

• Storing API keys or tokens securely
• Encrypting data or signing payloads
• Adding passkey sign-in

Use this skill to build and troubleshoot UIKit interfaces, connect UIKit with SwiftUI, and modernize app lifecycle and resizing behavior. It points to guidance for Auto Layout, Combine, TextKit, PencilKit, and UIKit animations, including common layout and lifecycle problems.

• Embed a UIKit view in SwiftUI
• Add SwiftUI screens to a UIKit app
• Debug Auto Layout constraint conflicts