Template Comparison
FreeEasily compare .NET templates side by side.
Free · Opens the source repo
What Template Comparison does
The Template Comparison skill allows developers to effectively compare two or more .NET templates using the dotnet new command. This skill is particularly useful for those who are unsure which template to use for their projects, as it provides a side-by-side analysis of various parameters, feature support, frameworks, and classifications. By inspecting each template's help output, the skill generates a comprehensive comparison table that highlights the differences and similarities between the selected templates.
When using this skill, users can input the short names of the templates they wish to compare, such as webapi and webapp. The skill will then gather relevant information about each template’s parameters, including names, types, defaults, and available options. It also evaluates feature support, such as authentication methods and framework compatibility, allowing users to make informed decisions based on their specific project needs.
This skill is ideal for developers who are in the planning stages of a project and need to understand the nuances between similar templates before committing to one. It helps clarify which template best aligns with their requirements, whether they are building a web API, a web application, or a Blazor project. The skill does not support project creation or template authoring, which keeps its focus sharp and relevant for comparison tasks.
By providing clear recommendations based on user input and a structured comparison table, the Template Comparison skill simplifies the decision-making process, ensuring that developers can choose the most appropriate template for their projects without confusion or guesswork.
When to use it
Use this skill when you need to compare multiple .NET templates to determine which one best fits your project requirements.
When not to use it
This skill is not suitable for creating projects from templates or for authoring and validating custom templates.
What you can build with it
Choosing Between Web API and Web App
A developer is unsure whether to use the `webapi` or `webapp` template for a new project and uses this skill to compare their features.
Understanding Blazor Options
A team is evaluating whether to use `blazor` or `blazorwasm` for a client-side application and needs a detailed comparison of their capabilities.
Selecting a Background Processing Template
A developer needs to decide between the `worker` and `console` templates for a background task and uses the skill to clarify their differences.
How to install Template Comparison
View source1. Install with the skills CLI
npx skills add dotnet/skills/template-comparison --agent claude-code2. Or install it manually
Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.
Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs
Inside SKILL.md
Written by dotnetTemplate Comparison
This skill helps an agent compare 2+ dotnet new templates side by side so the user can
pick the right one. It inspects each template's parameters and feature support and renders
a comparison table.
When to Use
- User is deciding between similar templates (e.g.,
webapivswebapp,blazorvsblazorwasm) - User asks "which template should I use for X?"
- User wants to understand how two or more templates differ before creating a project
When Not to Use
- User wants to create a project — route to
template-instantiation - User wants to author or validate a custom template — route to
template-authoringortemplate-validation - User just needs to find or inspect a single template — route to
template-discovery
Inputs
| Input | Required | Description |
|---|---|---|
| Template short names | Yes | Two or more template short names to compare (e.g., webapi, webapp) |
| Comparison focus | No | Optional aspect to emphasize (auth, AOT, frameworks, interactivity) |
Workflow
Step 1: Inspect each template
Run dotnet new <template> --help for each template being compared to collect its
parameters (names, types, defaults, choices) and supported frameworks:
dotnet new webapi --help
dotnet new webapp --help
If a template is not installed, find and install it first (dotnet new search <keyword>,
then dotnet new install <package>).
Run
--helpcalls sequentially. The template engine uses a global mutex, so running severaldotnet new <template> --helpcommands concurrently can fail with a transient "mutex"/"persistence" error and empty output. Inspect templates one at a time; if a call fails, retry it once before moving on, and still produce the comparison from whatever parameter knowledge you have rather than ending with no answer.
Step 2: Build the comparison table
Produce a side-by-side table covering:
- Parameters — name, type, default, choices
- Feature support — auth, AOT, Docker, controllers, interactivity
- Available frameworks — e.g., net8.0, net9.0, net10.0
- Classifications — categories the template advertises (Web, API, Blazor, etc.)
Example shape:
| Aspect | webapi | webapp |
|---|---|---|
Auth (--auth) | None, Individual, SingleOrg, Windows | None, Individual, SingleOrg, ... |
AOT (--aot flag) | present if dotnet new webapi --help lists --aot | present if dotnet new webapp --help lists --aot |
Controllers (--use-controllers) | Yes | n/a |
| Interactivity | n/a | n/a |
| Frameworks | net8.0 / net9.0 / net10.0 | net8.0 / net9.0 / net10.0 |
| Classifications | Web, WebAPI | Web, Razor Pages |
Step 3: Recommend
End with a decisive Recommendation line — never leave the user with just a table. Format:
Recommendation:
<template>— one sentence tying the choice to the user's stated scenario. (Pick the other if<condition>.)
Then link to template-instantiation to create it. A comparison that ends without naming a winner (or a clear "it depends on X") is incomplete — that indecision is what makes this skill tie with a plain answer.
Decision shortcuts for common pairs
Use these as the opinionated default when the user hasn't given a countervailing constraint. Still inspect with --help to confirm parameters, but lead with the verdict:
| Pair | Default pick | Because |
|---|---|---|
webapi vs webapp | webapi for a JSON/REST backend; webapp for server-rendered HTML/Razor Pages | webapi ships controllers/minimal APIs + OpenAPI, no UI |
blazor vs blazorwasm | blazorwasm when offline / no server is required; blazor (Web App) for flexible server + client interactivity | Standalone WASM runs fully client-side, works offline |
worker vs console | worker for long-lived/queue/background processing | Generic Host: DI, logging, config, graceful shutdown, IHostedService lifecycle |
mvc vs webapp | webapp (Razor Pages) for page-focused apps; mvc for controller/view separation at scale | Razor Pages is lighter for CRUD-style pages |
Validation
- Every template requested was inspected via
dotnet new <template> --help - The comparison covers parameters, feature support, frameworks, and classifications
- Differences relevant to the user's scenario are called out explicitly
- A recommendation (or clear trade-off) is provided
Common Pitfalls
| Pitfall | Solution |
|---|---|
| Comparing uninstalled templates from memory | Install and inspect each template so the comparison reflects the real parameters and choices. |
| Assuming feature parity | Parameter names and feature support vary by template — confirm each with --help. |
| Comparing fundamentally different template types | Only compare templates that solve overlapping problems; note when they target different scenarios. |
More Info
- dotnet new templates — built-in template reference
- dotnet new — CLI reference
Frequently asked questions about Template Comparison
Similar skills
Rhino 3D Scripting
Streamline your Rhinoceros 3D scripting tasks.
MVVM Toolkit
Streamline ViewModel development with source generators.
FreeCAD Scripts
Generate Python scripts for FreeCAD automation and modeling.
Azure Architecture Builder
Design and deploy Azure infrastructure using natural language.
Command Development
Streamline your command creation for Claude Code.
Create Cowork Plugin
Easily build and package plugins through guided sessions.