New advertisers: 50% off your first month with code FIRSTMONTHSee slots

Proactive skill checks inside live workflows, with a re-indexing skill and user-level installer.

version
0.5.0
GitHub stars
32
View on GitHub

What it does

  • Adds skill-or-not, reindex, go-out-then-in, and install-heuristic skills for skill-development habits
  • Runs a five-step checklist on each task: repeatable, automatable, already ours, already someone else's, else create
  • Orders skill and task work: task first by default, with skill writing delegated to a subagent
  • Installs the heuristic at user level into CLAUDE.md, AGENTS.md, GEMINI.md, QWEN.md, or opencode config, never per project

Proactive skill development inside a live workflow. Ask 'should this become a skill?' before every task: a five-step checklist (repeatable, automatable, already ours, already someone else's, else create and validate it), an order of operations when skill and task are asked for together (task first by default, writing delegated to a subagent), a reindex skill that makes a new skill available at once, a go-out-then-in skill (take private skills public as a generic plugin, then graft your details back as an overlay), plus an installer that puts the heuristic in your user-level CLAUDE.md / AGENTS.md.

Add marketplace

/plugin marketplace add danielrosehill/Claude-Code-Plugins

Run it inside Claude Code once, then install the plugin below.

Install

/plugin install skill-genie@danielrosehill

Run it inside Claude Code after adding the marketplace.

Files

Discovered from source

Go out, then in

Something built privately often turns out to be mostly reusable: the mechanics are generic, only the names, numbers, paths and preferences are personal. Going out then in splits it in two, so the generic part is shared and maintained once, and the private part shrinks to a thin overlay.

Out: extract the generic part into a public plugin with no personal details. Publish: release and list it. In: put the user's details into an overlay the public plugin reads, and strip the moved parts out of the private original.

0. Read the user's procedure

Resolve the skill-genie data folder as in reindex ($SKILL_GENIE_HOME, $CLAUDE_USER_DATA/skill-genie/, ~/.claude-user-data/skill-genie/). If it holds go-out-then-in.md, follow it: it names the user's marketplaces, release rules, sync route and private-overlay location, and wins over the defaults below.

1. Split: what goes out, what stays in

Read every skill, command and script in the private source. Sort each into:

Goes out (generic)Stays in (private)
Mechanics: API calls, endpoints, verification, ordering, failure modesNames, phone numbers, emails, chat/account ids, hosts, LAN URLs, file paths
Safety rules that apply to anyone (rate limits, ban risk, approval defaults)Relationship rules, voice/tone, per-person policies
Validated facts about the tool (versions, quirks), datedAnything about specific people, even as an example

A skill that is mostly personal stays private whole; a skill that is mostly generic moves. Where one skill mixes both, the generic version moves and the private one keeps only the delta (or is replaced by the overlay entirely).

2. Design the overlay before writing

The public plugin must work for a stranger and for the user without edits. If the user follows the Public Plugin, Private Overlay standard (plugin public-private-overlay), its folder rules, secrets rule and "no parallel private fork" rule govern this step; its audit-plugins skill is the check afterwards. Give the plugin:

  • A profile/overlay format documented in the plugin (references/profile.md or similar): every value the skills need that is personal (identity, tool/server name, local conventions, routes to other tools such as "how to save a contact", "how to stage a file", "where to log").
  • A lookup order: an env var, then $CLAUDE_USER_DATA/<plugin>/, then ~/.claude-user-data/<plugin>/, then a memory/context record for hosted clients with no local files.
  • Several profiles when more than one person or account may use it, chosen by name or default: true.
  • A no-profile path: ask for the two or three essential values, do the task, offer to save the profile.

Routes to the user's other private tools go in the overlay as plain text ("skill X", "script Y"), not as hard dependencies in the plugin.

3. Write it out

  • New repo, public, named at maximum specificity, MIT unless the user says otherwise.
  • History tripwire: never make an existing private repo public without checking its history. Flipping visibility (or reusing a private repo, including an empty-looking placeholder) publishes every past commit, not just the current tree. Run the leak check below over the whole history (git log -p --all, plus commit messages and author emails), not just the working tree. Clean (or zero commits): flipping it is fine. Any private detail or PII in history: don't rewrite history. Create a fresh public repo with clean content, delete the private one (confirm with the user first; it's deletion), then bring the public one back in as usual. Same if the private repo has forks or old releases.
  • Rewrite rather than copy-and-scrub: copied text drags personal examples along. Use neutral examples (Alex, Acme Hardware, 15551234567).
  • Keep dated validation notes ("verified 2026-11-17 on version X"), minus personal ids.
  • README: what it does, requirements, setup (the profile), cautions, and a History line saying where it came from.
  • A short CLAUDE.md that forbids personal details in the repo.
  • Leak check before the first push: grep the repo for the user's name, partner's and contacts' names, phone numbers, email domains, hostnames, private IPs and home paths. Zero hits, or fix first. A pushed leak in a public repo is permanent.

