Agent skill

Graphify Dotnet

by managedcode in managedcode/dotnet-skills

Use graphify-dotnet to generate codebase knowledge graphs, architecture snapshots, and exportable repository maps from .NET or polyglot source trees, with optional AI-enriched semantic relationships.

MITAuto-check passedKnowledge Management

Install Graphify Dotnet

skills CLI
$ npx skills add managedcode/dotnet-skills --skill graphify-dotnet -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install managedcode/dotnet-skills graphify-dotnet --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/managedcode/dotnet-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/catalog/Tools/Graphify/skills/graphify-dotnet .claude/skills/graphify-dotnet && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
graphify-dotnet
GitHub stars
486
Token cost
~1.9k tokens
SKILL.md length
696 words
Files
4 (incl. references)
Skills in repo
81
Repo updated
First seen
Licence
MIT

At a glance

Use graphify-dotnet to generate codebase knowledge graphs, architecture snapshots, and exportable repository maps from .NET or polyglot source trees, with optional AI-enriched semantic relationships.

  • Works in 8 steps: Confirm the problem is structural… → Install and verify the tool before doing… → Start with a bounded AST-only run so the… → …
  • : graphify commands
  • SKILL.md covers Trigger On, Workflow, Architecture and Practical Recipes, plus 6 more sections
  • Calls dotnet

What it does

Graphify Dotnet is an agent skill from managedcode/dotnet-skills. Use graphify-dotnet to generate codebase knowledge graphs, architecture snapshots, and exportable repository maps from .NET or polyglot source trees, with optional AI-enriched semantic relationships. USE FOR: graphify commands; graph JSON, HTML, SVG, Cypher, Markdown, and Obsidian exports; repository map and architecture snapshot generation. DO NOT USE FOR: unrelated stacks; generic tasks that do not need this specific guidance. INVOKES: inspect the repository context, edit targeted files, and run relevant build…

Its SKILL.md is about 1.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 4 other files, including reference files (for example `manifest.json`, `references/source-map.md` and `references/usage-and-operations.md`). Compatibility notes: Requires the graphify-dotnet global tool and a .NET 10 SDK; AST-only extraction works with zero model setup, while semantic enrichment needs Azure OpenAI…

It sits in Knowledge Management, covering Codebase knowledge for agents and Knowledge graphs. It works with .NET, Obsidian and Neo4j. The repository describes itself as: Installable .NET skill catalog and CLI for Codex, Claude Code, GitHub Copilot, and Gemini. The licence is MIT.

When your agent uses it

  • : graphify commands
  • Obsidian exports
  • Repository map and architecture snapshot generation
  • : unrelated stacks

Example prompts

  • “/graphify-dotnet”

Requirements

  • Compatibility (from SKILL.md): Requires the `graphify-dotnet` global tool and a .NET 10 SDK; AST-only extraction works with zero model setup, while semantic enrichment needs Azure OpenAI, Ollama, or GitHub Copilot SDK.

Workflow steps

8 steps, taken from the first numbered list in SKILL.md.

  1. Confirm the problem is structural discovery, architecture review, onboarding, or graph export. If the user only needs one symbol lookup…
  2. Install and verify the tool before doing anything else
  3. Start with a bounded AST-only run so the first output is fast and deterministic
  4. Review outputs in this order
  5. Add AI enrichment only when inferred relationships or conceptual grouping matter more than strict syntax-only structure.
  6. Expand export formats for the real consumer
  7. Use watch for iterative architecture work, but rerun a clean run periodically because deletes and renames can leave stale references behind.
  8. Run benchmark only after you already trust the generated graph.json; its value is comparative token-reduction evidence, not billing-grade…

What it can do on your machine

Read from SKILL.md and the folder at commit 535dd55. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • dotnet

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

  • Compatibility

    Requires the `graphify-dotnet` global tool and a .NET 10 SDK; AST-only extraction works with zero model setup, while semantic enrichment needs Azure OpenAI, Ollama, or GitHub Copilot SDK.

    From compatibility in the SKILL.md frontmatter.

Context cost

Graphify Dotnet loads about 1.9k tokens when it runs, and up to ~4.9k if it reads all its reference files. Until then it costs about 149 tokens; SKILL.md has 696 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~149
When it runs · the whole SKILL.md, loaded when a task matches
~1.9k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~4.9k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from managedcode/dotnet-skills at commit 535dd55, republished under its MIT licence (© managedcode). 696 words, ~1,920 tokens.

