task-observer - One Skill to Rule Them All

The meta-skill that builds and improves all your skills, including itself.

Why "One Skill to Rule Them All"? The slogan doesn't claim this is the best skill. It couldn't be: a meta-skill is useless without the skills it watches over. It describes what Task Observer does: keep an eye on how all your other skills are working and suggest improvements. You decide which changes are installed.

This meta-skill has logged over 1,600 observations across my 81 skills, most of which were turned into skill improvements. The majority of my 81 skills were themselves created based on observations by the meta-skill.

The current version of task-observer also includes improvements from 69 different contributors, each credited as an author or co-author in the commit history, and its commits close 99 issues and pull requests. Without these contributions, the project wouldn't be half as good as it is today.

This meta-skill is a practical application of the Augmented Expertise methodology, an AI framework for knowledge workers. However, users have reported successful integrations into their Hermes and Openclaw setups, so it works equally well with autonomous agents.

Quick install

1. From a terminal (Vercel's skills CLI, needs Node.js): npx skills add rebelytics/one-skill-to-rule-them-all --skill task-observer — add -g to install it for all your projects.
2. In the Claude apps (web, desktop, mobile, Cowork): upload the .skill bundle from the latest release via Settings → Customize.
3. Then activate it: add the activation instruction from references/environments.md to your CLAUDE.md (or your platform's equivalent). Installing alone is not enough, because description matching under-triggers; see "Check that it actually runs" below.

Why you should use task-observer

Creating skills is powerful but time-consuming. The skills that do get built stay frozen: they never learn from how you actually use them.

Task Observer fixes those problems. It's a meta-skill that runs alongside your work, watches what you do, and does two things:

1. Identifies new skills for you — it spots repeating patterns in your work and flags them as skill candidates, then helps you build them, so you get skills without staring at a blank page.
2. Improves your existing skills — it notices corrections you make, preferences you express, and gaps in your current skills, then suggests specific updates.

You work normally. It watches. Your skill library grows and gets better over time.

The self-improving part

This is the detail that makes Task Observer truly beautiful in my opinion. Because it runs during every session and observes all active skills — including itself — it captures improvements to its own methodology over time.

If it misses something, or if its observation format could be clearer, or if it's triggering in contexts where it shouldn't — it notices, and it logs that too. The skill that improves all your skills also improves itself.

What it does

Task Observer monitors your work sessions and looks for three things:

1. Corrections and adjustments — if you adjust the AI's output or steer it in a different direction, that's a signal that a skill could be clearer or more complete
2. Gaps no skill covers yet — if you're doing something manually or repeatedly that could be systematised, the observer flags it as a candidate for a new skill
3. Its own blind spots — the observer watches itself too, capturing improvements to its own methodology as you use it

During each session, it produces a structured observation log: what it noticed, which skills are affected, and specific suggested improvements. You review, approve, and your skills evolve.

Some observations reveal patterns that aren't specific to one skill. These get captured as cross-cutting principles in a separate log — and new skills are automatically checked against them whenever they're created or updated. The more you use the system, the higher the quality floor across your whole skill library.

The observer doesn't modify your installed skills. In an interactive review you approve each change; a scheduled review applies the observations that need no decision from you to staged copies only. Nothing goes live until you install the updated bundle, so you stay in control of what changes and when.

How this differs from project memory

Claude Code Projects can write project memory on its own: when you correct a thread and tell Claude to remember the correction, it goes into that project's memory and later threads start with it. Those entries are notes the agent keeps to, scoped to one project, and they are deleted with the project.

Task Observer does a different job, and the two work best together. Scope: project memory records a fact or a pitfall for this project; Task Observer turns recurring friction into a change to a reusable skill, which then carries into every project that loads that skill. Control: project memory is written automatically and applied as an instruction; a Task Observer observation is a proposal, and a human review sits between the observation and the rule it becomes. Nothing changes a skill until you install the staged update.

The practical link: a pitfall you find yourself storing in project memory more than once, or in more than one project, is a Task Observer signal — it has stopped being about the project and started being about the skill.

Who it's for

You don't need to be a developer. If you use skills in any capacity and you want those skills to get better over time instead of staying frozen, this is for you.

If you're a builder, you can easily integrate this skill, or even just the methodology, into your existing setup. Just point your agent at the repo and let it guide you towards the ideal implementation for your specific setup.

The task observer is particula