4. Publish

Push, cut the first release per the user's versioning rule, add the marketplace entry (and changelog/catalogue steps the marketplace requires), then make it discoverable now (reindex). For a plugin new to a marketplace, a full re-sync may be needed.

5. Come back in

  1. Write the user's profile(s) in their private data area, with every value from step 2: real ids, aliases, routes to their private skills, and a pointer to the private plugin for the rules that stayed in. Commit only that file if the area is a shared repo.
  2. Strip the moved skills from the private plugin. In its README, say which public plugin now holds them and that the profile carries the details. Update cross-references in the remaining private skills to the new public names.
  3. Bump the private plugin's version and its marketplace entry; re-index both plugins.
  4. If the private plugin is now empty or near-empty, fold the remainder into the profile and retire it (the user's consolidation procedure applies, if they have one).

6. Verify

  • Catalogue/plugin listing shows the public plugin with every moved skill, and the private one without them.
  • Reading a public skill as served contains no personal detail.
  • Run one real task through the public skill with the user's profile and confirm it behaves as the private skill did.

Report

Public repo and release, marketplace, skills moved, profile path(s), what stayed private and why, leak check result.


First worked through 2026-11-17: a private personal-WhatsApp plugin's send, new-number, group, archive and health skills went out as a public WAHA plugin with per-account profiles, so a second household member could use the same skills on their own account.

Readme

Skill Genie

Proactive skill development that fits a live workflow. A user-level heuristic for AI agents: before starting a task, ask whether it should become a skill, and when the skill and the task are asked for together, do them in a sensible order.

Formerly To-Skill-Or-Not-To-Skill (renamed 2026-11-13; the old GitHub URL redirects).

Skills and plugins are defined patterns of work, and their value is cumulative. The current pace of AI development is chaotic partly because there is so much to define. Workflows are being written for the first time on top of tooling that, until recently, did not exist. Agents are now very good at writing skills and plugins themselves, so it costs little to ship the workflow you need. The leverage is in noticing that a task should be captured at all.

This repo gives you that habit in four forms:

  • a snippet for the user-level instruction file of whatever agent you use (CLAUDE.md, AGENTS.md, GEMINI.md, …), so the lens is always on;
  • a skill, reindex, that makes a newly written skill available at once;
  • a skill, go-out-then-in, that takes private skills public as a generic plugin, then grafts your own details back on as a profile overlay (optional private procedure: go-out-then-in.md in the same data folder as reindex.md);
  • a skill, skill-or-not, that runs the full checklist on demand ("I think this is replicable, run the checklist");
  • an installer that propagates the snippet into every agent you have.

The heuristic

For every task:

  1. Is it repeatable? The shape of the task often answers this. When it doesn't, check history: memory, past sessions, shell history, the repo.
  2. Can it be automated or assisted with tools available now? That means MCP, APIs, browser use, the shell, or written guidance. Partial automation counts, and the bar for yes is deliberately low.
  3. Is it already in our library? In theory, skill discovery makes this step moot, because a relevant skill should surface on its own. In practice, search before you conclude it is missing.
  4. Has someone else written it? If a third-party skill fits as-is, add it to your third-party collection as a pointer to the upstream. If it is close, use it as the base for your own.
  5. Otherwise, create it. Add it to your public or private plugin, deploy it, and validate it by running the task you were about to do as a one-off.

A "no" at step 1 or 2 means you just do the task.

Skill and task together: order of operations

Often the request is "we need a skill for this, and also do X". There are three orders:

  1. Task, then skill (default). Do the task, then write the skill from the experience, pitfalls included. The risk is forgetting the skill, so the agent notes it up front and writes it before reporting the task as done, usually by handing a full brief of the run to a background subagent, so the live work carries on.
  2. Skill, then task. Write the skill while the request is fresh, force a re-index straight away (skill reindex), then do the task through the skill.
  3. Skill, task, update. Draft the skill, run the task through it, then update the skill with the delta: pitfalls, wrong turns, steps that differed.

When it can, the agent offers these as a menu with task-then-skill recommended. Otherwise it uses the default and says so.

Forcing a re-index: your own procedure

How a new skill becomes available depends entirely on your setup: a skills folder, a marketplace plugin, or a searchable catalogue. The reindex skill carries generic steps for each, but reads your own procedure first from a private overlay outside the plugin:

$SKILL_GENIE_HOME/reindex.md                 # or
$CLAUDE_USER_DATA/skill-genie/reindex.md     # or
~/.claude-user-data/skill-genie/reindex.md

Put the exact commands for your setup there (push, sync, verify, load in session). Your deployment details stay out of this public repo. If the file is missing, the skill offers to write it once the generic steps have worked.

The same text is a habit in Agent-Habits, which is its source. Use either one, not both.

The exact text injected into instruction files is in snippet/heuristic.md. The step-by-step version is in skills/skill-or-not/SKILL.md.

The setup it assumes

The heuristic pays off most with a library that is easy to add to and easy to search:

  • Several plugin collections ("marketplaces", although nothing is for sale):
    • a public one for everything that can be open-sourced;
    • a private one for skills that carry personal or business detail;
    • a third-party one that holds pointers to other people's plugins, pinned to a ref and never copied.
  • Progressive discovery of tools and skills, so the agent finds what is relevant without everything loading up front.
  • User-level configuration, so habits follow you into every project.
  • Federated access to tools through a single gateway, rather than per-project server lists.

Why user level, not project level

The heuristic governs how an agent works in general. It is not about any one codebase. In a project's CLAUDE.md it would apply only inside that repo, and every repo would need its own copy. The installer refuses any file inside a git work tree unless you pass --force.

Install

As a Claude Code plugin, from the danielrosehill marketplace:

/plugin marketplace add danielrosehill/Claude-Code-Plugins
/plugin install skill-genie@danielrosehill

Then inject the snippet at user level. You can ask the agent to "install the skill heuristic", which runs the install-heuristic skill, or run the installer yourself:

git clone https://github.com/danielrosehill/Skill-Genie
cd Skill-Genie
./install.sh --dry-run        # preview: every agent whose config dir exists
./install.sh                  # write it
./install.sh --list           # known agents and their user-level files
./install.sh --agent claude   # just one
./install.sh --remove         # take it out again
AgentUser-level file
Claude Code~/.claude/CLAUDE.md
Codex CLI~/.codex/AGENTS.md
Gemini CLI~/.gemini/GEMINI.md
Qwen Code~/.qwen/QWEN.md
opencode~/.config/opencode/AGENTS.md

For any other agent, pass --file PATH. The block sits between <!-- BEGIN skill-genie --> markers (blocks under the pre-rename to-skill-or-not-to-skill markers are replaced in place). Re-running the installer replaces the block in place, and the first write to an existing file leaves a .bak- copy.

Hook or skill?

Both work. The instruction-file snippet is the always-on version: the agent applies the lens to every task without being asked. The skill is the explicit version, run when you suspect a task is a candidate. A UserPromptSubmit hook could force the check on every prompt, but the snippet does the same job without the per-prompt overhead, so no hook ships here.

License

MIT

Details

Marketplace
danielrosehill/Claude-Code-Plugins
Source
danielrosehill/Skill-Genie
Author
Daniel Rosehill
Category
AI & Context
License
MIT

More from danielrosehill/Claude-Code-Plugins

All 264

Similar to skill-genie

More Memory & Context