home / skills / aaronontheweb / dotnet-skills / skills-index-snippets

skills-index-snippets skill

/skills/skills-index-snippets

This skill helps maintain AGENTS.md and CLAUDE.md indexes to route .NET skills and agents efficiently and automatically.

npx playbooks add skill aaronontheweb/dotnet-skills --skill skills-index-snippets

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
4.5 KB
---
name: skills-index-snippets
description: Create and maintain AGENTS.md / CLAUDE.md snippet indexes that route tasks to the correct dotnet-skills skills and agents (including compressed Vercel-style indexes).
invocable: false
---

# Maintaining Skill Index Snippets (AGENTS.md / CLAUDE.md)

## When to Use This Skill

Use this skill when:
- Adding, removing, or renaming any skills or agents in this repository
- Updating `.claude-plugin/plugin.json`
- Creating copy/paste snippets for downstream repositories (OpenCode, Claude Code, etc.)
- You want a compact, always-on index that improves skill utilization

## Goal

Make skills and agents easy for coding assistants to use by removing the decision point.

Instead of hoping an assistant will "remember" to invoke a skill, provide a small router snippet inside `AGENTS.md` / `CLAUDE.md` that:

1) Tells the assistant to prefer retrieval-led reasoning
2) Provides a task->skill/agent routing index
3) Defines lightweight quality gates (optional)

## Source of Truth

- Registry: `.claude-plugin/plugin.json`
  - Skills are listed as directories (each contains `SKILL.md`)
  - Agents are listed as markdown files in `agents/`
- Skill IDs: the `name:` field in each `SKILL.md` frontmatter
- Agent IDs: the `name:` field in each agent frontmatter

When writing snippets for downstream repos, always reference skills/agents by their IDs (frontmatter `name`), not by local filesystem paths.

## Minimal Snippet Template (Readable)

Use this in target repos to route common tasks:

```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
- 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 Template (Vercel-style)

Use this when you want maximum density (small context footprint):

```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-service-defaults,aspire-integration-testing}
|data:{efcore-patterns,database-performance}
|di-config:{dependency-injection-patterns,microsoft-extensions-configuration}
|testing:{testcontainers-integration-tests,playwright-blazor-testing,snapshot-testing}
|quality-gates:{dotnet-slopwatch(after:substantial new/refactor/LLM code),crap-analysis(after:tests added/changed in complex code)}
|agents:{dotnet-concurrency-specialist,dotnet-performance-analyst,dotnet-benchmark-designer,akka-net-specialist,docfx-specialist}
```

### Regenerating the README block

If the README contains the markers below, the generator can update it automatically:

```
<!-- BEGIN DOTNET-SKILLS COMPRESSED INDEX -->
...compressed snippet...
<!-- END DOTNET-SKILLS COMPRESSED INDEX -->
```

Run:

```bash
./scripts/generate-skill-index-snippets.sh --update-readme
```

## How to Update Snippets After Skill Changes

1. Update `.claude-plugin/plugin.json` to include/remove skills and agents.
2. Ensure each skill has correct frontmatter `name:` (used by OpenCode and others).
3. Run `./scripts/validate-marketplace.sh`.
4. Update your snippet routing lists:
   - Add new skills to the right category
   - Remove deleted skills
   - Keep names exactly matching frontmatter IDs
5. If you maintain a downstream `AGENTS.md`/`CLAUDE.md` snippet, regenerate it and re-copy into dependent repos.

## Recommended Categories

These are snippet categories (not necessarily repository folder structure):

- C# / code quality
- ASP.NET Core / Web (incl. Aspire)
- Data
- DI / config
- Testing
- Quality gates
- Specialist agents

Keep the snippet small; it should be a router, not documentation.

Overview

This skill creates and maintains compact AGENTS.md / CLAUDE.md snippet indexes that route tasks to the correct dotnet-skills skills and agents. It supports both human-readable and compressed Vercel-style snippets so downstream assistants can reliably invoke skills by ID. Use it to remove routing ambiguity and improve retrieval-led reasoning for .NET development tasks.

How this skill works

The skill reads the plugin registry and skill/agent frontmatter to build a task->skill routing index. It outputs either a readable markdown block or a compressed single-line snippet that downstream repos can paste into their AGENTS.md / CLAUDE.md. The snippets instruct assistants to prefer retrieval-led reasoning, list routing categories, and optionally define lightweight quality gates and specialist agents.

When to use it

  • When adding, removing, or renaming skills or agents in the plugin registry
  • After updating plugin metadata or skill frontmatter names
  • When creating copy/paste snippets for downstream repositories
  • To provide a compact always-on router so assistants choose the right skill
  • When you want a compressed index to save context footprint

Best practices

  • Reference skills and agents by their frontmatter IDs, not filesystem paths
  • Keep the snippet a router only—avoid embedding long documentation
  • Use the compressed format for small context budgets and readable format for developer-facing docs
  • Include quality gates for heavy or LLM-authored changes (optional)
  • Regenerate snippets after any registry or name changes and validate with the marketplace script

Example use cases

  • Add a new efcore-patterns skill and insert it under the Data category in the snippet
  • Switch to the compressed Vercel-style block to reduce token usage for hosted assistants
  • Create an AGENTS.md in a downstream repo that routes ASP.NET tasks to aspire-service-defaults
  • Include dotnet-slopwatch as a post-refactor quality gate for large changes
  • Regenerate snippets automatically as part of CI after plugin.json updates

FAQ

What is the authoritative source for skill and agent IDs?

Use the plugin registry and each skill/agent frontmatter name field as the source of truth.

Should I use readable or compressed snippets?

Use readable snippets for human-maintained docs and compressed snippets when you need minimal context footprint for downstream assistants.