format
format configures the SDK-provided dotnet format tool for .NET projects, enabling reproducible code formatting and analyzer fixes across local and CI environments. It respects .editorconfig as the source of truth for style preferences and helps avoid formatter conflicts by clarifying ownership when multiple tools are in use.
format sets up dotnet format with CI-safe verification for .NET repositories using .editorconfig-driven style enforcement.
AI-generated summary based on this skill's SKILL.md
Decision gist · record as of 2026-07-25
format sets up dotnet format with CI-safe verification for .NET repositories using .editorconfig-driven style enforcement. format configures the SDK-provided dotnet format tool for .NET projects, enabling reproducible code formatting and analyzer fixes across local and CI environments. It respects .editorconfig as the source of truth for style preferences and helps avoid formatter conflicts by clarifying ownership when multiple tools are in use.
Use it when
- format clarifies that dotnet format is the SDK-provided tool for style enforcement and analyzer fixes driven by .editorconfig.
- format uses .editorconfig as the source of truth for all style preferences.
Verify before relying
Read SKILL.md below before installing (5 files). Open directory: indexed for reading, not audited.
Install
managedcode/dotnet-skills/format · repository language: C#
Open directory. Skills are indexed for reading, not audited. Review a skill's body before installing it.
Frequently asked questions
AI-generated answers based on this skill's SKILL.md and metadata
How do I set up dotnet format for CI verification in my project?
format enables dotnet format setup for CI by configuring the tool to run reproducibly across environments. Install dotnet format via the .NET SDK, create or update your .editorconfig file with style rules, then add a CI step using `dotnet format --verify-no-changes` to fail the build if code doesn't match your configured style. This ensures all commits meet formatting standards before merge.
What's the difference between dotnet format and CSharpier?
format clarifies that dotnet format is the SDK-provided tool for style enforcement and analyzer fixes driven by .editorconfig, while CSharpier is an opinionated third-party formatter. They can conflict if both run on the same code. Choose one as your primary formatter and configure the other to respect its output, or disable overlapping rules to prevent fights during formatting.
How do I configure editorconfig-driven style enforcement with dotnet format?
format uses .editorconfig as the source of truth for all style preferences. Create a .editorconfig file in your repository root with rules like `indent_style`, `indent_size`, and C#-specific analyzers (e.g., `csharp_space_after_cast`). dotnet format reads these rules and applies them during `dotnet format` runs, ensuring consistent enforcement across your team and CI.
Why is dotnet format not working or the command is missing?
format helps troubleshoot missing dotnet format by confirming it ships with .NET SDK 5.0+. Verify your SDK version with `dotnet --version`. If format is unavailable, update your SDK or install it globally via `dotnet tool install -g dotnet-format`. Check that your project targets a compatible framework and that .editorconfig exists; without it, dotnet format has no rules to apply.
How can I verify formatting without making changes in my build?
format enables CI-safe checks using `dotnet format --verify-no-changes`, which reports violations without modifying files. This is ideal for CI pipelines: run it to detect drift, fail the build if formatting is needed, and let developers fix locally with `dotnet format`. Combine with `--severity` flags to enforce only critical style rules or include analyzer fixes as needed.
What does dotnet format do with whitespace and style analyzers?
format explains that dotnet format handles both whitespace formatting (indentation, spacing) and code style analyzer fixes defined in .editorconfig. It can apply IDE0 and CA rule corrections automatically, making code consistent with your style guide. Use `dotnet format --help` to see options like `--no-restore` and `--include`/`--exclude` for fine-grained control over what gets formatted.
SKILL.md
Rendered from the published skill. Quoted content, verbatim.
dotnet format
Trigger On
- the repo uses
dotnet format - you need a CI-safe formatting check for .NET
- the repo wants
.editorconfig-driven style enforcement
Value
- produce a concrete project delta: code, docs, config, tests, CI, or review artifact
- reduce ambiguity through explicit planning, verification, and final validation skills
- leave reusable project context so future tasks are faster and safer
Do Not Use For
- repositories that intentionally use
CSharpieras the only formatter - analyzer strategy with no
(truncated - see the full file via the links below)
File tree — 5 files
catalog/Tools/Format/skills/format/SKILL.md
catalog/Tools/Format/skills/format/manifest.json
catalog/Tools/Format/skills/format/references/commands.md
catalog/Tools/Format/skills/format/references/config.md
catalog/Tools/Format/skills/format/references/dotnet-format.md
Let your AI agent find skills like this
Example. Real query, live index.
You found this page by searching. An agent finds it by wishing: SkillFed indexes 56,283 agent skills by what they can do, searchable in plain language.
wish › “Set up dotnet format for a .NET repository with CI verification”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
CSharpier establishes a single, opinionated formatting standard for C# and XML in .NET projects. It detects current formatter state, installs the tool locally for reproducible CI, and documents ownership to avoid conflicts with dotnet format. Use this when your team values consistent formatting decisions over extensive configuration options.
cloc delivers line-count, language composition, and branch-diff statistics for .NET codebases through repeatable, configurable commands. Use it to measure solution footprint, compare code deltas across refs, and track codebase composition—not to assess developer productivity or replace design review.
Modern C# for .NET helps you write idiomatic C# code that aligns with your repository's target framework and language-version constraints. It guides feature selection across C# versions, handles compatibility decisions, and validates that new syntax is actually supported by your project's configuration.
stylecop-analyzers sets up the StyleCop.Analyzers package in .NET repositories, establishing clear ownership between root .editorconfig and stylecop.json configuration. It detects existing state, adds the package where needed, and prevents rule overlap with other analyzer packs. Use it when your team requires stronger style conventions than SDK analyzers alone provide.
This skill deploys the free JetBrains ReSharper Command Line Tools to inspect and refactor .NET repositories using `jb inspectcode` and `jb cleanupcode`. It manages durable team settings through solution-level configuration, enforces quality gates by surfacing and fixing issues rather than ignoring them, and integrates with your build and test pipeline.
Roslynator equips .NET projects with open-source static analysis and code-cleanup capabilities through NuGet analyzer packages and an optional command-line tool. Configure rule severity in `.editorconfig`, run analysis and fix workflows, or detect unused code—all while respecting your repo's existing analyzer setup.
More skills complexity (MIT) · analyzer-config (MIT) · meziantou-analyzer (MIT) · code-analysis (MIT)