dotnet-core

Implement C# 14 features and best practices in .NET Core applications.

Updated May 28, 2026
One-click install
npx skills add https://github.com/ojrojas/AgentsInstructions --skill dotnet-core-ojrojas
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: dotnet-core
Source: https://github.com/ojrojas/AgentsInstructions/tree/main/.claude/skills/dotnet-core
Command: npx skills add https://github.com/ojrojas/AgentsInstructions --skill dotnet-core-ojrojas

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps developers modernize their .NET Core applications by enforcing best practices and leveraging the latest C# 14 features.

Core Features & Use Cases

  • Modern Language Features: Implements C# 14 features like extension members, primary constructors, and collection expressions.
  • Architecture Style: Promotes minimal APIs, vertical slice architecture, and constructor-based dependency injection.
  • Performance Rules: Encourages the use of ValueTask, streaming for large datasets, and avoiding allocations in hot paths.
  • API Design: Advocates for explicit contracts, record types, and no over-engineered layers.
  • Observability: Emphasizes structured logging and OpenTelemetry tracing.
  • Error Handling: Recommends using ProblemDetails and avoiding silent exception swallowing.
  • Use Case: For a developer looking to upgrade a .NET Core application, this Skill provides a set of guidelines and rules to ensure modern best practices are followed.

Quick Start

Run the dotnet-core skill to get started with modernizing your .NET Core application.

Frequently Asked Questions about dotnet-core

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I modernize a .NET Core application with C# 14 features?

To modernize a .NET Core application, implement C# 14 features like extension members and primary constructors while enforcing architectural best practices for enhanced performance and maintainability.

What is the best way to improve .NET Core performance in hot paths?

The best way to improve .NET Core performance in hot paths is to use `ValueTask`, stream large datasets, and explicitly avoid memory allocations to reduce garbage collection overhead.

How does vertical slice architecture work with minimal APIs in .NET Core?

Vertical slice architecture with minimal APIs works by organizing .NET Core features around distinct business capabilities, minimizing layers and utilizing constructor-based dependency injection for streamlined API design.

Can I use OpenTelemetry tracing and structured logging for .NET Core observability?

Yes, you can use OpenTelemetry tracing and structured logging in .NET Core to establish robust observability, allowing you to effectively monitor application behavior and diagnose performance issues.

Does .NET Core API design require explicit contracts and ProblemDetails for error handling?

Modern .NET Core API design requires explicit contracts using `record` types and `ProblemDetails` for error handling to ensure clear communication and prevent silent exception swallowing.

When should I avoid over-engineered layers in .NET Core application architecture?

You should avoid over-engineered layers in .NET Core architecture when modernizing applications, opting instead for minimal APIs and vertical slices to reduce unnecessary complexity and improve maintainability.