Official agent skill

Update .NET Release Graph

by dotnet in dotnet/core

Regenerates the HAL+JSON .NET release information graph from source data when new releases, CVE data or lifecycle dates change.

OfficialMITAuto-check passedDevelopment

Install Update .NET Release Graph

skills CLI
$ npx skills add dotnet/core --skill update-release-graph -a claude-code

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

GitHub CLI
$ gh skill install dotnet/core update-release-graph --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/dotnet/core.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.github/skills/update-release-graph .claude/skills/update-release-graph && 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
update-release-graph
GitHub stars
22k
Token cost
~4.1k tokens
SKILL.md length
1,154 words
Files
1
Skills in repo
15
Repo updated
First seen
Licence
MIT

At a glance

Regenerates the HAL+JSON .NET release information graph from source data when new releases, CVE data or lifecycle dates change.

  • Works in 11 steps: Verify source data is ready → Run the graph generators → Regenerate legacy files → …
  • Adding a new .NET patch release to the release graph
  • SKILL.md covers Architecture, When to use, Prerequisites and Inputs, plus 5 more sections
  • Calls python3, git and dotnet; reaches nuget.pkg.github.com and learn.microsoft.com; needs GITHUB_TOKEN

What it does

The graph in `release-notes/` is a set of linked JSON files using HAL `_links` and `_embedded` properties, and it is generated from source data, never edited by hand. Inputs are `releases.json`, per-patch `release.json`, `_manifest.json` lifecycle data, an optional root `_llms.json` of overrides and `cve.json` disclosure records. Outputs include the root, major and patch indexes, the timeline hierarchy from year down to month, `llms.json` and download listings.

The `release-notes` tool offers `generate version-index`, `generate timeline-index`, `generate llms-index` and `generate indexes`, which runs all of them, each taking an input directory, an optional output directory and a `--url-root` option. The skill applies when a patch release ships, a major version is added, CVE data changes, a version reaches end of life or any source file is edited. Changes to `supported-os.json` and querying the graph belong to other skills. The excerpt is cut off at the prerequisites.

When your agent uses it

  • Adding a new .NET patch release to the release graph
  • Adding a new major version with its manifest
  • Refreshing timeline entries after CVE or end-of-life changes

Example prompts

  • “A new .NET patch release shipped, so update the release graph from the source data.”
  • “Add the new major version to the graph and regenerate all the indexes.”
  • “Refresh the timeline after I edited a cve.json file.”

Requirements

  • The `release-notes` graph generator tool

Workflow steps

11 steps, taken from the step headings in SKILL.md.

  1. Verify source data is ready
  2. Run the graph generators
  3. Regenerate legacy files
  4. Validate
  5. Spot-check the graph
  6. Commit and PR
  7. Create source data files
  8. Regenerate
  9. Verify the new version appears
  10. Update source data
  11. Regenerate outputs

What it can do on your machine

Read from SKILL.md and the folder at commit 44927bc. 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:

    • python3
    • git
    • dotnet
    • npm
    • npx
    • gh

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

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • nuget.pkg.github.com
    • learn.microsoft.com
    • dotnet.microsoft.com
    • raw.githubusercontent.com

    Also links to:

    • datatracker.ietf.org
    • github.com

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

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • GITHUB_TOKEN

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

Context cost

Update .NET Release Graph loads about 4.1k tokens when it runs. Until then it costs about 166 tokens; SKILL.md has 1,154 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~166
When it runs · the whole SKILL.md, loaded when a task matches
~4.1k

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 dotnet/core at commit 44927bc, republished under its MIT licence (© dotnet). 1,154 words, ~4,055 tokens.

