01
Write idiomatic modern C#
Use clear types, records, pattern matching, nullable annotations, collections, LINQ, exceptions, disposables, and naming that fit the target language version.
Modern .NET development workflow
CategorySoftware Development
Codex Skills for C#
Codex Skills for C# give Codex practical instructions for reading .NET solutions, writing idiomatic C#, using nullable reference types, handling asynchronous work, building ASP.NET Core services, testing behavior, and maintaining packages. Download the skills and configure them for your target framework, SDK, architecture, and coding standards.
Modern C#.NETASP.NET CoreAutomated testing
01
02
03
04
05
06
07
08
09
02
03
04
05
06
07
08
09
task: add invoice endpoint
inspect:
- solution structure
- nullable context
- service contracts
verify: build + tests + analyzersC# correctness is shaped by the project
The same feature changes meaning across target frameworks, nullable settings, async boundaries, analyzers, and application types.
Strong C# code uses the language and runtime deliberately. Nullability communicates contracts, async methods preserve responsiveness, cancellation flows across boundaries, LINQ execution behavior matters, and dependency lifetimes affect correctness.
These skills guide Codex through .NET development with attention to solution structure, compiler diagnostics, framework conventions, package compatibility, tests, performance, and existing architectural choices.
What the downloadable skills can do
What Codex Skills for C# can help develop
02
Handle asynchronous work correctly
Use Task-based APIs, await work properly, propagate cancellation, avoid async void outside event handlers, and preserve exceptions and resource lifetimes.
03
Build .NET applications
Work across ASP.NET Core, workers, console tools, libraries, desktop applications, dependency injection, configuration, logging, and data access.
04
Verify with the .NET toolchain
Compile all target frameworks, run unit and integration tests, respect analyzers and formatting, inspect warnings, and check package and API compatibility.
From solution context to verified change
Let the project files, compiler, and tests define the working constraints
The workflow reads the solution and target frameworks first, then uses compiler feedback and tests throughout implementation.
workflow.statusREADY
Context → Plan → Work → Verify
01
Inspect the solution
Read solution and project files, SDK settings, target frameworks, nullable mode, analyzers, package versions, architecture, and test projects.
02
Trace the relevant contracts
Follow interfaces, dependency injection, models, nullability, async call chains, persistence, serialization, configuration, and public API consumers.
03
Implement in local style
Reuse established patterns, preserve lifetime and cancellation behavior, keep types honest, and avoid suppressing warnings without a clear reason.
04
Run complete .NET checks
Restore, build, test, format or analyze as configured, inspect warnings, and validate every affected target framework and application path.
C# across the .NET ecosystem
Adapt the workflow to the application model in the repository
A web API, reusable library, desktop application, and game project have different lifecycle and compatibility needs.
ASP.NET Core
Build APIs, middleware, authentication policies, dependency injection, configuration, background services, and integration tests.
Libraries and NuGet packages
Design public APIs, preserve binary and source compatibility, target frameworks, document behavior, and prepare package releases.
Desktop and tools
Develop console, WPF, WinForms, and worker applications with responsive async flows, configuration, logging, and deployment.
Unity and game code
Write runtime and editor C# within Unity's supported language, serialization, lifecycle, performance, and platform constraints.
Common C# work
Use the skills for language-level details and full .NET features
The workflow can focus on one class or trace a change across projects in a large solution.
01Add an ASP.NET Core endpoint
02Fix nullable reference warnings
03Refactor synchronous code to async
04Create a background worker
05Write LINQ and data transformations
06Build a reusable class library
07Add xUnit or NUnit tests
08Upgrade a target framework or package
Developers working in .NET
Who Is This For?
These skills support teams that want Codex to respect C# semantics, framework conventions, and solution-specific decisions.
C# developers
Implement features, fix defects, refactor code, improve tests, and use modern language features with project context.
.NET backend teams
Build services with clear contracts, correct dependency lifetimes, async behavior, persistence, authorization, and observability.
Enterprise application teams
Maintain multi-project solutions, compatibility requirements, analyzers, migrations, integrations, and long-lived codebases.
Developers learning C#
See how language features, compiler diagnostics, runtime behavior, project configuration, and tests fit together.
Good to know:
The skills assist C# and .NET work, but changes still require review against the supported SDKs, target frameworks, platform requirements, security standards, performance needs, and production environment.
Configure the .NET context
Installation Guide
Install the skills beside the solution so Codex can inspect project files, shared build settings, tests, and analyzer rules.
Download and extract the C# skills
Keep SKILL.md with its C# guidance, .NET verification process, framework notes, and supporting references.
Choose project or personal scope
Use project scope for solution-specific architecture and versions, or personal scope for reusable C# development habits.
Record SDK and framework support
Provide global.json expectations, target frameworks, C# language version, nullable policy, analyzer severity, runtime identifiers, and supported platforms.
Document project conventions
Add dependency injection patterns, exception rules, async and cancellation policy, testing libraries, formatting, and public API requirements.
Start from the solution root
Open Codex where it can find the solution, Directory.Build files, project references, tests, package configuration, and local instructions.
Before you write C#
Frequently Asked Questions
Answers about .NET versions, ASP.NET Core, null safety, async code, testing, and Unity.
Which C# and .NET versions are supported?+
The skill follows the SDK, target frameworks, language version, and packages declared by the project. State any additional deployment constraints.
Can it build ASP.NET Core APIs?+
Yes. It can guide endpoints, middleware, services, dependency injection, persistence, authentication, validation, logging, and integration tests.
Does it handle nullable reference types?+
Yes. The workflow treats annotations as API contracts, follows compiler flow analysis, and avoids using the null-forgiving operator merely to silence warnings.
Can it fix async and await problems?+
It can trace async call chains, blocking calls, cancellation, exception flow, resource lifetime, and incorrect async void use, then verify the affected behavior.
Can these skills help with Unity C#?+
Yes, when you provide the Unity version and project constraints. Unity APIs, serialization, lifecycle methods, main-thread rules, and supported C# features must be respected.
Let the compiler help prove the design
Give Codex a C# workflow that respects types, async behavior, framework conventions, and the whole solution.
Honest nullability. Predictable tasks. Clean builds. Tests across the affected projects.