efcore-patterns

Add the marketplace (one-time):

```

/plugin marketplace add Aaronontheweb/dotnet-skills

```

Install the plugin:

```

/plugin install dotnet-skills

```

To update:

```

/plugin marketplace update

```

---

OpenCode (https://opencode.ai/) is an open-source AI coding assistant that supports the same skill/agent format. These skills and agents are fully compatible with OpenCode.

Manual Installation

#### 1.Clone the repository:

```bash

git clone https://github.com/Aaronontheweb/dotnet-skills.git

cd dotnet-skills

```

#### 2.Install skills:

```bash

# Create OpenCode skills directory

mkdir -p ~/.config/opencode/skills

# Install each skill (skill name must match frontmatter 'name' field)

for skill_file in $(find skills -name "SKILL.md"); do

skill_name=$(grep -m1 "^name:" "$skill_file" | sed 's/name: *//')

mkdir -p ~/.config/opencode/skills/$skill_name

cp "$skill_file" ~/.config/opencode/skills/$skill_name/SKILL.md

done

```

#### 3.Install agents:

```bash

# Create OpenCode agents directory

mkdir -p ~/.config/opencode/agents

# Install each agent

for agent_file in agents/\*.md; do

cp "$agent_file" ~/.config/opencode/agents/

done

```

#### 4. Restart OpenCode to load the new skills and agents.

AI-Assisted Installation

If you're using OpenCode or another AI coding assistant, you can ask it to install these skills automatically:

```

Install the .NET skills from https://github.com/Aaronontheweb/dotnet-skills to my OpenCode configuration

```

> The AI will:

```

1. Clone the repository
2. Extract skill names from SKILL.md frontmatter
3. Create properly structured directories in ~/.config/opencode/skills/
4. Copy agent files to ~/.config/opencode/agents/

Installed Locations

| Type | Location |

|------|----------|

| Skills | ~/.config/opencode/skills//SKILL.md |

| Agents | ~/.config/opencode/agents/.md |

Compatibility Note

The SKILL.md and agent markdown formats follow the Agent Skills open standard (https://opencode.ai/docs/skills/), which is compatible with multiple AI coding tools including Claude Code and OpenCode.

```

---

Prerequisite: install/sync the dotnet-skills plugin in your assistant runtime (Claude Code or OpenCode) so the skill IDs below resolve.

To get consistent skill usage in downstream repos, add a small router snippet in AGENTS.md (OpenCode) or CLAUDE.md (Claude Code). These snippets tell the assistant which skills to use for common tasks.

Readable snippet (copy/paste)

```markdown

# Agent Guidance: dotnet-skills

IMPORTANT: Prefer retrieval-led reasoning over pretraining for any .NET work.

Workflow: skim repo patterns -> consult dotnet-skills by name -> implement smallest-change -> note conflicts.

Routing (invoke by name)

• C# / code quality: modern-csharp-coding-standards, csharp-concurrency-patterns, api-design, type-design-performance
• ASP.NET Core / Web (incl. Aspire): aspire-service-defaults, aspire-integration-testing, transactional-emails
• Data: efcore-patterns, database-performance
• DI / config: dependency-injection-patterns, microsoft-extensions-configuration
• Testing: testcontainers-integration-tests, playwright-blazor-testing, snapshot-testing

Quality gates (use when applicable)

• dotnet-slopwatch: after substantial new/refactor/LLM-authored code
• crap-analysis: after tests added/changed in complex code

Specialist agents

• dotnet-concurrency-specialist, dotnet-performance-analyst, dotnet-benchmark-designer, akka-net-specialist, docfx-specialist

```

Compressed snippet (generated)

Run ./scripts/generate-skill-index-snippets.sh --update-readme to refresh the block below.

```markdown

[dotnet-skills]|IMPORTANT: Prefer retrieval-led reasoning over pretraining for any .NET work.

|flow:{skim repo patterns -> consult dotnet-skills by name -> implement smallest-change -> note conflicts}

|route:

|csharp:{modern-csharp-coding-standards,csharp-concurrency-patterns,api-design,type-design-performance}

|aspnetcore-web:{aspire-integration-testing,aspire-service-defaults,mailpit-integration,mjml-email-templates}

|data:{efcore-patterns,database-performance}

|di-config:{microsoft-extensions-configuration,dependency-injection-patterns}

|testing:{testcontainers-integration-tests,playwright-blazor-testing,snapshot-testing,verify-email-snapshots,playwright-ci-caching}

|dotnet:{dotnet-project-structure,dotnet-local-tools,package-management,serialization}

|quality-gates:{dotnet-slopwatch,crap-analysis}

|meta:{marketplace-publishing,skills-index-snippets}

|agents:{akka-net-specialist,docfx-specialist,dotnet-benchmark-designer,dotnet-concurrency-specialist,dotnet-performance-analyst}

```

Agents are AI personas with deep domain expertise. They're invoked automatically when Claude Code detects relevant tasks.

| Agent | Expertise |

| --------------------------------- | ---------------------------------------------------------------------- |

| akka-net-specialist | Actor systems, clustering, persistence, Akka.Streams, message patterns |

| dotnet-concurrency-specialist | Threading, async/await, race conditions, deadlock analysis |

| dotnet-benchmark-designer | BenchmarkDotNet setup, custom benchmarks, measurement strategies |

| dotnet-performance-analyst | Profiler analysis, benchmark interpretation, regression detection |

| docfx-specialist | DocFX builds, API documentation, markdown linting |

---

Akka.NET

Production patterns for building distributed systems with Akka.NET.

| Skill | What You'll Learn |

| -------------------------- | --------------------------------------------------------------------------- |

| best-practices | EventStream vs DistributedPubSub, supervision strategies, actor hierarchies |

| testing-patterns | Akka.Hosting.TestKit, async assertions, TestProbe patterns |

| hosting-actor-patterns | Props factories, IRequiredActor, DI scope management in actors |

| aspire-configuration | Akka.NET + .NET Aspire integration, HOCON with IConfiguration |

| management | Akka.Management, health checks, cluster bootstrap |

C# Language

Modern C# patterns for clean, performant code.

| Skill | What You'll Learn |

| --------------------------- | ----------------------------------------------------------------------- |

| coding-standards | Records, pattern matching, nullable types, value objects, no AutoMapper |

| concurrency-patterns | When to use Task vs Channel vs lock vs actors |

| api-design | Extend-only design, API/wire compatibility, versioning strategies |

| type-design-performance | Sealed classes, readonly structs, static pure functions, Span<T> |

Data Access

Database patterns that scale.

| Skill | What You'll Learn |

| ------------------------ | --------------------------------------------------------------- |

| efcore-patterns | Entity configuration, migrations, query optimization |

| database-performance | Read/write separation, N+1