Home / Repositories / rebelytics/one-skill-to-rule-them-all / installation

Installation guide

rebelytics/one-skill-to-rule-them-all installation guide

CC BY 4.0 Claude-oriented meta-skill that observes substantive work, records corrections and reusable workflow insights, proposes new or improved skills, propagates cross-cutting principles, and supports review-controlled updates without directly changing skills by default.

Repository overview GitHub

Install Task Observer for Claude Code on macOS Tahoe (Apple silicon)

What you are installing

**Repository:** [rebelytics/one-skill-to-rule-them-all](https://github.com/rebelytics/one-skill-to-rule-them-all/)

The installed skill is named **Task Observer**. It watches substantive, multi-step work sessions for reusable patterns, corrections, judgment calls, and gaps in existing skills. It records recommendations for you to review rather than directly changing your skills.

Claude Code classification

This repository is best classified as a **Claude Code Agent Skill that uses context injection and supports skill authoring/improvement**:

**Context injection:** Claude Code loads the instructions in `SKILL.md` when the skill is activated.
**Skill authoring:** the workflow identifies candidates for new skills and recommends improvements to existing skills.
**Installation mode:** a copied skill folder under `.claude/skills/`; it is not documented as a Claude Code marketplace plugin.

The supplied files do **not** document an MCP server, executable tool, background daemon, or Claude Code lifecycle hook. The skill mentions that a separate activation instruction or harness-level hook can improve reliability, but none is included as an installer here.

Compatibility notes for your Mac

The repository says the full experience is tested with **Claude Code in the desktop app**. Standalone Claude Code without the desktop app is described as expected to work but untested, with reported successful user experiences.

There are no first-party macOS Tahoe instructions, minimum Claude Code version, processor requirements, package-manager dependencies, or Apple-silicon-specific binaries in the supplied documentation. The skill itself is a Markdown bundle, so there is no documented difference between Apple silicon and Intel installation.

This guide therefore uses the repository’s documented **project-level** Claude Code location. The repository also mentions a user-level skills directory but does not provide its exact path, so this guide does not invent one.

Before you begin

You need:

1. Claude Code, preferably through the Claude desktop app because that is the tested configuration. 2. A persistent project folder where you use Claude Code. 3. The complete Task Observer bundle: - `SKILL.md` - `references/weekly-review.md` - `references/skill-authoring.md` - `references/environments.md`

Keep `SKILL.md` and `references/` together. Installing only `SKILL.md` is documented as a degraded installation: the core skill can continue, but it will report the missing references when they are needed.

Do not install the repository into a temporary checkout or a Claude worktree if you want observation history to persist. The skill warns that state stored under an ephemeral path such as `.claude/worktrees/` may disappear when that checkout is removed.

Recommended installation: download the ZIP

This method does not require Terminal commands.

1. Download the repository

Open [the repository on GitHub](https://github.com/rebelytics/one-skill-to-rule-them-all/).
Select the green **Code** button.
Select **Download ZIP**.
Open your Mac’s **Downloads** folder.
Double-click the downloaded ZIP if macOS has not already expanded it.

The extracted folder will normally have a name based on the repository and branch. Open it and confirm that you can see `SKILL.md` and a `references` folder.

2. Open your persistent Claude Code project

In Finder, open the project folder in which you want Task Observer available. This should be the stable project root, not a temporary clone or a folder inside `.claude/worktrees/`.

The documented destination, relative to that project root, is:

.claude/skills/task-observer/

If your project already has `.claude/skills/`, open it and create a folder named `task-observer` there. Hidden files can be shown in Finder with **Command–Shift–Period**.

If the hidden `.claude` hierarchy does not already exist, create the documented folder hierarchy using the project editor or file manager you normally use for Claude Code projects. No Terminal creation command is provided here because the repository does not publish one.

3. Copy the complete bundle

Copy these items from the extracted repository into `.claude/skills/task-observer/`:

SKILL.md
references/

Your finished layout must look like this:

[your project]/
└── .claude/
    └── skills/
        └── task-observer/
            ├── SKILL.md
            └── references/
                ├── environments.md
                ├── skill-authoring.md
                └── weekly-review.md

The repository may contain other files, including its README and Tessl metadata. They are not listed as part of the Claude Code skill bundle. The bundle manifest in `SKILL.md` consists of the one skill file and those three reference files.

Optional source-supported clone method

The repository explicitly allows cloning, and GitHub metadata supplies its HTTPS clone URL. If you already know how to use Git, you may clone the repository first:

git clone https://github.com/rebelytics/one-skill-to-rule-them-all.git

After cloning, use the same documented folder layout above: copy `SKILL.md` and `references/` together into your project’s `.claude/skills/task-observer/` folder. No additional install, build, or dependency command is documented.

Start Claude Code and verify the installation

Open the stable project in Claude Code. Begin a substantive, multi-step task and ask Claude whether the `task-observer` skill is available. You can also explicitly mention **Task Observer**, **skill observations**, or **One Skill to Rule Them All**, which are documented activation phrases.

A complete installation should allow the skill to load its reference files when needed:

setup or no-filesystem questions load `references/environments.md`;
creating or editing a skill loads `references/skill-authoring.md`;
a review loads `references/weekly-review.md`.

If Claude reports that one of these files is missing, return to the folder layout and copy the entire `references` directory again. Do not flatten it: the three files must remain inside the `references` subfolder.

The first active session may create persistent observation data, including:

skill-observations/log.md
skill-observations/last-review-date.txt
cross-cutting-principles.md

The repository says observations normally live in a persistent workspace and that proposed updates may use a `skill-updates/` folder. These are working data, not additional files you must download.

Improve activation reliability

The repository cautions that description matching alone is not enforceable. Its quick start recommends making sure the skill loads in every session where it is needed, using an instruction in `CLAUDE.md` as the author’s example. Exact activation wording is delegated to `references/environments.md`, which should be loaded for setup questions.

Because the supplied evidence does not include that reference file’s contents, this guide does not invent a `CLAUDE.md` instruction or hook configuration. After installation, ask Claude Code to open the installed `references/environments.md` and explain its repository-provided activation options before you change configuration.

Normal use

Work normally on substantive tasks. Task Observer is intended to stay active through execution, feedback, and reflection. It records corrections, reusable workflows, gaps, and possible simplifications. It should recommend changes rather than silently modify your skills.

The README suggests asking **“Any observations logged?”** near the end of a session. It also recommends a recurring review schedule, adjusted to your needs. The skill itself offers a review when open observations have never been reviewed or the last review is more than seven days old; it should not block your current task.

Read the repository’s [USER-GUIDE.md](https://github.com/rebelytics/one-skill-to-rule-them-all/blob/main/USER-GUIDE.md) for its first-party operating guidance.

Troubleshooting and boundaries

**Skill not found:** confirm the exact project-relative location is `.claude/skills/task-observer/SKILL.md`.
**Incomplete-install warning:** confirm all three named files are inside `task-observer/references/`.
**Observations disappear:** make sure the project and observation workspace are persistent, not a temporary clone or `.claude/worktrees/` checkout.
**Skill does not activate consistently:** consult the installed `references/environments.md`; the repository says an activation instruction may be needed.
**Standalone Claude Code issue:** remember that this mode is expected to work but is not listed as tested by the repository.
**Small skill library:** the author notes that built-in memory and direct edits may involve less overhead when you maintain only a few skills.

The repository is licensed under **CC BY 4.0**. If you adapt or redistribute it, give appropriate credit by linking to the original repository and naming **Eoghan Henn / rebelytics.com**.