
skill-genie
Proactive skill checks inside live workflows, with a re-indexing skill and user-level installer.
- version
- 0.5.0
- GitHub stars
- 32
What it does
- Adds
skill-or-not,reindex,go-out-then-in, andinstall-heuristicskills 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-PluginsRun it inside Claude Code once, then install the plugin below.
Install
/plugin install skill-genie@danielrosehillRun it inside Claude Code after adding the marketplace.
Files
Discovered from sourceGo 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 modes | Names, 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), dated | Anything 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.mdor 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
- 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.
- 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.
- Bump the private plugin's version and its marketplace entry; re-index both plugins.
- 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.mdin the same data folder asreindex.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:
- Is it repeatable? The shape of the task often answers this. When it doesn't, check history: memory, past sessions, shell history, the repo.
- 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.
- 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.
- 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.
- 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:
- 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.
- 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. - 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
| Agent | User-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- skill-or-notv0.1.1
- skill-thisv0.7.0
- smart-homev1.0.0
- snap-itv0.1.0
- social-feedbackv1.1.2
- sop-writerv1.0.0
- spec-led-certificationv0.3.0
- spec-starterv1.0.0
- stack-evaluatorv0.1.1
- stack-searchv1.0.0
- start-herev0.1.0
- style-switcherv0.2.0
- sweetwaterv1.0.0
- synology-mgmtv1.0.0
- synthetic-datav1.0.0
- system-recovery-modev1.0.0
- task-queuerv1.1.0
- tasker-adbv1.0.0
- taxonomy-creationv1.0.0
- teach-this-repov1.1.1
- tech-comms-diagramsv2.1.0
- tech-docsv1.0.0
- tech-researchv1.0.0
- technical-docsv1.0.0
Similar to skill-genie
More Memory & Context
discernment-nudgeanthropics/skills196.9K starsAppends two or three short follow-up questions after a substantive answer to help users check key facts, probe the reasoning, and notice missing context
claude-memthedotmack/claude-mem118.9K starsPersistent memory for Claude Code: the next session starts where the last one left off.
agentdbruvnet/ruflo82.2K starsAgentDB (external: maintained in ruvnet/agentdb, pinned to commit 27678c3, plugin 3.6.0): agentdb's own standalone MCP server pinned to agentdb@3.6.0 (vector me
headroom-skillheadroomlabs-ai/headroom80.3K starsSkill: add headroom-ai compress() to a Python or TypeScript app to cut LLM input tokens (tool outputs, logs, JSON, chat history). No API key.
mem0mem0ai/mem069.2K starsCross-session memory and token savings for coding agents.
context7upstash/context765K starsUp-to-date documentation lookup. Pull version-specific documentation and code examples directly from source repositories into your coding agent's context.