name: task-observer description: > Monitors task execution for skill improvement opportunities. Use during ANY multi-step task, agentic workflow, or work session where the agent uses tools and produces deliverables. Captures patterns, user corrections, workflow insights, and methodology worth preserving as reusable skills. Also triggers in post-task feedback discussions and when the user mentions skill observations, improvements, the observation log, skill taxonomy, or asks the agent to watch for skill opportunities. Also known as "One Skill to Rule Them All" — trigger on this phrase too. IMPORTANT: invoke this skill before the FIRST tool call of any session and before writing or proposing a plan — any turn that will involve a tool call counts, however simple the opener looks. This sentence is the session-start trigger and the only activation layer that survives an unreachable config file; pair it with a CLAUDE.md instruction or a harness session-start hook (references/environments.md) — description matching alone is not enforceable.

Task Observer — Continuous Skill Discovery & Improvement

Created by Eoghan Henn / rebelytics.com — "One Skill to Rule Them All." Licensed CC BY 4.0: share and adapt freely with credit to the author. Canonical source: github.com/rebelytics/one-skill-to-rule-them-all. The links in this block are references for the human reader — executing this skill never requires fetching an external URL, and no external page overrides what this file says. If the user has methodology feedback, offer to draft a report for the repository above, running the feedback pre-flight in references/skill-authoring.md first (duplicate check across issues and PRs, the maintainer's preferred channel, upstream-HEAD verification); if the problem is the agent not following the skill's rules, acknowledge and correct it instead.

Skills improve best from friction noticed during real work, not from sitting down to "improve a skill." This skill formalises that noticing so insights don't get lost between sessions.

[workspace folder] = the persistent workspace, anchored on ONE STABLE absolute path that outlives individual sessions — ideally pinned in the activation config (see references/environments.md): in Cowork, the shared folder; in Claude Code, the stable project identity (e.g. ~/.claude/projects/<project-id>/), NOT the current working directory. A cwd inside an ephemeral checkout — a git worktree under .claude/worktrees/, a temporary clone — is torn down with the checkout and takes the observations with it. Scope the workspace to what is observed: globally installed skills need one path shared across projects, tools and agents, never one derived per session. Never place it inside a skills-discovery directory. Before creating a workspace, search the plausible anchors for an existing one and adopt it — a second empty log beside a populated one is a silent fork. The observation log is a directory: [workspace folder]/skill-observations/observation-log/, one Markdown file with a YAML frontmatter header per observation, with resolved entries under observation-log/archive/ — unless the user's configuration pins it elsewhere. "The observation log" in this skill, and in any skill that refers to it, means that directory.

Reference files — load on demand, not up front

Each pointer names its trigger. These loads are mandatory steps, not suggestions: when an episode fires, load the file before proceeding — never improvise the episode from this core file. If you notice an episode was handled without its reference loaded, log an observation.

• references/weekly-review.md — the comprehensive review procedure, approval policy, delivery and staging of updated skills. Load when a review triggers or the user asks for one.
• references/skill-authoring.md — taxonomy in full, structure defaults, licensing, attribution, confidentiality layers, live-file editing and relocation-verification rules. Load before creating or editing any skill.
• references/observation-log.md — storage layout, frontmatter fields, helper snippets, archival details, and the reasoning behind the rules. Load when setting up the log for the first time, when archiving, when an id or frontmatter looks wrong, or before changing how anything reads the log.
• references/signals.md — the full catalogue of what is and isn't worth logging. Load when unsure whether something is an observation, or when sorting many candidates.
• references/environments.md — activation and config setup, compaction behaviour, bundle manifest, handoff-doc mode for storage-less environments. Load for setup questions, after compaction, or when there is no filesystem.
• references/migration.md — the one-time scripted conversion of a pre-3.0 single-file log.md. Load only when the Session Start Protocol detects a legacy log. Fresh installs never read it.

Session Start Protocol

1. Storage. If skill-observations/observation-log/ (with its archive/ subdirectory) or skill-observations/cross-cutting-principles.md don't exist, create them (principles template: references/skill-authoring.md). Create skill-observations/last-review-date.txt containing the literal value never if it doesn't exist — never write a date into it at setup; a date means a review actually ran. If a legacy single-file skill-observations/log.md exists and observation-log/ does not, this is an upgrade from a pre-3.0 install: load references/migration.md and run the scripted conversion before writing anything else. Before creating or writing anything: if the resolved workspace folder sits under an ephemeral path (e.g. .claude/worktrees/, a temporary clone), warn the user and re-anchor on the stable project path first — state written to an ephemeral checkout is lost at teardown.

2. Scan. Read only the frontmatter of each file in observation-log/ — the header block between the first two --- lines, never the bodies — and build awareness from status, skill, proposes_skill and title; also read the active principles. Hold them in awareness, don't surface unprompted. Frontmatter-only is the whole point of the per-file format: the scan stays cheap once hundreds of observations exist.

   An empty scan in a log known to be non-empty is a broken command until proven otherwise, never the finding "no relevant observations". Count the files independently of the parse — a literal path, not the variable the loop uses — and halt if files exist but nothing parsed. Re-derive every path inside the same tool call: shell state does not carry between calls in most harnesses, and a path variable that silently resolves to empty turns a filter into a match-nothing glob rather than an error.

   d=skill-observations/observation-log                                # re-derive in EVERY call
   n=$(ls skill-observations/observation-log/*.md 2>/dev/null | wc -l) # literal path: independent of $d
   parsed=0
   for f in "$d"/*.md; do
     [ -e "$f" ] || continue
     hdr=$(awk 'NR==1 && /^---[[:space:]]*$/ {fm=1; next}
                fm && /^---[[:space:]]*$/ {exit}
                fm' "$f")
     [ -n "$hdr" ] && parsed=$(( parsed + 1 ))
     printf '%s\n---\n' "$hdr"
   done
   [ "$n" -gt 0 ] && [ "$parsed" -eq 0 ] && \
     { echo "SCAN COMMAND BROKEN — $n files present, 0 headers parsed"; exit 1; }
   

3. Review trigger. Read skill-observations/last-review-date.txt. The value carries the truth: a date = when the last review actually ran; never = no review has run yet. A missing file is abnormal (step 1 creates it) — recreate it with never, don't invent a date. If the value is never or older than 7 days AND there are OPEN observations: in an interactive session, offer the review in one line ("the observation backlog hasn't been reviewed [in N days / yet] — run it now, or carry on with your task?") and proceed with the user's task unless they opt in; never gate their work on the review. Only a scheduled/autonomous run loads references/weekly-review.md and runs the review unprompted.

4. Activation. Once per session: if no CLAUDE.md (or equivalent) activation instruction for this skill exists, briefly suggest adding one (see references/environments.md). Skip if already configured.

5. Concurrency. There is no shared log file to guard: each observation is its own file, so creating one never collides with or overwrites another session's entry. Before changing the status of an existing observation, re-read that one file first (a parallel review may have resolved it).

6. Targets and staged work. Resolve each distinct skill: value in the scanned frontmatter against the installed skill set and mention, in one line, any that no longer resolve — a deleted skill can accumulate dozens of observations before a review discovers the target is gone. If skill-updates/PENDING.md lists staged updates, say "N staged updates awaiting review" in one line.

7. First run. If the log is empty and the project has history (handover or decision docs, commit history, test scripts, an existing CLAUDE.md — which is largely a record of corrections nobody logged), offer a one-off backfill pass over those artefacts. Backfilled entries cite the durable artefact (file and section) in session_context instead of a session, and the same-turn immediacy rule is satisfied by one batched write. The pass is one-off; the scheduled review takes over afterwards.

When to Observe

Active for the entire task session — execution, post-task feedback, review discussion, meta-discussion about skills or methodology, and strategy conversations about how work should be done. The observation mindset does not deactivate when the conversation shifts from doing the work to discussing it; review-phase feedback is often the highest-signal input. Inactive only for casual conversation and quick factual questions with no tools or deliverables involved.

What to Watch For

New skill: a reusable multi-step workflow, a methodology the user explains that no skill captures, a recurring task type, a process the user describes as "I always do it this way". Improve a skill: the agent violates a documented rule (the skill needs enforcement, not louder rules); a user correction reveals a missing rule or edge case; a better workflow or technique emerges than the skill recommends; a wrong assumption; new tooling obsoletes a step; a principle that applies to other skills too. Simplify a skill: a section never relevant across many sessions, a rule from a single unvalidated observation, contradictory rules, a rule the agent consistently fails to follow — convert to structural enforcement or remove. Full catalogue with examples: references/signals.md.

Do NOT log: one-off corrections that don't generalise; preferences already captured in a skill; tool bugs unrelated to methodology; observations that would need proprietary client information to be useful in an open-source skill (unless an internal skill is the right home). The generalisability test, when unsure: would this still make sense in another project, and for another task using the same skill? Does it name a missing rule, step or principle rather than fix this task? Is it likely to recur? Mostly no → task context, not an observation. Before minting a proposes_skill name, check the existing candidates and reuse a fitting one — independently logged proposals for one skill rarely share a name.

Validate the target at write time. A name in skill: must be a skill that exists now; if it doesn't, the observation proposes a skill instead. Checking is cheap at write time and expensive forty entries later.

Check the target's siblings at write time, and record that you did. Libraries accumulate families — several skills implementing one methodology for different tools, one structure for different subjects, one companion pattern for different base skills. An insight found while using one member usually applies to the rest, but nothing in the workflow asks, so skill: collapses to a single entry and the family silently diverges. Before writing, resolve the target against the family registry (skill-observations/skill-families.md; spec, coherence models and the no-registry fallback in references/observation-log.md), and for each sibling either add it to skill: or state in the body why it does not apply. Fast test: could this sentence survive having the tool's or subject's name removed? If yes it belongs to every sibling — and a rule that declares itself generic inside one artefact ("this applies to any file-writing script, not just X") is the cheapest possible propagation signal, so treat that phrasing as an automatic multi-skill flag. Then record the outcome in the mandatory siblings_checked: frontmatter field, including the verdict "checked — instance-specific, no propagation": a one-entry skill: list is byte-identical whether the siblings were evaluated or never considered, and only the recorded field makes the absence of the judgement visible to a review or a drift audit.

How to Log

Write the observation file silently, within the same turn or the next — never batch mentally for later; the act of writing is the enforcement mechanism.

Mandatory checkpoint after every 3rd completed todo item. After marking the 3rd, 6th, 9th (etc.) item complete, you must write to disk — not merely ask yourself whether anything is pending. Either write any pending observation files, or, if genuinely none have accumulated, append a one-line no observations acknowledgement to skill-observations/checkpoints.log. The required action is a concrete write; a remembered "ask whether" is not enforcement. The count need not be precise; roughly every third completion is the rule. (Exception: where the workspace is a shared hosted document store in which every write is priced and invalidates other sessions' context, suppress the empty marker and keep only the check — see references/environments.md.)

A denied or failed write is not a read-only log. Retry once before concluding the workspace is unwritable, and try a second tool that reaches the same path — a permission classifier can deny one interface while allowing another, and consecutive denials from a probabilistic gatekeeper are noise, not a wall. Report "failed N times", never "cannot be done", unless retries and alternate interfaces are actually exhausted; otherwise observations are silently lost for the rest of the session.

Deliverable-event flush. Whenever you present or render a major deliverable — a file handed to the user, a deck or PDF render, a staged skill file — or complete a task/todo batch, write any pending observation files at that moment, before moving on. These checkpoints already involve a tool call; piggy-backing the flush onto them makes the write a side effect of work you were doing anyway. (Why both checkpoints are writes rather than questions: references/observation-log.md.)

Two gaps this pairing still leaves — both observed across full working days in which nothing was logged at all.

1. A session can contain no todo items whatsoever. The 3rd-completion checkpoint is bound to ONE tool; work driven entirely through direct tool calls and shell commands never trips it. It is armed only in sessions that happen to use todos, so it is not a safety net that is always present. When a session runs without them, the deliverable flush is the only enforcement left and must be applied deliberately.
2. "Is this a major deliverable?" is a self-assessment, and self-assessment is what fails under load. Prefer triggers unmistakable in the tool record over ones needing a judgement call. In particular, treat any project-completing command — a deploy, release, publish, or push — as a flush point: it is a concrete tool call, as hard a trigger as a completed todo, and it reliably marks the end of a unit of work where insights have accumulated.

The rule behind both: an enforcement trigger must hang on an event objectively visible in the tool record, never on the agent noticing that a moment qualifies. And a counter bound to a single tool is silently inert in every session that does not use it — such triggers always need a second, independent path.

Id and filename. Each observation is NNNN-short-slug.md (zero-padded id + a kebab-case slug from the title). The id is the highest of three values, plus one: the highest numeric prefix in observation-log/, the highest in observation-log/archive/, and the number in observation-log/archive/.id-floor (the highest id ever issued — update it whenever you issue an id above it, so the counter can never restart from 1 when the active directory is empty):

d=skill-observations/observation-log
hi=$( { ls "$d" "$d/archive" 2>/dev/null | grep -oE '^[0-9]+'; cat "$d/archive/.id-floor" 2>/dev/null; } \
     | sort -n | tail -1); : "${hi:=0}"
[ "$hi" -eq 0 ] && [ -n "$(ls "$d"/*.md 2>/dev/null)" ] && { echo "ID COMMAND BROKEN — log is non-empty but no ids extracted"; exit 1; }
next_id=$(( hi + 1 )); echo "$next_id" > "$d/archive/.id-floor"

The guard line distinguishes "the log says zero" from "I could not read the log": a command that fails to empty rather than to error would otherwise propose id 1 in a populated log. A new file never touches another entry's bytes, so it cannot truncate, overwrite or renumber anyone else's work. If two parallel sessions pick the same id, two files share a number — harmless; the next review renumbers one and logs a meta-observation.

Batch writes: resolve each id at its own write time. When logging more than one observation in a session that may overlap a scheduled review or another writer, run the id snippet before EACH file — never pre-compute a range and hardcode sequential numbers into a batch. A batch append is N separate races, not one; pre-baked numbers collapse N independent max-checks into a single stale read (observed: a hardcoded id collided with one a parallel review issued between the check and the write).

A structural probe that comes back empty where content existed before is a stop signal, not a create. If the directory or file you logged to earlier in the session is suddenly missing, or the id check returns empty in a log you know is populated, HALT and re-probe the structure (is there an observation-log/? a log.md.migrated?) — a parallel session may have migrated or reorganised the storage. Never let an append silently recreate a missing target: that converts a migration signal into corruption (observed: a stale session recreated the retired log.md with a fresh "Observation 1" after the per-file migration renamed it).

File format. YAML frontmatter (the metadata every scan reads) followed by the Issue → Improvement → Principle body. The frontmatter is mandatory; always write status: open and a non-empty siblings_checked: at creation time — an observation without a status field is treated as OPEN by reviews, never as nonexistent, and one without siblings_checked: counts as logged without a sibling check.

---
id: [N]
title: [Short descriptive title]
status: open            # open | actioned | declined | superseded | parked
type: open-source       # open-source | internal
skill: [list of existing skills this improves — always a list, even with
       one entry; first entry is primary; may be empty]
proposes_skill: [list of new skills this argues for, by working name;
       may be empty — an observation can fill either list or both]
siblings_checked: [MANDATORY, never blank: the family name and the members
       evaluated, plus the verdict — e.g. "family-name: a, b — shared, both
       added" or "family-name: a, b — instance-specific, no propagation";
       the literal `none` only where the target belongs to no family]
area: [which part of the skill or workflow]
date: [YYYY-MM-DD]
session_context: [what task was being worked on]
parked_until:           # MANDATORY when status is parked, empty otherwise:
                        #   one line naming the condition that unparks it
resolved:               # date resolved; leave empty while OPEN
resolution:             # what was done — set only when actioned/declined
reference:              # optional: path to saved session-local evidence
---

**Issue:** [What happened — specific enough to understand weeks later
without the original conversation.]

**Suggested improvement:** [Concrete change. For existing skills, name the
section or rule; for new skills, scope and key components.]

**Principle:** [The generalisable takeaway — the most important field.]

parked means decided, not pending. Use it when an observation is sound but cannot be acted on until an external precondition is met — the scheduled task that produced it is disabled, the tool it describes is out of use, a dependency has not landed. A parked entry is OUT of the work queue: reviews must not re-escalate it, and the decision belongs in status:, not in a free-text note beside a status: open (a note nothing classifies on leaves the entry in the queue and it gets re-raised at every review). It is not resolved either, so it never archives — archival needs a resolved status plus a resolved: date. It stays in observation-log/ indefinitely until either its parked_until: condition is met — set it back to open and queue it — or it is genuinely resolved. parked_until: is mandatory whenever status is parked: one line stating the condition, phrased so a later session can actually answer whether it has happened.

Context preservation: if an observation depends on session-local data (uploads, API output), save that context into the workspace first and set reference: to its path — an observation whose evidence dies with the session is incomplete.

Confidentiality at logging time: for type: open-source observations, the Issue/Improvement fields may reference specifics for context, but the Principle must be fully generalised — no client names, domains, or details traceable to a real project. Full confidentiality layers: references/skill-authoring.md.

Changing an existing observation: re-read that one file, edit only the frontmatter fields you are changing (status, parked_until, resolved, resolution), never batch-rewrite the directory. Archival is a plain mv (below).

Referencing Observations

Cite an observation by the id field in its frontmatter (= the NNNN- filename prefix). Never cite a grep -n line number as if it were the id — search-tool line numbers are positional metadata, not identifiers. A cited id must fall within the range that exists across observation-log/, archive/ and .id-floor; a number far outside it is almost certainly a line number misread as an id.

Taxonomy (quick version)

Open-source — client-agnostic, methodology-driven, useful to other practitioners. Internal — contains user/client/project specifics or personal preferences. Default to open-source when it could go either way, stripping specifics. The boundary is also a confidentiality boundary, and the two errors are not symmetric: over-classifying as internal costs only reach, under-classifying can leak — when genuinely uncertain, prefer internal and promote later. Full requirements (attribution, licensing, structure): references/skill-authoring.md.

Archival on Write

On every write, first mv already-resolved files from observation-log/ to observation-log/archive/. "Already resolved" is read from the file's own frontmatter: status: actioned, declined or superseded AND a resolved: date before today. Files resolved today stay until the next day, whichever session resolved them — the grace period lives in the file, never in session memory. A resolved file with no readable resolved: date gets today's date written to that field instead of being archived. One file per mv; no rewrite of anything else. Helper and rationale: references/observation-log.md.

Surfacing Protocol

Default: at end of session, as a grouped summary — improvements grouped by skill, new-skill candidates listed separately; for each, one sentence plus suggested type; ask which to act on. Surface earlier when an observation needs user input to be complete, when a skill is actively producing wrong output, or when observations cluster on one skill.

Deferral wears a second disguise: not a promise, but an argument. "Let's wait until this has seen a few days of real use", "we should gather more data first" — this reads as diligence, which is exactly why it goes unchallenged, including by the person saying it. It is not an announcement, so a rule about executing rather than announcing does not catch it. So before writing any "later" into a recommendation, name two things: which specific observation would change the decision, and when it could realistically arrive. If you cannot name one, the evidence is either already conclusive (act now) or waiting adds nothing (act now). Then ask what the delay costs — if a known-defective state stays live meanwhile, the burden of proof is on deferring, not on acting. A deferral is a decision and needs the same justification as acting; "more evidence would be better" is not one, because the question is whether more evidence could change the OUTCOME.

Default to log-and-defer. Surfacing an observation is not an invitation to act on it: state that it is logged for the next review, and stop. Reserve in-session application strictly for the triggers under "Acting on Observations". Do NOT routinely offer a binary "apply now vs leave for next review" choice; for users who run regular reviews that offer is unwanted friction, and if a user has said they always defer, suppress it entirely.

Self-check before surfacing: observations were logged throughout the whole session (including discussion phases); logged silently; each follows Issue → Improvement → Principle; each is typed; existing-skill items name the section; no open-source Principle contains client-identifying info; every observation file carries status: (status: open at write time) and a non-empty siblings_checked: — if any lacks one, do the sibling check now and record it rather than back-filling the field with none.

Acting on Observations

Act only in three contexts: (1) the comprehensive review (load references/weekly-review.md); (2) an explicit user request ("update X skill", "act on observation #N"); (3) in-session correction when a skill is producing wrong output the user should know about. Otherwise: log, don't act.

Read the full body before resolving, dismissing, fixing, or citing. A tracked item's title (observation, GitHub issue, ticket) is an index entry, not its content — it compresses away the failure story, the reporter's context, and often the proposed fix. Dismissal is the path with no downstream checkpoint: a resolved or cited item gets reviewed later, a dismissed one silently disappears. Harvest fix designs from issue bodies — reporters frequently include the correct solution, which also settles attribution. When a parallel agent logs a finding that appears to duplicate your own, diff the two bodies, not the titles: two entries about the same mechanism can carry opposite operational conclusions, and the second is often the refinement, not the echo. Apparent agreement suppresses verification more effectively than disagreement does, so this rule binds hardest exactly where it feels least necessary.

When acting: small, clearly-additive, low-risk changes (a new rule, a clarification, a factual fix) may be applied without waiting for the next review — "directly" means now, not in place: the edit is still made on a staged copy based on a fresh read of the live file and handed to the user to install, in every environment and every context. Staging-only has no interactive exception; an exception the user has to remember is a gate that eventually gets left open. Substantial changes (restructuring, new capabilities, changed methodology) and all new-skill creation: load references/skill-authoring.md first and follow its editing and staging rules. A principle that applies to skills generally goes to the cross-cutting principles file (same reference).

Set the status in the same turn you act. An observation acted on in-session must have its frontmatter updated — status: actioned, resolved: YYYY-MM-DD, resolution: what was done — before the turn ends. The work and the bookkeeping are two acts, and the second is the one that gets dropped; a stale open entry then invites redoing finished work over a section that has since moved on. The write is the enforcement, exactly as it is for logging.

Quick Reference

task-observer - One Skill to Rule Them All

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

In the first seven months of using this meta-skill, it logged over 1200 observations across my 70 skills, most of which were turned into skill improvements. The majority of my 70 skills were themselves created based on observations by the meta-skill.

The current version of task-observer also includes improvements suggested by 36 different users, across 60 issues and 12 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.

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 skills directly. It produces recommendations that you review. You stay in control of what changes and when.

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 particularly valuable if you've built multiple skills and want a systematic way to maintain and improve them without manually auditing each one. It's also useful if you don't have any skills yet: the observer will start identifying skill candidates for you and help you build them.

One honest boundary: the formal observation log and review cycle pay off most as your skill library and usage grow — many skills, parallel sessions, scheduled reviews. If you run a small setup with a handful of skills, your AI system's built-in memory features may cover much of the same ground with less overhead, and editing a skill directly is quick. The observer's value compounds with scale: adopt it early if you expect your library to grow, or come back to it when direct editing stops feeling manageable.

How it works

The best way to get started with this work setup in any environment is to grab the skill, readme and user guide, feed them to your AI and let it guide you towards the best setup for your particular environment - No matter which AI system you use. As long as skills are supported, you should be able to use this approach with some adjustments. And even without skills, the methodology should work with any other type of knowledge base that your AI has access to.

Installation

The skill is a small bundle: SKILL.md, the files in references/ that are loaded on demand (this keeps the always-loaded part lean), and two helper scripts in scripts/. Installing only SKILL.md works, but runs degraded and isn't recommended — the skill will tell you which files are missing.

Get the files: download the .skill bundle attached to the latest release, or download the repo as a ZIP (Code → Download ZIP) / clone it and keep SKILL.md, references/ and scripts/ together.

Claude (web interface, desktop app, mobile app, Cowork): upload the .skill bundle via Settings → Customize (or put SKILL.md, references/ and scripts/ into one folder and zip that folder). The skill is then available in all chats and in Cowork tasks.

Claude Code: place the folder at .claude/skills/task-observer/ (project-level) or in your user-level skills directory, preserving the references/ and scripts/ subfolders.

Other systems: keep the folder structure intact wherever your platform expects skills, and let your AI guide you (see "How it works" above).

Claude environment notes

In Claude Cowork (including Dispatch) or Claude Code in the desktop app: Full experience. The observer writes observation logs to your filesystem, so improvements persist between sessions and can be actioned easily. Observations land in [your shared folder]/skill-observations/observation-log/, one small file each; proposed skill updates land in [your shared folder]/skill-updates/. Upgrading from a version before 3.0? The first session converts your old single-file log automatically (see the user guide). You don't normally need to look at these directly — Claude handles them — but they're there if you want to inspect what's been captured.

In Claude.ai web or Claude Chat in the desktop app / mobile app: Handoff doc mode. Since there's no filesystem access, the observer produces a structured handoff document at the end of your session that you can use to update your skills in a dedicated session.

Compatibility

Tested and designed for:

• Claude Cowork (full experience with filesystem access)
• Claude Dispatch
• Claude.ai web interface (handoff doc mode)
• Claude mobile app (handoff doc mode)
• Claude Code in the desktop app

Confirmed to work by users:

• Claude Code without desktop app — the methodology and format translate directly - plenty of users have reported seamless experiences with this.

Versions for other environments created by users:

• Codex version by AllstarGER: https://github.com/AllstarGER/one-skill-to-rule-them-all (based on an older version of task-observer)
• Please get in touch if you've open-sourced an adaptation of the meta-skill for another system or environment. I'm happy to include it here.

Potentially compatible with caveats:

• Other skills-compatible platforms (ChatGPT, Gemini CLI, Cursor, etc.) — the skill uses Claude-centric concepts like <available_skills> and skill-creator references that other systems would need to interpret or adapt. The SKILL.md format is cross-platform, but the content assumes Claude's architecture.
• Users have reported successful integrations into Openclaw and Hermes setups.

If you try it in another environment, please let me know how it goes. Issues and pull requests welcome.

Quick start

1. Read the user guide at https://github.com/rebelytics/one-skill-to-rule-them-all/blob/main/USER-GUIDE.md
2. Give the content of this repo (skill, readme and user guide) to the AI system of your choice and let it guide you towards the ideal configuration for your individual setup.
3. Make sure that the skill loads in all sessions where it's needed (I solved this via an instruction in my CLAUDE.md file).
4. Try to remember to ask "Any observations logged?" when you finish a session (I do this every time I archive a session). Sometimes, the skill then finds additional improvement potential that it didn't log before.
5. Schedule a recurring review session that applies all open observations. Mine runs Monday, Wednesday and Friday morning, but you should adapt this to your needs.

Contributing

This is an open-source project for the community. If you use it, I would love to hear from you:

• Bug reports and feature requests: Open an issue or a pull request, whichever you prefer — you are credited either way. See CONTRIBUTING.md for how reports become changes and how credit works.
• Platform compatibility reports: Tried it somewhere other than Claude? Tell me what happened.
• Interesting use cases: Have you come up with a creative way of using or improving Task Observer?
• Integrations with other systems: One user told me that they connected task observer to Obsidian. Do you have a similar story?