visionarycoder/vc.Agentic - Page 8

dotnet-code-quality-standards

Apply repository-specific .NET quality rules with correct split between modern application code and Roslyn tooling constraints.

dotnet-compiled-regex-patterns

Convert RegEx patterns to compiled regular expressions for improved runtime performance.

dotnet-dependency-injection

Combined dotnet dependency injection guidance with task/provider-specific modes. Govern dependency injection lifetimes, registrations, and composition-root usage across .NET services.

dotnet-dto-standards

Define immutable, scope-owned DTO shapes, serialization rules, and mapping scope for .NET applications.

dotnet-exception-handling

Combined dotnet exception handling guidance with task/provider-specific modes. Consolidated guidance for .NET exception-management CWEs with detection patterns, fixes, and verification.

dotnet-immutability-standards

Govern immutable design for DTOs, value objects, events, and configuration models in .NET code.

dotnet-inspect

Query .NET APIs across NuGet packages, platform libraries, and local files. Search for types, list API surfaces, compare and diff versions, find extension methods and implementors. Use whenever you need to answer questions about .NET library contents.

dotnet-intake-router

Route generic .NET requests to the minimum correct implementation skill after domain routing is resolved, separating DI, validation, logging, performance, contracts, and resilience concerns.

dotnet-logging

Combined dotnet logging guidance with task/provider-specific modes. Govern structured logging, correlation, redaction, and level discipline across .NET services.

dotnet-mapping-standards

Standardize dedicated mapping scope, projection patterns, and compile-time-safe DTO transforms in .NET applications.

dotnet-maui-doctor

Validate and fix .NET MAUI development environments. All version requirements are discovered dynamically from NuGet APIs — never hardcode versions.

dotnet-namespace-standards

Standardize root namespace, folder alignment, and namespace ownership rules across .NET projects.

dotnet-naming-conventions

Combined dotnet naming conventions guidance with task/provider-specific modes. Applies consistent C# naming conventions by matching local repository patterns and analyzer expectations.

dotnet-performance-standards

Govern measured hot-path optimization, allocation control, and efficient type choice across .NET code.

dotnet-pinvoke

Map native signatures to .NET safely by making type widths, string encoding, ownership, and handle lifetime explicit.

dotnet-resilience-standards

Apply retry, timeout, circuit-breaker, fallback, and isolation patterns safely to external .NET dependencies.

dotnet-source-generated-regex

Convert runtime or compiled regex usage to build-time GeneratedRegex patterns for .NET 7+.

dotnet-telemetry-standards

Govern OpenTelemetry setup, correlation, metrics, and safe observability patterns across .NET services.

dotnet-trace-collect

Capture cross-platform .NET trace artifacts for performance diagnostics by choosing the correct tool, command, and artifact handoff data.

dotnet-validation-standards

Govern FluentValidation placement, rule ownership, and validation result flow across .NET code.

dotnet-value-object-standards

Enforce immutable, validated, equality-safe value objects that reduce primitive obsession in .NET domain models.

dotnet-webapi

Scaffold or refactor ASP.NET Core Web API projects with OpenAPI, dependency injection, typed contracts, and testable endpoint structure.

drop-python-version-support

Guide changes required when a project drops one or more oldest supported Python versions and raises its minimum supported version. Use when asked to remove the oldest supported runtimes, raise the minimum Python requirement, modernize code after raising the…

dry-principles

Apply DRY guidance when code repeats logic, rules, or structure and should be consolidated without overengineering. Use when refactoring duplication, extracting helpers, standardizing patterns, or deciding whether shared code is worth introducing.

dump-collect

Configure and collect crash dumps for modern .NET applications by choosing the correct runtime path, collection command, and artifact handoff data.

durable-objects

Create and review Cloudflare Durable Objects. Use when building stateful coordination (chat rooms, multiplayer games, booking systems), implementing RPC methods, SQLite storage, alarms, WebSockets, or reviewing DO code for best practices. Covers Workers…

efcore-dbcontext-design

Design EF Core DbContext types with explicit lifetime, model configuration, resilience, and measurable validation.

efcore-intake-router

Route EF Core requests to the minimum correct EF Core skill by separating DbContext design, migrations, testing, and query optimization concerns.

efcore-migrations

Create and apply EF Core migrations with deterministic naming, rollback planning, and measurable deployment checks.

efcore-orm-project

Scaffold Entity Framework Core ORM projects following the Vertical Slice Design (VBD) pattern with clean separation of entities, configurations, and context.

efcore-testing-patterns

Test EF Core code with provider-aware isolation, deterministic data setup, and measurable verification rules.

email-inbox-triage

Triage an inbox: prioritize threads, draft replies safely.

env-provider-skill

Generates environment provider abstractions for configuration access, validation, and testability.

evaluate-plugin

Evaluate a local Codex plugin in engineer-friendly language. Use when the user says "evaluate this plugin", "audit this plugin", "why did this score that way", "what should I fix first", "help me benchmark this plugin", or asks for a plugin-wide report before…

evaluate-skill

Evaluate a local Codex skill in engineer-friendly terms. Use when the user says "evaluate this skill", "give me an analysis of the game dev skill", "audit this skill", "why did this score that way", "what should I fix first", or asks for a skill-specific…

event-sourcing-patterns

Design .NET event-sourced systems when the task needs durable event history, replay, projections, and explicit consistency boundaries.

executing-plans

Implement an assigned plan in bounded steps with dependency checks, verification, and progress reporting.

exp-mock-usage-analysis

Trace .NET mock setups through production control flow to find dead, unreachable, redundant, or replaceable mocks.

exp-simd-vectorization

Experimental optimization workflow for .NET SIMD and TensorPrimitives changes that stay benchmark-gated.

exp-test-maintainability

Analyze .NET test suites for repeated setup, copy-paste structure, and maintainability refactors without editing code.