Download SKILL.mdSave it as .claude/skills/update-release-graph/SKILL.md (or your agent's skills folder).
name
update-release-graph
description
Update the HAL+JSON release information graph when new .NET releases ship. Regenerates index files across the version hierarchy (root → major → patch), timeline hierarchy (timeline → year → month), llms.json, and downloads using graph generator tools. USE FOR: adding a new patch release to the graph, adding a new major version, updating timeline entries after a release, refreshing the graph after source data changes. DO NOT USE FOR: supported-os.json changes (use update-supported-os skill), querying the graph (use dotnet-releases skill on release-index branch), editing generated graph files by hand (update source data and regenerate).

Update Release Graph

Regenerate the HAL+JSON information graph in release-notes/. The graph is a set of interconnected JSON files using HAL _links and _embedded properties. It is generated from source data — never hand-edit the output files.

Architecture

Source data (inputs — edit these)
FileLocationPurpose
releases.json{ver}/releases.jsonLegacy release list with all patches, SDKs, component versions, download URLs, hashes
release.json{ver}/{patch}/release.jsonIndividual patch release data (subset of releases.json entry)
_manifest.json{ver}/_manifest.jsonLifecycle data and reference links (GA date, EOL date, what's-new, compatibility)
_llms.json_llms.json (root, optional)Partial overrides merged into generated llms.json
cve.jsontimeline/{year}/{month}/cve.jsonCVE disclosure records
Generated graph (outputs — do not hand-edit)
text
release-notes/
├── index.json                          ← root: all major versions
├── llms.json                           ← AI entry point: latest patches per supported version
├── {ver}/
│   ├── index.json                      ← major: all patches for this version
│   ├── manifest.json                   ← reference hub: compatibility, OS support, what's-new
│   ├── sdk/
│   │   ├── index.json                  ← SDK version index
│   │   └── sdk-{band}.json            ← per-band SDK history
│   ├── downloads/
│   │   ├── index.json                  ← components + feature bands
│   │   ├── runtime.json                ← per-RID runtime downloads
│   │   ├── sdk.json                    ← per-RID SDK downloads
│   │   ├── sdk-{band}.json            ← per-RID band-specific SDK downloads
│   │   ├── aspnetcore.json             ← per-RID ASP.NET Core downloads
│   │   └── windowsdesktop.json         ← per-RID Windows Desktop downloads
│   └── {patch}/
│       └── index.json                  ← patch detail (immutable after creation)
└── timeline/
    ├── index.json                      ← timeline root: all years
    ├── {year}/
    │   ├── index.json                  ← year: all months with releases
    │   └── {month}/
    │       └── index.json              ← month: all patches released (immutable)
Graph generators

The release-notes tool includes four graph generation commands:

CommandGeneratesFrom
generate version-indexRoot index, major indexes, patch indexes, manifests, SDK indexes, downloadsreleases.json, release.json, _manifest.json, cve.json
generate timeline-indexTimeline root, year indexes, month indexesSame sources + release calendar
generate llms-indexllms.jsonSame sources (supported versions only)
generate indexesAll of the above in one shotAll source data

All accept the same arguments:

bash
release-notes generate <type> <input-dir> [output-dir] [--url-root <url>]

When to use

  • A new .NET patch release ships (monthly servicing) — source data is updated, graph needs regenerating
  • A new .NET major version is added — _manifest.json and initial releases.json are created
  • CVE data changes — cve.json files are updated, graph needs refreshing
  • A .NET version reaches end-of-life — _manifest.json is updated, graph needs regenerating
  • Any source data file is modified and the graph should reflect the changes

Prerequisites

release-notes

The release-notes tool handles both graph generation and legacy file operations. The public dotnet-release tool is for navigating release data and CVEs. Packages are published to GitHub Packages.

bash
dotnet tool install -g release-notes \
  --add-source https://nuget.pkg.github.com/richlander/index.json

# Verify — should show graph generation commands
release-notes --help

Note: GitHub Packages requires authentication even for public repositories. If you get a 401 error, configure credentials for the source:

bash
dotnet nuget add source https://nuget.pkg.github.com/richlander/index.json \
  --name github-richlander \
  --username USERNAME \
  --password "$GITHUB_TOKEN" \
  --store-password-in-clear-text
markdownlint
bash
npm install -g markdownlint-cli

Inputs

The user provides:

  • What changed — new patch release, new major version, EOL update, CVE refresh, etc.
  • Which source files were updated — releases.json, release.json, _manifest.json, etc.
  • Optionally, a custom --url-root for link generation (defaults to the release-index branch URL)

Process — Regenerate after a new patch release

This is the most common operation. Source data (releases.json, release.json) has been updated with a new patch release.

1. Verify source data is ready

Confirm these files exist and are updated:

bash
# The major version's releases.json must include the new patch
cat release-notes/{ver}/releases.json | python3 -c "
import sys, json
data = json.load(sys.stdin)
print(f\"Latest: {data['releases'][0]['release-version']} ({data['releases'][0]['release-date']})\")"

# The patch directory should exist with release.json
ls release-notes/{ver}/{patch}/
# Expected: release.json, {patch}.md

The _manifest.json should also be present for the major version:

bash
cat release-notes/{ver}/_manifest.json | python3 -c "
import sys, json
data = json.load(sys.stdin)
print(f\"Version: {data['version']}, Phase: {data['support_phase']}, EOL: {data.get('eol_date', 'N/A')}\")"
2. Run the graph generators

The simplest approach is generate indexes which runs all three generators in sequence:

bash
# Generate all graph files in one shot
release-notes generate indexes release-notes

Or run each generator individually (order matters: version-index → timeline-index → llms-index):

bash
release-notes generate version-index release-notes
release-notes generate timeline-index release-notes
release-notes generate llms-index release-notes

Custom URL root (for PR review before merging to release-index):

bash
release-notes generate indexes release-notes --url-root https://raw.githubusercontent.com/dotnet/core/<commit-sha>

Separate output directory (to inspect output without overwriting source):

bash
release-notes generate indexes release-notes /tmp/graph-output

The default URL root is https://raw.githubusercontent.com/dotnet/core/refs/heads/release-index/release-notes/.

3. Regenerate legacy files
bash
# Regenerate releases-index.json from releases.json files
release-notes generate releases-index release-notes

# Regenerate releases.md
release-notes generate releases release-notes
4. Validate
bash
# Verify release links and hashes (can take minutes — do not cancel)
release-notes verify releases release-notes
# Or for a specific version
release-notes verify releases {ver} release-notes
# Skip hash verification for faster iteration
release-notes verify releases release-notes --skip-hash

# Lint generated markdown
npx markdownlint --config .github/linters/.markdown-lint.yml release-notes/releases.md

Exit codes for verify:

  • 0 — no issues
  • 2 — issues found (report written to stdout as markdown)
5. Spot-check the graph

Verify key relationships are correct:

bash
# Root index lists all versions
python3 -c "
import json
data = json.load(open('release-notes/index.json'))
for r in data['_embedded']['releases']:
    print(f\"{r['version']}: supported={r.get('supported', 'N/A')}\")"

# Major index has the new patch as latest
python3 -c "
import json
data = json.load(open('release-notes/{ver}/index.json'))
print(f\"Latest patch: {data['latest_patch']}\")
print(f\"First embedded: {data['_embedded']['patches'][0]['version']}\")"

# Month timeline includes the patch
python3 -c "
import json
data = json.load(open('release-notes/timeline/{year}/{month}/index.json'))
for ver, patch in data['_embedded']['patches'].items():
    print(f\"{ver}: {patch['version']}\")"

# llms.json is current
python3 -c "
import json
data = json.load(open('release-notes/llms.json'))
for ver, patch in data['_embedded']['patches'].items():
    print(f\"{ver}: {patch['version']} ({patch['date']})\")"
6. Commit and PR
bash
git checkout -b update-release-graph-{date}
git add release-notes/
git commit -m "Update release graph — {summary}"
gh pr create --title "Update release graph — {summary}" --body "{description}"

Process — Add a new major version

When a new .NET major version is added (e.g. .NET 11.0):

1. Create source data files

Create the _manifest.json with lifecycle data and reference links:

bash
# release-notes/{ver}/_manifest.json
json
{
  "kind": "manifest",
  "title": ".NET {ver} Manifest",
  "version": "{ver}",
  "label": ".NET {ver}",
  "target_framework": "net{ver_no_dot}",
  "release_type": "lts|sts",
  "support_phase": "preview|active",
  "ga_date": "20XX-11-XXTXX:XX:XXZ",
  "eol_date": "20XX-XX-XXTXX:XX:XXZ",
  "_links": {
    "downloads-html": { "href": "https://dotnet.microsoft.com/download/dotnet/{ver}", "title": "...", "type": "text/html" },
    "whats-new-html": { "href": "https://learn.microsoft.com/dotnet/core/whats-new/dotnet-{major}/overview", "title": "...", "type": "text/html" },
    "whats-new": { "href": "https://raw.githubusercontent.com/dotnet/docs/main/docs/core/whats-new/dotnet-{major}/overview.md", "title": "...", "type": "application/markdown" },
    "compatibility-html": { "href": "https://learn.microsoft.com/dotnet/core/compatibility/{ver}", "title": "...", "type": "text/html" }
  }
}

Create the initial releases.json with the first release entry.

Create the release.json in the patch directory.

2. Regenerate

Same as the patch release process — run release-notes generate indexes release-notes → legacy files.

3. Verify the new version appears
  • In index.json root: new version in _embedded.releases
  • In timeline/index.json: version added to the appropriate year's major_releases
  • In llms.json: version in supported_major_releases and _embedded.patches

Process — Mark a version EOL

1. Update source data

Edit release-notes/{ver}/_manifest.json:

  • Set "support_phase": "eol"
  • Set "supported": false (if present)
2. Regenerate outputs

Run all generators. The tools will:

  • Set supported: false in root index
  • Remove from llms.json supported_major_releases and _embedded.patches
  • Update support_phase in major index

Source data conventions

_manifest.json (partial manifest)

This is the authoritative source for lifecycle data. The generators merge it with computed data to produce the full manifest.json.

Required fields: kind, title, version, label, target_framework, release_type, support_phase, ga_date, eol_date.

The _links section contains reference links that are merged into the generated manifest. These are links that cannot be computed (what's-new pages, compatibility docs, release blog, etc.).

Show full SKILL.md (481 more words)Show less
release.json (per-patch)

Contains the full release data for a single patch: component versions, download URLs, file hashes. This is a subset of the corresponding entry in releases.json.

The generators use release.json to:

  • Build patch detail indexes with embedded runtime/SDK data
  • Generate per-RID download files
  • Compute SDK feature band information
Preview releases

Preview/RC releases are stored in a different directory structure:

  • {ver}/preview/preview1/ for preview.1
  • {ver}/preview/rc1/ for RC1

The generators automatically detect this from the version string (contains -preview. or -rc.).

After GA, the generators filter previews from _embedded.patches in the major index. RC releases are kept because they have go-live support.

Graph conventions

ConventionRule
Propertiessnake_case_lower
Link relationskebab-case-lower
DatesISO 8601 with timezone: 2026-02-10T00:00:00+00:00
Default URL roothttps://raw.githubusercontent.com/dotnet/core/refs/heads/release-index/release-notes/
$schemaInjected by generators; points to schemas/v1/
kindDiscriminator: root, major, patch, month, year, timeline, llms, manifest, downloads
Mutability
Index TypeMutable?Notes
Root indexYesUpdated when versions are added/removed
Major indexYesUpdated monthly with new patches
Patch detailNoFrozen after creation
Timeline rootYesUpdated when new years are added
Year indexYesUpdated monthly
Month indexNoFrozen after creation
llms.jsonYesUpdated with every release
manifest.jsonRarelyGenerated from _manifest.json
Downloads filesYesUpdated with new release download URLs

Immutable files use only prev-* links (no next). Mutable files use latest-* links.

Key facts

  • The graph is fully generated — edit source data (releases.json, release.json, _manifest.json), then run the generators
  • Never hand-edit generated files (index.json, manifest.json, llms.json, downloads files, timeline indexes)
  • _manifest.json (with underscore prefix) is the source; manifest.json (without prefix) is the generated output
  • Similarly, _llms.json is optional source overrides; llms.json is the generated output
  • releases-index.json (legacy flat format) is generated by release-notes generate releases-index
  • releases.md is generated by release-notes generate releases
  • The generators are idempotent — running them on unchanged source data produces identical output
  • When running individually, order matters: version-index → timeline-index → llms-index; generate indexes handles this automatically
  • All _links.*.href values are absolute URLs; the base URL is controlled by --url-root
  • _embedded.patches is an array (newest first) in major indexes; an object keyed by major version in month indexes
  • CVE data in the graph comes from timeline/{year}/{month}/cve.json

Common mistakes

MistakeCorrection
Hand-editing index.json or other generated filesEdit source data and re-run the generators
Hand-editing manifest.jsonEdit _manifest.json and re-run VersionIndex
Hand-editing releases-index.jsonRun release-notes generate releases-index release-notes
Hand-editing releases.mdRun release-notes generate releases release-notes
Running generators in wrong orderUse generate indexes (handles order automatically) or run: version-index → timeline-index → llms-index
Missing _manifest.json for a versionThe generators warn but fall back to releases.json; create _manifest.json for accurate lifecycle data
Missing release.json for a patchPatch detail index will be incomplete; ensure every patch has a release.json
Editing source data without regeneratingAlways run release-notes generate indexes release-notes after changing source files
Forgetting --url-root for PR reviewLinks will use the default release-index branch URL; pass --url-root with a commit SHA for verifiable links in PRs

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

Files

Just SKILL.md in .github/skills/update-release-graph of dotnet/core.

Open the folder on GitHubat commit 44927bc

Compare with similar skills

Update .NET Release Graph 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.

Update .NET Release Graph compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Update .NET Release Graph this skilldotnet/core22k—~4.1kAutomated safety check: PassMIT
Add Analyzerdotnet/roslynator3.5k—~1.3kAutomated safety check: PassCustom licence
Release Roslynatordotnet/roslynator3.5k—~1kAutomated safety check: PassCustom licence
Open Pull RequestGremlinq/ExRam.Gremlinq187—~1.5kAutomated safety check: PassMIT
Prepare ReleaseGremlinq/ExRam.Gremlinq187—~1.1kAutomated safety check: PassMIT
Maintain DisCatSharpAiko-IT-Systems/DisCatSharp140—~1.2kAutomated safety check: PassMIT

Similar skills

  • Add Analyzer

    dotnet/roslynator

    Official

    A skill your agent uses when adding a new RCS diagnostic in roslynator (RCS0 formatting, RCS1 general, RCS9 code-analysis), wiring roslynator EditorConfig options, or when docs say CHANGELOG.md…

    3.5k GitHub stars~1.3k tokensUpdated 2 days ago
    DevelopmentAuto-check passed
  • Release Roslynator

    dotnet/roslynator

    Official

    A skill your agent uses when shipping a roslynator release, rolling CHANGELOG.md [Unreleased], updating the VS Code extension changelog, creating a GitHub v release, or optionally tagging cli-v.

    3.5k GitHub stars~1k tokensUpdated 2 days ago
    DevelopmentAuto-check passed
  • Open Pull Request

    Gremlinq/ExRam.Gremlinq

    A skill your agent uses when opening a pull request for the current branch, or when an existing pull request needs a better description - including when the check-description CI check has failed.

    187 GitHub stars~1.5k tokensUpdated 2 days ago
    DevelopmentAuto-check passed
  • Prepare Release

    Gremlinq/ExRam.Gremlinq

    A skill your agent uses when preparing a new release. An agent skill from Gremlinq/ExRam.Gremlinq.

    187 GitHub stars~1.1k tokensUpdated 2 days ago
    DevelopmentAuto-check passed
  • Maintain DisCatSharp

    Aiko-IT-Systems/DisCatSharp

    Guides changes to the DisCatSharp C# Discord library: tracing a payload field through parsing, serialization and caches, then validating across target frameworks.

    140 GitHub stars~1.2k tokensUpdated yesterday
    DevelopmentAuto-check passed
  • Revit Toolkit Backward Compat

    Nice3point/RevitToolkit

    Evolve the public surface of Nice3point.Revit.Toolkit without breaking downstream consumers: deprecate a renamed or replaced member with [Obsolete] with a JetBrains [CodeTemplate] auto-conversion…

    176 GitHub stars~2k tokensUpdated today
    DevelopmentAuto-check passed

More from dotnet/core

All 15 skills in this repo
  • Official

    Audits and updates os-packages.json files listing the Linux packages each .NET release needs per distro, then regenerates the Markdown from the JSON.

    22k GitHub stars~2.3k tokensUpdated yesterday
    Auto-check passed
  • Official

    Audits and updates the supported-os.json files for .NET releases, checking them against upstream lifecycle data and regenerating the markdown with the release-notes tool.

    22k GitHub stars~4.1k tokensUpdated yesterday
    Auto-check passed
  • Official

    Validates .NET release data with the release-notes CLI: download URL liveness, SHA512 hashes, CDN latest.version files and aka.ms redirects.

    22k GitHub stars~1.8k tokensUpdated yesterday
    Auto-check passed
  • Produces the changes.json manifest for a .NET preview, RC or GA milestone by choosing the right VMR base and head refs and running release-notes generate changes.

    22k GitHub stars~1.7k tokensUpdated yesterday
    Auto-check passed
  • Official

    Ranks the changes in a release manifest and writes a scored features file that release notes, docs and blog posts can each cut at their own threshold.

    22k GitHub stars~2.2k tokensUpdated yesterday
    Auto-check passed
  • Official

    Audits a scored features.json file and its draft release notes against editorial examples to catch over-scored, under-scored, or missing entries.

    22k GitHub stars~1.6k tokensUpdated yesterday
    Auto-check passed

Works with

Categories

Questions about Update .NET Release Graph

What does Update .NET Release Graph do?

Regenerates the HAL+JSON .NET release information graph from source data when new releases, CVE data or lifecycle dates change. The graph in `release-notes/` is a set of linked JSON files using HAL `_links` and `_embedded` properties, and it is generated from source data, never edited by hand.json` disclosure records.

When should I use Update .NET Release Graph?

Update .NET Release Graph fits situations like: adding a new .NET patch release to the release graph; adding a new major version with its manifest; refreshing timeline entries after CVE or end-of-life changes.

How do I install Update .NET Release Graph in Claude Code?

Run `npx skills add dotnet/core --skill update-release-graph -a claude-code`. Or copy the skill folder (.github/skills/update-release-graph in dotnet/core) into .claude/skills/update-release-graph in your project. Claude Code loads it when a task matches its description.

How do I install Update .NET Release Graph in Codex?

Run `npx skills add dotnet/core --skill update-release-graph -a codex`. Or copy the skill folder (.github/skills/update-release-graph in dotnet/core) into .agents/skills/update-release-graph in your project. Codex loads it when a task matches its description.

Can I use Update .NET Release Graph 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 dotnet/core --skill update-release-graph -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/update-release-graph, .gemini/skills/update-release-graph, .github/skills/update-release-graph and .opencode/skills/update-release-graph in your project.

What does Update .NET Release Graph need to run?

Going by SKILL.md and its folder, Update .NET Release Graph needs the command-line tools its instructions call (python3, git, dotnet, npm, npx and gh) and credentials named GITHUB_TOKEN. Our summary lists: The `release-notes` graph generator tool.

Does Update .NET Release Graph access the network?

SKILL.md names 6 domains. In commands or code: nuget.pkg.github.com, learn.microsoft.com, dotnet.microsoft.com and raw.githubusercontent.com; the agent is likely to contact these when it follows the instructions. As links in the text: datatracker.ietf.org and github.com. This is read from the text; nothing was executed.

Is Update .NET Release Graph 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 Update .NET Release Graph use?

Update .NET Release Graph 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 Update .NET Release Graph use?

About 4.1k tokens (SKILL.md is roughly 16k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Update .NET Release Graph?

Skills that share tags, products or a category with Update .NET Release Graph: Add Analyzer (dotnet/roslynator, 3.5k stars), Release Roslynator (dotnet/roslynator, 3.5k stars), Open Pull Request (Gremlinq/ExRam.Gremlinq, 187 stars) and Prepare Release (Gremlinq/ExRam.Gremlinq, 187 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Update .NET Release Graph?

dotnet (a GitHub organization, an official publisher) maintains it in dotnet/core, which has 22,038 GitHub stars. The repository holds 15 skills in this directory. The repository was last updated on October 5, 2026.

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