Download SKILL.mdSave it as .claude/skills/graphify-dotnet/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.
name
graphify-dotnet
description
Use `graphify-dotnet` to generate codebase knowledge graphs, architecture snapshots, and exportable repository maps from .NET or polyglot source trees, with optional AI-enriched semantic relationships. USE FOR: graphify commands; graph JSON, HTML, SVG, Cypher, Markdown, and Obsidian exports; repository map and architecture snapshot generation. DO NOT USE FOR: unrelated stacks; generic tasks that do not need this specific guidance. INVOKES: inspect the repository context, edit targeted files, and run relevant build, test, lint, or validation commands when changes are made.
compatibility
Requires the `graphify-dotnet` global tool and a .NET 10 SDK; AST-only extraction works with zero model setup, while semantic enrichment needs Azure OpenAI, Ollama, or GitHub Copilot SDK.

graphify-dotnet

Trigger On

  • graphify, graphify run, graphify watch, graphify benchmark, or graphify config
  • generating graph.json, graph.html, graph.svg, graph.cypher, GRAPH_REPORT.md, obsidian/, or wiki/
  • building onboarding maps, architecture snapshots, or dependency-discovery artifacts from a repository
  • choosing between AST-only extraction and AI-enriched semantic extraction
  • pushing graph output into Neo4j, Obsidian, wiki docs, or CI artifacts

Workflow

  1. Confirm the problem is structural discovery, architecture review, onboarding, or graph export. If the user only needs one symbol lookup, one bug fix, or one dependency trace, normal repo search and tests are cheaper than a full graph run.
  2. Install and verify the tool before doing anything else:
    bash
    dotnet --version
    dotnet tool install -g graphify-dotnet
    graphify --version
  3. Start with a bounded AST-only run so the first output is fast and deterministic:
    bash
    graphify run ./src --format json,html,report --provider none --verbose
  4. Review outputs in this order:
    • GRAPH_REPORT.md for quick signal
    • graph.html for visual exploration
    • graph.json for scripting and downstream tooling
  5. Add AI enrichment only when inferred relationships or conceptual grouping matter more than strict syntax-only structure.
  6. Expand export formats for the real consumer:
    • svg for static docs and PRs
    • neo4j for graph queries
    • obsidian,wiki for knowledge-base or onboarding flows
  7. Use watch for iterative architecture work, but rerun a clean run periodically because deletes and renames can leave stale references behind.
  8. Run benchmark only after you already trust the generated graph.json; its value is comparative token-reduction evidence, not billing-grade accounting.

Architecture

mermaid
flowchart LR
  A["Repository or subtree"] --> B["graphify run / watch"]
  B --> C{"AI provider configured?"}
  C -->|No| D["AST extraction only"]
  C -->|Yes| E["AST + semantic extraction"]
  D --> F["Knowledge graph + Louvain communities"]
  E --> F
  F --> G{"Output target"}
  G -->|Human review| H["graph.html + GRAPH_REPORT.md"]
  G -->|Automation| I["graph.json"]
  G -->|Static docs| J["graph.svg"]
  G -->|Knowledge base| K["obsidian/ or wiki/"]
  G -->|Graph queries| L["graph.cypher for Neo4j"]

Practical Recipes

Write a quick architecture snapshot
bash
graphify run . --format html,report --output ./artifacts/graph

Use this when you need a fast human-readable map of the current repo. Read ./artifacts/graph/GRAPH_REPORT.md first, then open ./artifacts/graph/graph.html.

Write queryable and documentation exports
bash
graphify run ./src --format json,neo4j,svg,obsidian,wiki --output ./graphify-out

Use this when the graph will be consumed by scripts, Neo4j, docs, or knowledge-base tooling instead of only a browser.

Read and benchmark an existing graph
bash
graphify benchmark ./graphify-out/graph.json

Treat this as a heuristic efficiency check for AI-context workflows after the graph already exists.

Provider Choice

  • none: best first run, deterministic, fast, no external dependencies
  • ollama: local and privacy-friendly; good for sensitive code or low-cost experimentation
  • azureopenai: enterprise-hosted semantic extraction with explicit endpoint, key, and deployment
  • copilotsdk: lowest-friction option for teams that already authenticate with GitHub Copilot

Choose the provider by operational constraint first, not by model hype:

  • privacy or offline requirements: ollama
  • enterprise Azure governance: azureopenai
  • fastest setup for existing subscribers: copilotsdk
  • no semantic extraction required: none

Configuration Patterns

graphify resolves settings in this priority order:

  1. CLI arguments
  2. user secrets
  3. environment variables
  4. appsettings.local.json
  5. appsettings.json

Use graphify config for the interactive wizard and graphify config show to inspect the resolved effective settings.

Common environment-variable patterns:

bash
# AST-only explicit override
export GRAPHIFY__Provider=None

# Ollama
export GRAPHIFY__Provider=Ollama
export GRAPHIFY__Ollama__Endpoint=http://localhost:11434
export GRAPHIFY__Ollama__ModelId=llama3.2

