Kno2gether kno2gether.com ↗ Try Knotie free
Playbook

Turn every finished build into a reusable Claude skill

The real IP of a one-person AI agency isn't the code you ship for one client — it's the skills Claude can rerun for the next one. Here's the meta-prompt that converts any finished build into a clean, standalone, reusable skill.

See how Knotie white-labels for you
01

The IP isn't the code — it's the skill

When you finish a client build, the temptation is to file away the code and move on. But the thing with real, compounding value isn't that one folder of code — it's the repeatable PROCESS you just figured out. This is the shift Albert Olgaard teaches for running a one-person business on Claude: you're not selling hours, you're compounding skills. Capture the process as a reusable Claude skill and your next client who needs the same thing is one slash command away — not a rebuild from scratch.
A Claude Code skill is a self-contained folder with a SKILL.md file. Personal skills live at ~/.claude/skills/<name>/ and are available across all your projects; project skills live at .claude/skills/<name>/ for that repo only. You invoke one directly with /skill-name.
02

Step 1 — Capture the build as a skill

The moment a build actually works, you've discovered a repeatable process. Don't let it evaporate. Have Claude write up the exact steps you just took as a skill: a folder with a SKILL.md describing what it does, when to use it, and the procedure.
  1. In the project where the build just worked, ask Claude to summarise the end-to-end procedure it followed (the commands, the order, the decisions).
  2. Have it write that as a SKILL.md inside a new folder named after the task (e.g. retell-agent-setup/SKILL.md).
  3. Keep the SKILL.md focused: a short description (so Claude knows WHEN to use it) + the step-by-step instructions (what to do).
Skills load their description into context so Claude knows what's available; the full body only loads when the skill is actually used — so a long procedure costs almost nothing until you need it.
03

Step 2 — Force it GENERIC (rule 1)

A raw capture bakes in THIS client. That's worthless on the next job — worse, it quietly runs the first client's settings on the second client's project. The fix: make the skill ASK for what's client-specific at run time instead of hardcoding it.
  • The skill should ask for the client's name, domain, and any IDs when it runs — never store api.acme.com or a client key inside it.
  • Replace every client-specific literal with a placeholder the skill prompts for (CLIENT_NAME, CLIENT_DOMAIN, etc.).
  • Quick test: read the SKILL.md and ask 'would this run correctly for a totally different client without edits?' If no, it's still too specific.
Generic is what turns a one-off into an asset. The skill should feel like a fill-in-the-blanks template, not a transcript of one job.
04

Step 3 — Demand STANDALONE (rule 2)

If the skill references paths back into the original project, it can't travel. A reusable skill has to run on its own folder, in any repo.
  • No absolute paths to the original project (e.g. /Users/you/clients/acme/...). Use relative paths or paths the skill resolves at runtime.
  • Bundle anything the skill needs inside its own folder; reference it via ${CLAUDE_SKILL_DIR} so it resolves whether the skill is installed at personal, project, or plugin level.
  • Move the folder to a fresh repo and run it. If it breaks, it had a hidden tie to the original project — fix that before you call it reusable.
Standalone is the difference between a skill you can drop into any client's repo and a snippet that only worked once, where it was born.
05

Step 4 — Install it once, reuse it forever

Put the finished skill where every project can see it, and your next client becomes a single command.
  1. Drop the skill folder in your personal skills directory: ~/.claude/skills/<name>/ — it's then available in every project on that machine.
  2. If the skills directory didn't exist when your session started, restart Claude Code once so it gets watched (edits to an existing skill hot-reload without a restart).
  3. Next client who needs the same thing: run /your-skill, answer the name/domain prompts, done — what took a day the first time now takes minutes.
  4. Commit project-specific skills into .claude/skills/ in the repo so your whole team (and future-you) inherits them.
Every finished build now leaves behind a tool that does the job again. After a few clients you have a LIBRARY of slash commands — that's the compounding.
06

The meta-prompt — paste this after any build

This is the SKILLIFY meta-prompt. Run it in the project where a build just succeeded; it converts that work into a clean, generic, standalone skill in one pass.
You just finished a working build in this project. Convert the exact
process you followed into a REUSABLE Claude Code skill, following these
rules strictly:

1. SUMMARISE the end-to-end procedure you actually used (commands,
   order, key decisions).
2. CREATE a skill folder named after the TASK (not this client) with a
   SKILL.md inside. SKILL.md = a short description (so you know WHEN to
   use it) + the step-by-step instructions.
3. MAKE IT GENERIC: find every value specific to THIS client (names,
   domains, IDs, keys, URLs) and replace each with a placeholder the
   skill ASKS the user for at run time. Hardcode nothing client-specific.
   List the inputs it will ask for at the top.
4. MAKE IT STANDALONE: remove every path reference back to this project.
   Use relative paths or ${CLAUDE_SKILL_DIR}. Bundle any files the skill
   needs inside its own folder.
5. ADD a 30-second self-test: how to confirm the skill runs correctly
   for a NEW client with no edits.
6. OUTPUT the full SKILL.md and the folder layout, ready to drop into
   ~/.claude/skills/.

Before you finish, re-read your SKILL.md and confirm: would this run for
a totally different client, in a different repo, with zero edits?
If not, fix it.
Save this. After every build that works, paste it once — and walk away with an asset instead of a memory.

Get the next drop

New AI build guides + the occasional bonus template. No spam, unsubscribe anytime.

By submitting you agree to our Privacy Policy & Terms. Unsubscribe anytime.

Frequently asked questions

Where do Claude Code skills live?
A skill is a folder with a SKILL.md. Personal skills go in ~/.claude/skills/<name>/ (available in all your projects); project skills go in .claude/skills/<name>/ (that repo only). You invoke one with /skill-name.
Do I have to restart Claude Code after adding a skill?
Editing an existing skill hot-reloads within the session. But if the skills directory didn't exist when the session started, restart once so Claude can watch it.
What makes a skill actually reusable?
Two things: GENERIC (it asks for client-specific values at runtime instead of hardcoding them) and STANDALONE (no path references back to the original project, so the folder travels to any repo).
Isn't this just saving snippets?
No — a snippet is tied to where it was born. A skill is a parameterised, standalone procedure Claude runs on demand with /name. That's the difference between a memory and an asset that compounds.

You're building a library of reusable skills. Knotie is the platform to sell what they produce — under your own brand.

Knotie is a white-label AI platform: resell voice agents, chat agents, and automations under your own brand and domain, with credit billing and your margin built in. Your skills make delivery fast; Knotie makes it a product you own. You bring the client relationship; Knotie powers the recurring offer.

See how Knotie white-labels for you