Code broken? → diff --package Foo@old..new first, then member
What's new in a .NET preview? → diff --platform System.Runtime@P2..P3 --additive per framework library
What types exist? → type --package Foo (discover types in a package or library)
What members does a type have? → member Type --package Foo (compact table by default)
What does a type look like? → type Type --package Foo (tree view for single type)
What are the method signatures? → member Type --package Foo -m Method (full signatures + docs)
What is the source/IL? → member Type --package Foo -m Method:1 -v:d (Source, Lowered C#, IL)
Where is the source code? → source Type --package Foo (SourceLink URLs), source Type -m Member (with line numbers)
Want raw source content? → source Type --package Foo --cat (fetches and prints source files)
What constructors exist? → member 'Type<T>' --package Foo -m .ctor (use <T> not <>)
How many overloads? → member Type --package Foo --show-index (shows Name:N indices)
What does this package depend on? → depends --package Foo
What does this type inherit? → depends 'INumber<TSelf>'
Want a dependency diagram? → depends --mermaid (standalone) or depends --markdown --mermaid (embedded)
What metadata fields exist? → -S Section --fields "PDB*" (structured query, no DSL)
What version is available? → Foo --version (cache-first), Foo --latest-version (always NuGet), Foo --versions (list all)

When to Use This Skill

"What types are in this package?" — type discovers types, find searches by pattern
"What members does this type have?" — member for methods/properties/events (docs on by default)
"What changed between versions?" — diff classifies breaking/additive changes
"What new APIs shipped in this preview?" — diff --platform System.Runtime@prev..current --additive per framework library
"This code uses an old API — fix it" — diff the old..new version, then member to see the new API
"What extends this type?" — extensions finds extension methods/properties (--reachable for transitive)
"What implements this interface?" — implements finds concrete types
"What does this type depend on?" — depends walks type hierarchy, package deps, or library refs
"Show dependencies as a diagram" — depends --mermaid for standalone mermaid, --markdown --mermaid for embedded
"Where is the source code?" — source returns SourceLink URLs; add member name for line numbers
"What version/metadata does this have?" — package and library inspect metadata
"What version is available?" — Foo --version (fast, cache-first — like docker run)
"What's the latest on NuGet?" — Foo --latest-version (always queries NuGet — like docker pull)
"What versions exist?" — Foo --versions (list all published versions)
"What TFMs are available?" — package Foo --tfms, then type --package Foo --tfm net8.0
"Where is the source code?" — source returns SourceLink URLs; add member name for line numbers
"Show me the actual source?" — source Type --package Foo --cat fetches and prints source file contents
"Show me something cool" — demo runs curated showcase queries

Key Patterns

Default output is markdown — headings, tables, and field lists that render well in terminals, editors, and LLM contexts. No flags needed:

dnx dotnet-inspect -y -- member JsonSerializer --package System.Text.Json    # scan members
dnx dotnet-inspect -y -- type --package System.Text.Json                     # scan types
dnx dotnet-inspect -y -- diff --package System.CommandLine@2.0.0-beta4.22272.1..2.0.3  # triage changes

Default format is markdown — no flags needed. Optional formats: oneline (--oneline), plaintext (--plaintext), json (--json), mermaid (--mermaid). Verbosity (-v:q/m/n/d) controls which sections are included; formatter controls how they render. They compose freely — except --oneline and -v cannot be combined.

dnx dotnet-inspect -y -- member JsonSerializer --package System.Text.Json -v:d  # detailed (source/IL)
dnx dotnet-inspect -y -- System.Text.Json -v:n --plaintext                      # all local sections, plaintext
dnx dotnet-inspect -y -- type --package System.Text.Json --oneline              # compact columnar output
dnx dotnet-inspect -y -- depends Stream --mermaid                               # standalone mermaid diagram
dnx dotnet-inspect -y -- depends Stream --markdown --mermaid                    # mermaid embedded in markdown

Use diff first when fixing broken code — triage changes, then drill into specifics:

dnx dotnet-inspect -y -- diff --package System.CommandLine@2.0.0-beta4.22272.1..2.0.3  # what changed?
dnx dotnet-inspect -y -- member Command --package System.CommandLine@2.0.3               # new API surface

Platform Diffs & Release Notes

For framework libraries (System., Microsoft.AspNetCore.), use --platform instead of --package. This is the primary workflow for .NET release notes — diff each framework library between preview versions:

dnx dotnet-inspect -y -- diff --platform System.Runtime@P2..P3 --additive        # what's new?
dnx dotnet-inspect -y -- diff --platform System.Net.Http@P2..P3 --additive       # per-library
dnx dotnet-inspect -y -- diff --platform System.Text.Json@9.0.0..10.0.0          # across major versions

Multi-library packages: diff --package works across all libraries in a package (e.g., Microsoft.Azure.SignalR with multiple DLLs). For framework ref packages like Microsoft.NETCore.App.Ref, prefer --platform per-library since it resolves from installed packs.

Nightly/preview packages from custom feeds: The --source flag works for version listing but not package downloads. Pre-populate the NuGet cache instead:

# Pre-populate cache (fails with NU1213 but downloads the package)
dotnet add package Microsoft.NETCore.App.Ref --version <version> --source <feed-url>
# Then use normally — resolves from NuGet cache
dnx dotnet-inspect -y -- diff --platform System.Runtime@P2..P3 --additive

Version Resolution (Docker-style)

Version queries use Docker-like semantics: cached packages are served in under 15ms, network calls cost 1–4 seconds. Three flags, three behaviors:

Flag	Behavior	Network	Like Docker...
`--version` (bare)	Local — returns the version from local cache	Only on cache miss	`docker run nginx`
`--latest-version`	Remote — queries nuget.org for the absolute latest	Always	`docker pull nginx`
`--versions`	Remote — returns every published version	Always	`docker image ls --all`

--version and bare-name inspection share the same cache. If Foo --version returns 2.0.3, then Foo (or package Foo) will inspect that same 2.0.3 — no surprises, no extra network call. This is the fast path for most tasks.

--latest-version and --versions always query nuget.org, so they reflect the latest published state. Use --latest-version when you need to confirm the newest version, e.g., before a dependency upgrade.

dnx dotnet-inspect -y -- Foo --version           # what's in the cache? (fast, local)
dnx dotnet-inspect -y -- Foo --latest-version     # what's on nuget.org? (always network)
dnx dotnet-inspect -y -- Foo --versions           # list all published versions
dnx dotnet-inspect -y -- Foo --versions 5         # list latest 5 versions
dnx dotnet-inspect -y -- Foo --versions --preview # include prerelease versions

The same flags work on the package subcommand:

dnx dotnet-inspect -y -- package Foo --version           # same local cache check
dnx dotnet-inspect -y -- package Foo --latest-version     # always queries nuget.org
dnx dotnet-inspect -y -- package Foo --versions           # list all versions

Version pinning with @version syntax:

dnx dotnet-inspect -y -- Foo@2.0.3                # pinned — no network if cached
dnx dotnet-inspect -y -- Foo@latest               # always checks nuget.org
dnx dotnet-inspect -y -- Foo                      # prefer cache, refresh on TTL expiry

Use --version (not --latest-version) as the default. It's fast and returns the same version that bare-name commands will use. Only reach for --latest-version when you need the absolute latest from nuget.org.

Structured Queries (like Go templates, without a DSL)

Discover the schema, then select and project — no template language needed:

dnx dotnet-inspect -y -- System.Text.Json -D                          # list sections
dnx dotnet-inspect -y -- System.Text.Json -D --effective              # sections with data (dry run)
dnx dotnet-inspect -y -- library System.Text.Json -D --tree           # full schema tree
dnx dotnet-inspect -y -- System.Text.Json -S Symbols                  # render one section
dnx dotnet-inspect -y -- System.Text.Json -S Symbols --fields "PDB*"  # project specific fields
dnx dotnet-inspect -y -- type System.Text.Json --columns Kind,Type    # project specific columns

Mermaid Diagrams

The depends command supports --mermaid for Mermaid diagram output. Two modes:

Flags	Output	Use case
`--mermaid`	Standalone mermaid (`graph TD`)	Pipe to `mmdc`, embed in tooling
`--markdown --mermaid`	Mermaid fenced blocks inside markdown	Render in GitHub, VS Code, docs

dnx dotnet-inspect -y -- depends Stream --mermaid                               # type hierarchy as mermaid
dnx dotnet-inspect -y -- depends Stream --markdown --mermaid                    # embedded in markdown
dnx dotnet-inspect -y -- depends --library System.Text.Json --mermaid           # assembly reference graph
dnx dotnet-inspect -y -- depends --package Markout --mermaid                    # package dependency graph

Search Scope

Search commands (find, extensions, implements, depends) use scope flags:

(no flags) — all platform frameworks (runtime, aspnetcore, netstandard)
--platform — all platform frameworks
--extensions — curated Microsoft.Extensions.* packages
--aspnetcore — curated Microsoft.AspNetCore.* packages
--package Foo — specific NuGet package (combinable with scope flags)

type, member, library, diff accept --platform <name> as a string for a specific platform library.

Command Reference

Command	Purpose
`type`	Discover types — terse output, no docs, use `--shape` for hierarchy
`member`	Inspect members — docs on by default, supports dotted syntax (`-m Type.Member`)
`find`	Search for types by glob or fuzzy match across any scope
`diff`	Compare API surfaces between versions — breaking/additive classification
`extensions`	Find extension methods/properties for a type (`--reachable` for transitive)
`implements`	Find types implementing an interface or extending a base class
`depends`	Walk dependency graphs upward — type hierarchy, package deps, or library refs
`package`	Package metadata, files, versions, dependencies, `search` for NuGet discovery
`library`	Library metadata, symbols, references, SourceLink audit
`source`	SourceLink URLs — type-level or member-level (with line numbers), `--cat` to fetch content, `--verify` to check URLs
`demo`	Run curated showcase queries — list, invoke, or feeling-lucky

Filtering and Limiting

dnx dotnet-inspect -y -- type System.Text.Json -k enum               # filter by kind (type and member commands)
dnx dotnet-inspect -y -- type System.Text.Json -t "*Converter*"      # glob filter on type names
dnx dotnet-inspect -y -- member System.Text.Json JsonDocument -m Parse  # filter by member name
dnx dotnet-inspect -y -- type System.Text.Json -5                    # first 5 lines (like head -5)
dnx dotnet-inspect -y -- type System.Text.Json --tail 10             # last 10 lines (like tail -10)

Do not pipe output through head, tail, or Select-Object. Use built-in --head / --tail:

-n N, --head N, or -N — first N lines (like head). Keeps headers, truncates cleanly.
--tail N — last N lines (like tail). Buffers output, emits only the final N lines.
-m N (numeric) — item limit (members per kind section).
-k Kind — filter by kind: class/struct/interface/enum/delegate (type) or method/property/field/event/constructor (type single-type view, member).
-S Section — show only a specific section (glob-capable).

Key Syntax

Generic types need quotes: 'Option<T>', 'IEnumerable<T>'
Use <T> not <> for generic types — "Option<>" resolves to the abstract base, 'Option<T>' resolves to the concrete generic with constructors
type uses -t for type filtering, member uses -m for member filtering (not --filter)
Dotted syntax for member: -m JsonSerializer.Deserialize or -m System.Text.Json.JsonSerializer.Deserialize
Diff ranges use ..: --package System.Text.Json@9.0.0..10.0.0
Derived types only show their own members — query the base type too

Installation

Use dnx (like npx). Always use -y and -- to prevent interactive prompts:

dnx dotnet-inspect -y -- <command>

dotnet-inspect

dotnet-inspect

Quick Decision Tree