# Azure OpenAI
export GRAPHIFY__Provider=AzureOpenAI
export GRAPHIFY__AzureOpenAI__Endpoint=https://myresource.openai.azure.com/
export GRAPHIFY__AzureOpenAI__ApiKey=...
export GRAPHIFY__AzureOpenAI__DeploymentName=gpt-4o

# GitHub Copilot SDK
export GRAPHIFY__Provider=CopilotSdk
export GRAPHIFY__CopilotSdk__ModelId=gpt-4.1
Show full SKILL.md (286 more words)Show less

Tradeoffs And Constraints

  • AST-only mode is reliable for structural facts such as files, classes, methods, and imports, but it will not infer conceptual links that are absent from syntax.
  • AI enrichment produces richer graphs but adds latency, provider setup, quota or subscription concerns, and privacy review.
  • watch mode is an inner-loop accelerator, not a perfect source of truth. Deleted files are not fully removed from the graph until a clean rebuild, and renames can temporarily duplicate nodes.
  • graph.html is great for quick inspection, but large graphs can render slowly and some browsers block file:// loading. Serve the output folder locally if the page renders blank.
  • graphify respects .gitignore, so an empty graph can be a path-selection problem instead of a parser failure.
  • benchmark is approximate. The source uses heuristic token estimation, so treat the numbers as directional rather than invoice-grade.

Deliver

  • a justified choice of AST-only vs AI-enriched extraction
  • concrete graphify commands for the repo, folder, or output consumer
  • the right export-format set for humans, docs, scripts, or graph databases
  • configuration guidance that fits the chosen provider and operating model
  • a validation path for the produced graph artifacts

Validate

  • dotnet --version shows a .NET 10 SDK
  • graphify --version resolves after installation
  • graphify run <path> --format json,html,report -v completes without provider or path errors
  • the output folder contains the expected artifacts for the selected formats
  • graphify config show reflects the intended provider configuration when AI enrichment is enabled
  • graphify benchmark <graph.json> runs only after a real graph file exists

Load References

  • references/source-map.md - upstream repository and docs map with direct links to the README, CLI docs, provider setup guides, sample project, and export-format docs
  • references/usage-and-operations.md - practical commands, provider setup patterns, export selection, watch-mode behavior, troubleshooting, and benchmark caveats

© managedcode, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 3 other files (references) in catalog/Tools/Graphify/skills/graphify-dotnet of managedcode/dotnet-skills.

  • SKILL.md
  • manifest.json
  • references/source-map.md
  • references/usage-and-operations.md

Open the folder on GitHubat commit 535dd55

Compare with similar skills

Graphify Dotnet next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Graphify Dotnet compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Graphify Dotnet this skillmanagedcode/dotnet-skills486—~1.9kAutomated safety check: PassMIT
Large Codebase Knowledge Base BuilderTencent/teamai-cli5.1k—~4.4kAutomated safety check: PassCustom licence
GSD Graphifyopen-gsd/gsd-core10k3 repos~5.3kAutomated safety check: NotesMIT
Engraphdevwhodevs/engraph171—~792Automated safety check: PassMIT
Wiki ExportAr9av/obsidian-wiki3.5k—~6.9kAutomated safety check: NotesMIT
Neo4j Driver Python Skillneo4j-contrib/neo4j-skills114—~4.1kAutomated safety check: NotesMIT

Similar skills

  • Compresses a large multi-repository codebase into a structured knowledge base through architecture reverse-engineering, a Graph RAG graph and AST analysis.

    5.1k GitHub stars~4.4k tokensUpdated yesterday
    Knowledge ManagementAuto-check passed
  • GSD Graphify

    open-gsd/gsd-core

    Builds, queries and inspects the project knowledge graph kept in .planning/graphs/ through the /gsd-graphify command, once the feature is switched on in the config.

    10k GitHub starsUsed in 3 repos~5.3k tokens
    Knowledge ManagementAuto-check: notes
  • Engraph

    devwhodevs/engraph

    Index and search document collections using hybrid semantic + graph + full-text search.

    171 GitHub stars~792 tokensUpdated 4 mo ago
    Knowledge ManagementAuto-check passed
  • Wiki Export

    Ar9av/obsidian-wiki

    Export the Obsidian wiki graph to JSON, GraphML, Neo4j Cypher, Postgres/SQL, HTML, or OKF bundles.

    3.5k GitHub stars~6.9k tokensUpdated yesterday
    Knowledge ManagementAuto-check: notes
  • Neo4j Driver Python Skill

    neo4j-contrib/neo4j-skills

    Neo4j Python Driver v6 — driver lifecycle, executequery, managed and explicit transactions, async (AsyncGraphDatabase), result handling, data type mapping, error handling, UNWIND batching…

    114 GitHub stars~4.1k tokensUpdated today
    Knowledge ManagementAuto-check: notes
  • Neo4j Document Import Skill

    neo4j-contrib/neo4j-skills

    Ingests unstructured and semi-structured documents into Neo4j as a knowledge graph.

    114 GitHub stars~5.4k tokensUpdated today
    Knowledge ManagementAuto-check: notes

