# DrSkill drskill is `brew doctor` for your agent's loadout. It looks at every coding agent on your machine or in your repo, works out exactly which skills and MCP servers each one loads, and checks the whole set for problems. By Drew Breunig, [[MIT License]], Python. Its own framing: *"Making sure your context is clean."* The premise is one most people haven't sat with. Coding agents load [[AI Agent Skills|skills]] and connect to MCP servers **before you type a word**. That loadout is a dependency tree nobody audits, and it's assembled from files you may not have read. ## What it checks **On the skill side:** 1. Skills that shadow each other 2. Skills loaded twice 3. Duplicate or near-duplicate skills 4. Skills that break the `SKILL.md` spec 5. Broken symlinks 6. Drift against your lockfile 7. Skills that burn too many tokens **On the MCP side:** 1. The same server configured twice with drifted settings 2. Secrets sitting in a committable config file 3. Unpinned server packages that run whatever publishes next 4. Server commands that no longer exist 5. Tools whose descriptions collide with each other or with a skill 6. Servers that quietly change their tools after you approved them 7. Tool text carrying hidden instructions, credential paths, or steering toward or away from other tools That last one is a prompt-injection check on your own tooling, and it's the one I'd have least expected to need. ## How it behaves The restraint is the notable part: - It reads your files. It never installs, edits or deletes a skill - Zero LLM calls unless you opt in with `scan --deep` - Never launches or connects to an MCP server unless you opt in with `scan --mcp-connect` - Every finding ends in a command: either a fix or an acknowledgement ```sh uv tool install drskill # or drskill-core for a minimal CI install drskill scan # detect agents, resolve loadouts, report by severity drskill init # write a starter ledger with budgets and thresholds drskill ack fe5b # acknowledge one finding until its content changes drskill review # walk findings one at a time, one keypress each ``` The `ack` model is well judged. Acknowledging silences a finding **until the skill's content changes**, so you dismiss a known-fine overlap once rather than every run, and it comes back if the underlying thing moves. ## Why I keep this note This is aimed squarely at the problem I have. **I run a large skill library, and I check it with a skill.** `osk-meta-skill-health` covers spec compliance, naming, duplicate triggers, orphans and capability collisions. That's the same job, done by an agent that has to choose to be careful, against a checklist I maintain. drskill does it deterministically, from outside, with no model in the loop by default. Those are different guarantees, and the second one is stronger for the checks that are genuinely mechanical. **The MCP checks have no equivalent in my setup at all.** Duplicated servers with drifted settings, unpinned packages, secrets in committable config, and tools that change their descriptions after approval. I have a fair number of MCP servers connected and I have audited exactly none of this. **"Why did the agent pick the wrong skill" finally has a tool.** Overlapping descriptions are the single most common cause, and with a few hundred skills you cannot eyeball it. My own collision checking is a rule I wrote; this is a scanner. The honest question it raises: **when a skill checks your skills, who checks that?** A read-only external scanner that makes no model calls is a better foundation for that job than another agent with the same blind spots. Worth trying against this vault's skill library and seeing what it says. ## References - [dbreunig/drskill](https://github.com/dbreunig/drskill) — source - [Drew Breunig](https://www.dbreunig.com/) — author ## Related - [[AI Agent Skills]] - [[AI Skill Best Practices]] - [[Claude Code Skills]] - [[Claude Code MCP Integration]] - [[Claude Code]] - [[AI Agents]] - [[Open Source]] - [[MIT License]]