Improve Skill Quality logo

Improve Skill Quality

OrganizationPopular
dotnet
improve-skill-quality

Diagnoses and fixes skills in the dotnet/skills repository that lose to their own baseline, fail to activate, time out, or return "no credible improvement". Use when an evaluation verdict is a regression or underpowered, when a skill regressed after a change, when /evaluate reports no results, or when deciding whether a weak skill should be strengthened or retired. Do not use for scaffolding a brand-new skill (use create-skill) or a brand-new eval (use create-skill-test).

Overview

Publisherdotnet
Repositoryskills
Skill nameimprove-skill-quality
Stars
5.5K
Forks
420
Bundled files
2
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 2 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by dotnet on GitHub. Read the source before you install it.

Installation

Install the Improve Skill Quality AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/dotnet/skills/tree/main/.agents/skills/improve-skill-quality
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/dotnet/skills.git /tmp/skills
mkdir -p .claude/skills
cp -r /tmp/skills/.agents/skills/improve-skill-quality .claude/skills/improve-skill-quality
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Improve Skill Quality in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Improve Skill Quality on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Improve Skill Quality is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Improve Skill Quality

Turn a failing or unconvincing evaluation into a targeted fix. The single most common mistake in this repo is rewriting skill prose in response to a verdict whose real cause was the eval, the fixtures, or the harness. Classify first, then fix.

When to Use

  • An evaluation verdict is a regression, underpowered, or "no credible improvement".
  • A skill wins in the isolated arm but not in the plugin arm, or is reported "not activated".
  • /evaluate reports "Evaluation ran but produced no results".
  • A skill scores well but costs too much (tokens, turns, wall time, plugin menu budget).
  • Deciding whether to strengthen or retire a persistently weak skill.

When Not to Use

  • Creating a new skill from scratch — use create-skill.
  • Creating a new eval.yaml from scratch — use create-skill-test.
  • Changing the harness itself (eng/skill-validator, eng/vally-adapter, evaluation*.yml).

Inputs

InputRequiredDescription
Verdict evidenceYesThe /evaluate PR comment, or results.json from the run artifacts
Losing trial transcriptsYes for content fixesBaseline vs. skilled output plus the judge's stated reason
Stimulus-vote W/T/L and repeated-run W/T/LYesSeparates cross-task evidence from reliability
Activation status per armYesIsolated and plugin activation are different failures

Workflow

Step 1: Get the evidence before forming a hypothesis

Read InvestigatingResults.md for how to download artifacts and read results.json. Extract, per failing stimulus:

  • authoritative stimulus-vote W/T/L and separate repeated-run W/T/L
  • activation status in the isolated and plugin arms, separately
  • the judge's verbatim reason on each losing trial
  • whether any trial errored, timed out, or produced empty output

Do not change skill content until you can quote a losing trial and the judge's reason for it. For the other cause classes the evidence is different: harness failures are diagnosed from the job log and the spec, and power problems from the trial record — neither has a losing trial to quote, and demanding one is what sends people rewriting prose instead.

Step 2: Classify the failure

Work down this table and stop at the first row that matches. Rows are ordered by how often the symptom has been misdiagnosed as a skill-content problem — the fixture row is first because a fixture failure also presents as a setup or reliability failure and gets misfiled as one.

SymptomReal cause classGo to
A fixture does not build, is untracked by git, breaks for the wrong reason, or contradicts itselfFixtureStep 4
No results.json, "produced no results", or the spec never loadedHarness / spec-loadStep 3
Trials errored, timed out, or returned empty outputReliabilityStep 3
Trajectories unmatched, a trial errored, or the summary disagrees — verdict reported inconclusiveReliability (not power)Step 3
Positive record (e.g. 16W/8T/1L), comparison conclusive, verdict still not a passStatistical powerStep 5
Skilled arm equals baseline arm by constructionEval designStep 6
Activated and lost on quality, judge names a concrete defectSkill contentStep 7
Activated in isolation, not in pluginActivation / routingStep 8
Not activated in either armFrontmatter descriptionStep 8
Wins but costs far more than baselineScope and costStep 7

A verdict is only a measured result when the comparison was conclusive: adapt.mjs requires zero errored trials, zero unmatched trajectories, and an agreeing summary before it will report a pass or a regression. Confirm that before reading a record as a power problem.

Step 3: Rule out harness and reliability causes

See references/eval-triage.md for the full catalogue. The recurring ones:

  • A spec declaring both config: and defaults: is rejected by vally, the job still exits 0, and the PR comment blames "transient infrastructure". Merge them into one defaults: block.
  • An errored trial is not automatically a fixture problem — judge-side auth and session.idle failures look identical from the verdict and need harness fixes, not SDK pins.
  • expect_tools: [bash] on an advisory question forces a restore or build and turns an answer into a timeout with no quality gain.
  • Genuine code-generation stimuli need roughly 360s; a timeout yields empty output, which fails every grader and hides the real quality signal.
  • Unmatched trajectories, an errored trial, or a summary that disagrees make the comparison inconclusive: the remaining matched trials are biased, so the record is not a measured null and must not be read as a power or content problem.

Step 4: Verify the fixtures before touching the skill

Run python eng/eval-quality/check_eval_quality.py — it blocks eleven defect classes that can cost a real result here. Then confirm by hand:

  • every fixture behaves as its stimulus assumes — a fixture meant to be healthy builds, and one meant to be broken fails for the exact reason the stimulus is about and no other;
  • every referenced fixture is in the git index (git ls-files), not merely on disk — .gitignore has silently swallowed committed coverage fixtures;
  • a fixture never states the same fact in two places that disagree — a Cobertura report whose declared line-rate, summary totals and <line> elements differ is the canonical case — or the two arms legitimately read different truths.

