Dotnet Harness Recommender

dotnet-harness-recommender

AI-powered skill recommendation engine that analyzes .NET project context and suggests relevant skills.

When to Use

Load this skill when:

• Starting work on an unfamiliar project
• Discovering what skills are available for a specific technology
• Understanding which skills apply to detected frameworks
• Getting contextual skill suggestions based on project analysis

Analysis Process

1. Detect Project Context

Analyzes:

• Project files: .csproj, .sln, global.json
• Package references: NuGet packages and versions
• Framework targets: TFM (e.g., net8.0, netstandard2.0)
• File patterns: Source organization and conventions

2. Map to Skills

Maps detected technologies to skill tags:

3. Prioritize Recommendations

Scoring factors:

• Direct match: Package name matches skill trigger (100 points)
• Category match: Technology category match (50 points)
• Version compatibility: Skill supports detected TFM (25 points)
• Usage frequency: Popular skills rank higher (10 points)

Commands

Get Recommendations

/​dotnet-harness:recommend

Analyzes current project and outputs:

Recommended Skills (based on project analysis):

1. dotnet-efcore-patterns (95/​100)
   Detected: Microsoft.EntityFrameworkCore 8.0.0
   Why: Core EF patterns for data access layer

2. dotnet-api-security (80/​100)
   Detected: Microsoft.AspNetCore.Authentication.JwtBearer
   Why: JWT auth and API security patterns

3. dotnet-resilience (75/​100)
   Detected: Polly package
   Why: Retry, circuit breaker patterns

Filter by Category

/​dotnet-harness:recommend --category data
/​dotnet-harness:recommend --category testing
/​dotnet-harness:recommend --category security

Interactive Mode

/​dotnet-harness:recommend --interactive

Guides through:

1. Project type selection
2. Technology stack questions
3. Architecture pattern questions
4. Generates prioritized skill list

Integration with Hooks

Session start hook automatically runs recommendation when:

• New .csproj detected in workspace
• No previous recommendations exist
• Project dependencies changed

See .rulesync/​hooks.json for implementation.

Project Pattern Detection

Web API Projects

<Project Sdk="Microsoft.NET.Sdk.Web">
  <PackageReference Include="Microsoft.AspNetCore.OpenApi" />
</​Project>

Triggers: dotnet-minimal-apis, dotnet-api-versioning, dotnet-openapi

Class Library

<Project Sdk="Microsoft.NET.Sdk">
  <TargetFramework>netstandard2.0</​TargetFramework>
</​Project>

Triggers: dotnet-library-api-compat, dotnet-nuget-authoring

MAUI App

<Project Sdk="Microsoft.NET.Sdk">
  <UseMaui>true</​UseMaui>
</​Project>

Triggers: dotnet-maui-development, dotnet-maui-aot, dotnet-uno-platform

Blazor WASM

<Project Sdk="Microsoft.NET.Sdk.BlazorWebAssembly">
  <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly" />
</​Project>

Triggers: dotnet-blazor-components, dotnet-blazor-testing, dotnet-aot-wasm

Console App

<Project Sdk="Microsoft.NET.Sdk">
  <OutputType>Exe</​OutputType>
</​Project>

Triggers: dotnet-system-commandline, dotnet-cli-architecture

Output Format

{
  "project_type": "Web API",
  "detected_frameworks": ["ASP.NET Core 8.0", "EF Core 8.0"],
  "recommendations": [
    {
      "skill": "dotnet-efcore-patterns",
      "confidence": 95,
      "reason": "Microsoft.EntityFrameworkCore detected",
      "priority": "high"
    }
  ],
  "alternatives": [
    {
      "skill": "dotnet-dapper-patterns",
      "reason": "Alternative to EF Core for performance"
    }
  ]
}

Best Practices

• Start with top 3: Focus on highest confidence matches
• Check version compatibility: Ensure skill supports your TFM
• Review alternatives: Consider alternative approaches
• Document choices: Note why specific skills were selected

Local Analysis Only

All analysis happens client-side:

• No external API calls
• No telemetry collection
• No skill usage tracking
• Results cached locally in .dotnet-harness/​recommendations.json

References

• [skill:dotnet-project-analysis] -- project context detection
• [skill:dotnet-version-detection] -- TFM and SDK detection
• [skill:dotnet-harness-manifest] -- skill metadata and tags

Code Navigation (Serena MCP)

Primary approach: Use Serena symbol operations for efficient code navigation:

1. Find definitions: serena_find_symbol instead of text search
2. Understand structure: serena_get_symbols_overview for file organization
3. Track references: serena_find_referencing_symbols for impact analysis
4. Precise edits: serena_replace_symbol_body for clean modifications

When to use Serena vs traditional tools:

• Use Serena: Navigation, refactoring, dependency analysis, precise edits
• Use Read/​Grep: Reading full files, pattern matching, simple text operations
• Fallback: If Serena unavailable, traditional tools work fine

Example workflow:

# Instead of:
Read: src/​Services/​OrderService.cs
Grep: "public void ProcessOrder"

# Use:
serena_find_symbol: "OrderService/​ProcessOrder"
serena_get_symbols_overview: "src/​Services/​OrderService.cs"