Copilot customization layer

A token-light, spec-driven alternative to GitHub Spec Kit for this .NET 10 microservices + React codebase. Instead of loading large always-on spec documents, context is scoped by file glob and loaded on demand. You only pay tokens for what's relevant to the file or task in front of you.

What's here

Primitive	Files	Loads when
Global instructions	copilot-instructions.md	Always (kept small on purpose)
Scoped instructions	instructions/	Auto-attached by applyTo glob when you touch matching files
Prompts	prompts/	On demand via / in chat
Custom agents	agents/	Selected in chat, or delegated to as subagents
Skills	skills/	On demand (/) or auto when the task matches the description
Hooks	hooks/	Deterministically at session/tool lifecycle events

Instructions (glob-scoped — the token-saver)

File	applyTo
csharp	**/*.cs
cqrs	**/*.Application/**/*.cs
api-versioning	**/*.Api/**/*.cs, **/Program.cs
dotnet-tests	**/*Tests/**, **/*Tests.cs
microservice-structure	src/services/**
docker	**/Dockerfile, **/docker-compose*.yml
react	src/web/**/*.tsx, src/web/**/*.ts
react-tests	src/web/**/*.test.tsx

Prompts (/ in chat)

• /scaffold-microservice — new 4-project service + Docker + versioning + tests
• /scaffold-cqrs-command — write use case, test-first
• /scaffold-cqrs-query — read use case, test-first
• /scaffold-endpoint — versioned minimal API or controller + integration test
• /scaffold-react-component — component + co-located test
• /scaffold-react-feature — React Query hook + components + route, test-first

Agents

• TDD Backend Engineer — strict RED→GREEN→REFACTOR for .NET features
• TDD Frontend Engineer — strict TDD for React features
• CQRS Slice Architect — plans a slice (command vs query, contract, route) before coding
• API Conventions Reviewer — read-only review of versioning/CQRS/layering/test coverage

Skills

• dotnet-vertical-slice — full backend slice end-to-end with bundled C# templates
• react-feature-slice — full frontend slice with bundled TS/TSX templates
• spec-then-slice — router: lean /specify → /plan → /tasks for novel features, falls back to the slice tools to build them, and harvests genuinely new patterns (e.g. EF Core) back into the layer

Hooks (deterministic)

• session-start-tdd — injects the test-first / CQRS / versioning guardrails into every new session
• format-on-edit — formats only the just-edited file (dotnet format / prettier)

Hook scripts ship in both pwsh (Windows) and bash (POSIX) variants. They auto-format and inject context; review them before enabling on a shared machine.

Cost strategy

Each prompt and agent is pinned to the cheapest model that does the job well, with the smallest tool set:

Primitive	Model	Tools	Why
/scaffold-* prompts	GPT-5 mini	edit, read, search, execute	Template-driven generation; small model is plenty
CQRS Slice Architect	GPT-5 mini	read, search, todo	Read-only planning, no edits
API Conventions Reviewer	GPT-5 mini	read, search	Read-only review, cheap enough for every PR
TDD Backend / Frontend	Claude Sonnet 4.5 → GPT-5 mini fallback	read, edit, search, execute, todo	Multi-step RED/GREEN reasoning; mid-tier, never a frontier/Opus model
spec-then-slice skill	frontier (Claude Opus 4.x / GPT-5)	inherits invoking agent	The lone exception: triage + spec/plan/tasks are judgement calls. Hands off to cheaper tiers for implementation
Other skills	inherit invoking agent	—	Run them via the prompts (cheap) or TDD agents

To rebalance cost vs. capability, edit the model: line in the relevant .prompt.md / .agent.md frontmatter. Fallback arrays pick the first available model (availability, not auto-downgrade), so list the cheaper acceptable model second.

---

This file is the reference index for the layer. For why it exists and how to use it, see the root README; to extend it, see CONTRIBUTING.