Five skills that turn Claude Code into a team that gets smarter every session. This is the working operating system of a solo consultant who runs their whole business on it.
This is for solo operators and small teams who use Claude Code (or any Claude-based coding agent) for real, ongoing work: not a one-off script, but a business or a codebase you come back to every day.
This is not another memory tool. Plenty of those exist already, and they solve a narrower problem than the one that matters: memory alone doesn't make an agent behave better, it just makes it remember behaving the same.
This is also not a 300-skill catalog. Most public skill collections optimize for count, because the more skills a repo lists, the more impressive it looks. This repo optimizes for something else: a small, coherent philosophy about how an agent should communicate, plan, and execute. It comes as five skills, each distilled from a working practice that was used in production, most days, for months, before being published here.
The differentiator isn't cleverness. Every skill here distills practices pressure-tested by real, paid, external-facing work, not written speculatively and never run.
Managed install (recommended; update later with npx skills update, and add -g to install user-wide like the manual copy):
npx skills add cobuchan/compounding-operatorManual copy (if you'd rather own a snapshot and edit freely):
git clone https://github.com/cobuchan/compounding-operator.git
mkdir -p ~/.claude/skills
cp -r compounding-operator/skills/* ~/.claude/skills/Both paths are supported on purpose. The managed install is the right default for most people: it's one command, and updating later is one command too (npx skills update). It doesn't watch for changes on its own; nothing here installs a background updater. The manual copy exists for anyone who wants to fork a skill's exact wording and diverge from it immediately, without pulling in future changes they didn't ask for. Neither approach is wrong. Pick based on whether you want to track this repo or own a permanent copy.
Most agent setups forget between sessions. Every session starts from the same blank slate, re-explains the same context, and repeats the same mistakes, which means the tenth session with an agent costs about the same as the first. That's not compounding, it's just repetition.
The bet behind this repo is the opposite. An agent that captures what it learns gets measurably better to work with over time, and the sessions get cheaper, not just longer. What it needs to capture is concrete: how to explain things so they land, how to plan work so it stays traceable, and how to execute one piece at a time without losing the thread.
This isn't a thought experiment. These five skills are the ones actually running, today, behind a solo consulting practice. They get used for planning, for explaining decisions clearly, and for day-to-day execution, not assembled as a demo for a launch post. That's the one claim a repo written specifically to look good on GitHub can't make.
These are falsifiable, not vibes:
- Explanations arrive in a five-part shape (context, background, the issue, examples, a recommendation) without you having to ask for that shape every time.
- Long text you need to copy-paste lands in an opened file instead of getting mangled inside a chat code block.
- A new project boots with a scratchpad, a CLAUDE.md, and a docs structure in under a minute, instead of you re-explaining your conventions from scratch.
- PRD stories get executed one at a time, with acceptance criteria checked and implementation notes written, never silently batched or skipped.
If you install these and none of that happens, something's wrong: either the install, or how your agent is invoking the skill. That's a testable claim, not a marketing one.
Forces every explanation into a fixed five-part shape (context, background, the issue, examples, recommendation), pitched so a bright reader with zero project background can follow it.
This one exists because of a real problem with strong models. The author runs Claude's Fable tier daily, and the stronger the model, the more knowledge-dense its answers get: correct, high-altitude, and sometimes genuinely hard to follow. The skill counters that with two rules that do most of the work. Nothing gets referenced by a shorthand name the reader may not remember, and every technical term gets defined in the sentence where it first appears.
Use it when an agent proposes a decision you need to actually understand before approving it, when you're catching up on work that happened while you were away, or any time an answer reads correct but you couldn't repeat it back in your own words.
Turns requirements into structured, trackable stories: a dual-file format with a markdown narrative for humans and a JSON tracker for state, plus a complexity scale and an explicit completion checklist.
The background is a familiar failure. Feature requests handed to an agent as freeform prose lose requirements silently; three sessions later, nobody can say which parts actually shipped. Keeping status in a data file rather than in prose is what makes the difference, because prose drifts and JSON doesn't.
Use it for any piece of work with more than a few steps, for work that will span multiple sessions, or before delegating a feature across several agents.
The companion executor. Takes the next story from a PRD tracker and runs it end to end: dependency checks, the gates you declare, then the tracker update. One story at a time.
It exists because long backlogs tempt agents into exactly the wrong behavior, batching stories silently or skipping the ones that look done. Its hard rules were each learned from a real failure. The JSON-mutation safety rule, for example, is there because a careless shell pipeline once wiped a production tracker file.
Use it when you'd otherwise say "just do the rest of the backlog," when resuming a half-finished PRD in a fresh session, or when a story needs a verification or review gate actually enforced rather than promised.
Bootstraps a new project with a standard structure (CLAUDE.md, scratchpad, docs, git) in one pass.
Every project the author starts gets the same skeleton, and the reason is agent-shaped: an agent walking into an ad hoc directory has no idea what your conventions are, so you pay a re-explaining tax every session. A standard baseline means session one of a new project behaves like session fifty of an old one.
Use it when starting any new repo, or to retrofit a consistent structure onto a project you've inherited.
Writes anything you need to copy-paste to a file and opens it, instead of leaving it inside a chat code block.
Born from repeated small disasters: chat rendering silently corrupts exactly the text where precision matters most, things like regex literals, escaped quotes, and long wrapped lines. A browser DevTools one-liner that breaks when pasted is the classic case. A file round-trip costs two seconds and removes the whole failure class.
Use it for DevTools console pastes, shell commands with quoted JSON, or any prompt or snippet you're about to carry into another tool by hand.
A few one-liners that these skills all try to live by:
- Fight for objectives, not just rules. When a rule and the actual goal conflict, the goal wins.
- Context is precious. Don't make an agent (or a person) re-read what it already knows.
- Friction produces good outcomes. An agent that pushes back is more useful than one that just complies.
- A lesson that isn't captured didn't happen. If it isn't written down somewhere the next session will read, it will be relearned the hard way, again.
MIT licensed; see LICENSE.
Issues and discussions are welcome. If a skill doesn't trigger when you expect, or its instructions produced a bad result, open an issue. Improvement PRs to an existing skill are welcome too: tightened wording, a fixed edge case, a clearer example.
New-skill PRs are generally not accepted. This is a small, curated set on purpose, not a growing catalog. If you've built something good, publish your own repo. Genuinely, please do; a wider ecosystem of well-considered skill sets is the point.
Built and used daily by the founder of Eigo Pro, an AI consulting practice for compliance professionals. More on LinkedIn: linkedin.com/in/jacobsearing.