My agent environment has grown into a small estate. Claude Code itself, a handful of skills from different sources, several MCP servers launched three different ways, plugins from a couple of marketplaces, hooks that call helper CLIs, a status line, and instruction files at user and project level. Every one of those things has its own release cadence, its own update command, and its own way of going quietly out of date.
Keeping it current was a chore I did by hand, and I kept doing it by hand for longer than I like to admit.
The chore I kept doing by hand
There is no single “update everything” button for an agent setup, because there is no single owner. Skills installed with the skills CLI update with npx skills update. Hand-copied skills update when you remember where you copied them from. An MCP server launched with npx -y pulls the latest on each start (unless the npx cache holds it back), one launched with uvx has its own cache, a pinned one stays pinned forever, and a local binary has its own upgrade subcommand. Plugins need their marketplace refreshed before the version comparison even means anything. The agent updates itself, mostly, unless an environment variable has turned that off.
Versions are the easy part, though. The expensive part is deprecation, because nothing breaks on the day it happens. A good example is the batch of reference MCP servers (GitHub, Slack, Brave Search, Puppeteer, PostgreSQL and others) that were moved to the archived modelcontextprotocol/servers-archived repo: npm marks them deprecated, they keep launching, and the replacement lives under a different name entirely. The same goes for an MCP server still configured with the deprecated HTTP+SSE transport, a settings key like includeCoAuthoredBy that Claude Code replaced with attribution, a retired model ID in a config file, or a line in CLAUDE.md pointing the agent at a tool that is no longer installed. None of these throw an error. They just sit there being wrong.

So, periodically, I went through the list. Run claude --version and compare it with npm. Run npx skills check. Open ~/.claude.json, read each MCP entry, look up each package on npm or PyPI, check whether its repo was archived. Read the changelog for anything renamed. Skim settings.json for keys that look old. It was tedious, and I was never sure I had covered everything.
The obvious thing I missed
Here is the embarrassing part. Every single step in that routine is something my coding agent is better at than I am. It has a shell. It can read config files in any format. It can call npm view, query PyPI, and ask the GitHub API whether a repo is archived. It can read a changelog faster than I can find the link to it. And it already knows where its own configuration lives, since it is the thing reading it.
I kept doing the agent’s housekeeping for it, by hand, while the agent sat in the next terminal tab waiting for work. Too dumb to see it earlier, plainly put. The job did not need a new tool. It needed written-down instructions that turn “check everything” into a repeatable procedure, which is exactly what an Agent Skill is.

The skills repo
I put it in a new public repository, lezli01/skills, which I intend to grow into a home for skills I write for my own work. Everything in it follows the open Agent Skills specification, so a skill is a folder with a SKILL.md (instructions plus frontmatter) and optional scripts/ and references/ that the agent loads only when the task calls for them.
Two rules hold for every skill in the repo. They are agent-agnostic: no dependence on one vendor’s features, and where a feature exists in only one agent the skill carries a fallback for the others. And they are cross-platform: helper scripts are plain Node.js, and CI runs the tests on Windows, macOS, and Linux, alongside a validator that checks each skill’s frontmatter, README, links, and discovery by the skills CLI. MIT licensed.
Keepup is the first skill in it, and its folder carries a README written for humans next to the SKILL.md written for the agent:

Installing keepup globally, so it runs from any project:
npx skills add lezli01/skills --skill keepup -g
The repo root is also a Claude Code plugin marketplace, so in Claude Code /plugin install lezli01 --marketplace lezli01/skills installs every skill in it, namespaced as lezli01:<skill-name>.
How keepup works
Keepup (currently 0.2.0) runs one pass in five steps: inventory, check, report, apply, verify. The first three are read-only. Nothing changes until I approve the report.
The inventory is a dependency-free Node script, scripts/inventory.mjs, which the agent runs with its own ID:
node <this-skill-dir>/scripts/inventory.mjs --agent claude-code
It prints JSON covering the agent’s version and install path (and duplicate installs), MCP servers, every skill the agent loads, skill lock entries, plugins and marketplaces, hooks and the status line along with the helper CLIs they call, configured models, instruction files, and leftover .bak or .tmp files. It redacts env values, headers, secret-looking args, and URL query strings, so no token ends up in the agent’s context or the report. The agent then cross-checks with its own listing commands (claude mcp list, claude plugin list), which can see managed config the script cannot.
The check step gives every item exactly one status, backed by evidence: a command’s output, a registry response, or a link to a changelog or deprecation notice. The statuses are Deprecated, Stale (no update exists, but the item no longer holds up: it duplicates something, points at something removed, or is cruft), Update, OK, and Unknown. Unknown is a valid answer; silently skipping an item is not. The skill tells the agent explicitly to verify every deprecation claim against a primary source, because its training data is out of date for exactly these facts. Items that need me (a restart, sudo, a sign-in, or a choice between replacements) are flagged as such.
What I get back is one numbered action list, and I answer with all, a list of numbers, or none. Then the apply step backs up every file it will touch to ~/.keepup-backups/<timestamp>/, and works in dependency order: helper CLIs first, then MCP servers, then skills and plugins, then config cleanups, and the agent itself last, because its update may need a restart. Removed files are moved into the backup folder, not deleted. Instruction files are only edited with approval of the exact change. Finally it re-runs the inventory and the checks for everything it changed and tells me what moved, what failed, and what is still waiting on me.
The scope is deliberately narrow: keepup audits only the agent it runs in. It knows the config layout of Claude Code, Codex CLI, Gemini CLI, Antigravity CLI, Cursor, Copilot CLI, OpenCode, and Windsurf, and if it finds several of them installed it lists the others at the end of the report and suggests running it inside each one, rather than reaching into their config itself. The one exception is shared items, such as a skill in ~/.agents/skills or a helper CLI, which it updates because the running agent depends on them, but a removal or breaking change there always asks first.
What it does not solve
The honest catch is that keepup is itself a snapshot. Its references/agents.md documents where each agent keeps its config “as of 2026-11”, and agents move faster than any reference file. The skill handles this by telling the agent to trust its own --help and docs over the file when they disagree, and to note the difference in the report. That softens the problem without removing it, which is why keepup lives in a repo that npx skills update can pull from. The skill that keeps things current needs keeping current, and since it is installed like any other skill, it shows up on its own list.

It also costs a run’s worth of tokens and wall-clock time, and it needs network access to npm, PyPI, and GitHub. That is a fair trade against me opening config files one by one, and the agent is more thorough about it than I was.
The trade, named plainly: I give up some control over when and how the audit happens, and I get an audit that happens at all, with evidence attached to every finding. The rest of what I build is over at lezli01.is-a.dev.
// comments load as you scroll here. They live in GitHub Discussions; sign in with GitHub to join in.