Step 5: Check whether the eval could ever have passed

The gate has two independent bars, and confusing them is the usual misdiagnosis:

  1. Distinct stimuli ≥ 5. Below that the verdict is reported underpowered — never a pass, never a regression.
  2. The sign test must reach p ≤ 0.05 over the discordant (non-tie) stimulus votes. Ties are not discarded silently; they hold the discordant count down.
discordant stimulus votesrecords that passp
≤ 4none, however good the skill≥ 0.0625
5–7zero losses only (5W/0L)0.031
8one loss survivable (7W/1L)0.035

So at exactly 5 stimuli a single tie is fatal — it leaves 4 discordant. At 6 stimuli one tie is survivable (5W/1T/0L); at 7, up to two are (5W/2T/0L). A loss is not.

So a positive record with a failing verdict is a power problem, not a content problem. Fix it by adding discriminating stimuli. Raising runs measures reliability for the same task and cannot clear the floor.

Step 6: Check whether the two arms differ at all

An eval that compares the skill against itself measures judge noise:

  • A dormancy guard (expect_activation: false) must not also set constraints.reject_skills. That makes the skilled arm skill-free, so the activation contract cannot observe a hijack. Schema version 4 retains the identical-arm comparison for diagnostics but excludes it from preference inference; unexpected isolated activation still blocks a pass.
  • A skill with disable-model-invocation: true is absent from the model-facing skilled arm, so its direct eval compares two identical arms regardless of whether graders inspect activation or answer content. Cover it through consumer outcomes instead; for example, filter-syntax is covered by run-tests and mtp-hot-reload.
  • A grader whose config is missing its required key enforces nothing, so the stimulus has one fewer assertion than it appears to.

Step 7: Fix skill content against the losing trial

Only now change the skill. Apply the patterns in references/writing-for-baseline-delta.md; the ones that most often flip a loss:

  • Replace reference prose the model already knows with decisions it would otherwise get wrong.
  • Add stop-conditions so a strong skill does not over-apply — but do not over-correct into answering more narrowly than the baseline did.
  • Scale output structure to input size; a dashboard for an 8-test suite loses to a direct answer.
  • Require truthful validation reporting; claiming "Build succeeded" after a failed restore is an automatic loss.
  • Verify load-bearing API claims by compiling or probing, not by reading source.
  • For cost regressions, gate rare or expensive paths behind references/ reads and size any orchestration to the user's scope.

Step 8: Fix activation

Activation failures are frontmatter and routing failures, not body failures. See references/eval-triage.md. Summary:

FailureFix
Not activated in any armPut the user's own words in description: symptoms, error codes, artifact names, quoted requests
A sibling skill wins the promptClaim the exact ambiguous words in description, and add matching exclusions on both siblings
Model answers with no skill at allRaise the stakes in the description, de-crowd the plugin menu, verify with the plugin arm
Boundary excludes real scenariosRe-read every "do not use for" clause against every eval prompt and real workflow phase
Description at the 1,024-char ceilingCut restated body content, not trigger phrases; check the plugin menu budget too

Step 9: Re-validate

bash
dotnet run --project eng/skill-validator/src/SkillValidator.csproj -- check --plugin ./plugins/<plugin>
python eng/eval-quality/check_eval_quality.py
./eng/run-skill-evals.sh <plugin> <skill>

Then request the official run by submitting a PR review containing /evaluate (Files changed → Review changes), which binds the run to the reviewed commit. Before declaring a regression on the result, confirm the skill payload actually changed — reruns on byte-identical content have shifted 7W/2T/2L to 4W/5T/2L.

Validation

  • For a content fix, a losing trial and the judge's stated reason are quoted in the PR description.
  • The failure was classified before any content was edited.
  • check_eval_quality.py and skill-validator check both pass.
  • Distinct-stimulus count clears the power bar for the target effect and observed tie rate.
  • Isolated and plugin activation are both reported.
  • The PR body records root cause, fix, and validation so the lesson is reusable.

Common Pitfalls

PitfallSolution
Rewriting skill prose in response to an underpowered verdictUnderpowered means too few distinct stimuli; add discriminating stimuli instead
Adding defaults: runs: to a spec that already has config:Merge into a single defaults: block; vally rejects specs with both
Padding runs to clear the stimulus floorRepeats measure reliability for one task; add stimuli
Treating an errored trial as fixture nondeterminismRead the stderr first; judge-side auth failures need harness fixes
Fixing a "wrong" answer that the fixture actually made wrongCheck fixture self-consistency before blaming the response
Strengthening a skill nobody uses and nothing passesWeak eval signal plus thin telemetry is a valid retirement case
Landing a fix without re-runningVerify the invoked payload contains the fix; judge noise is real

References

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Improve Skill Quality AI skill do?

Diagnoses and fixes skills in the dotnet/skills repository that lose to their own baseline, fail to activate, time out, or return "no credible improvement". Use when an evaluation verdict is a regression or underpowered, when a skill regressed after a change, when /evaluate reports no results, or when deciding whether a weak skill should be strengthened or retired. Do not use for scaffolding a brand-new skill (use create-skill) or a brand-new eval (use create-skill-test).

Why use Improve Skill Quality on TypingMind?

Because you install it once and use it with any model. Improve Skill Quality is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Improve Skill Quality in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/dotnet/skills/tree/main/.agents/skills/improve-skill-quality. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Improve Skill Quality?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Improve Skill Quality?

As many as you like. As long as a model supports skills, you can use Improve Skill Quality with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Improve Skill Quality AI skill free?

Yes. It is published on GitHub by dotnet under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