More from managedcode/dotnet-skills

All 81 skills in this repo
  • Analyzer Config

    managedcode/dotnet-skills

    Use a repo-root .editorconfig to configure free .NET analyzer and style rules.

    486 GitHub stars~1.3k tokensUpdated today
    Auto-check passed
  • Archunitnet

    managedcode/dotnet-skills

    Use the open-source free ArchUnitNET library for architecture rules in .NET tests.

    486 GitHub stars~1.2k tokensUpdated today
    Auto-check passed
  • Aspire

    managedcode/dotnet-skills

    Build, upgrade, and operate Aspire 13.5.x C or TypeScript application hosts with the current CLI, AppHost, ServiceDefaults, integrations, dashboard, testing, MCP, and deployment patterns for…

    486 GitHub stars~3.6k tokensUpdated today
    Auto-check passed
  • Aspnet Core

    managedcode/dotnet-skills

    Build, debug, modernize, or review ASP.NET Core applications with correct hosting, middleware, security, configuration, logging, and deployment patterns on current .NET.

    486 GitHub stars~2.1k tokensUpdated today
    Auto-check passed
  • Asynkron Profiler

    managedcode/dotnet-skills

    Use the open-source free Asynkron.Profiler dotnet tool for CLI-first CPU, allocation, exception, contention, and heap profiling of .NET commands or existing trace artifacts.

    486 GitHub stars~1.7k tokensUpdated today
    Auto-check passed
  • Azure Functions

    managedcode/dotnet-skills

    Build, review, or migrate Azure Functions in .NET with correct execution model, isolated worker setup, bindings, DI, and Durable Functions patterns.

    486 GitHub stars~2.6k tokensUpdated today
    Auto-check passed

Questions about Graphify Dotnet

What does Graphify Dotnet do?

Use graphify-dotnet to generate codebase knowledge graphs, architecture snapshots, and exportable repository maps from .NET or polyglot source trees, with optional AI-enriched semantic relationships. Graphify Dotnet is an agent skill from managedcode/dotnet-skills.NET or polyglot source trees, with optional AI-enriched semantic relationships.

When should I use Graphify Dotnet?

Graphify Dotnet fits situations like: : graphify commands; obsidian exports; repository map and architecture snapshot generation; : unrelated stacks.

How do I install Graphify Dotnet in Claude Code?

Run `npx skills add managedcode/dotnet-skills --skill graphify-dotnet -a claude-code`. Or copy the skill folder (catalog/Tools/Graphify/skills/graphify-dotnet in managedcode/dotnet-skills) into .claude/skills/graphify-dotnet in your project. Claude Code loads it when a task matches its description.

How do I install Graphify Dotnet in Codex?

Run `npx skills add managedcode/dotnet-skills --skill graphify-dotnet -a codex`. Or copy the skill folder (catalog/Tools/Graphify/skills/graphify-dotnet in managedcode/dotnet-skills) into .agents/skills/graphify-dotnet in your project. Codex loads it when a task matches its description.

Can I use Graphify Dotnet in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add managedcode/dotnet-skills --skill graphify-dotnet -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/graphify-dotnet, .gemini/skills/graphify-dotnet, .github/skills/graphify-dotnet and .opencode/skills/graphify-dotnet in your project.

What does Graphify Dotnet need to run?

Going by SKILL.md and its folder, Graphify Dotnet needs the command-line tools its instructions call (dotnet). Compatibility (from SKILL.md): Requires the `graphify-dotnet` global tool and a .NET 10 SDK; AST-only extraction works with zero model setup, while semantic enrichment needs Azure OpenAI, Ollama, or GitHub Copilot SDK..

Does Graphify Dotnet access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Graphify Dotnet safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Graphify Dotnet use?

Graphify Dotnet is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Graphify Dotnet use?

About 1.9k tokens (SKILL.md is roughly 7.7k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 2.9k tokens, read only when the agent opens those files.

What are the alternatives to Graphify Dotnet?

Skills that share tags, products or a category with Graphify Dotnet: Large Codebase Knowledge Base Builder (Tencent/teamai-cli, 5.1k stars), GSD Graphify (open-gsd/gsd-core, 10k stars), Engraph (devwhodevs/engraph, 171 stars) and Wiki Export (Ar9av/obsidian-wiki, 3.5k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Graphify Dotnet?

managedcode (a GitHub organization) maintains it in managedcode/dotnet-skills, which has 486 GitHub stars. The repository holds 81 skills in this directory. The repository was last updated on October 7, 2026.

Source: managedcode/dotnet-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.