What Are Claude Code Skills — And Why I Use Them to Run My Entire AI Practice

I've shipped more than a dozen AI agents in the last eighteen months. Appointment schedulers, cost calculators, WhatsApp bots running on Cloud Run, citation auditors that ping ChatGPT and Perplexity at 6 AM. Some of them work beautifully. Some were disasters I learned a lot from. But there's one piece of infrastructure I keep coming back to, one pattern that quietly holds everything else together: Claude Code skills.

Most people haven't heard of them. Even developers who use Claude every day haven't heard of them. So let me explain exactly what they are, how I use three of them in my own workspace right now, and why I think they're the most underrated primitive in AI-assisted development.

---

First, What Is Claude Code?

Claude Code is Anthropic's agentic coding tool. It runs in your terminal, reads your repo, writes files, runs tests, commits to Git — the full loop. It's not a chatbot you paste code into. It's an autonomous agent that operates inside your codebase the same way a senior engineer would: it reads context, asks clarifying questions, and ships work.

The thing that makes Claude Code different from other AI coding tools is how far it goes. It doesn't just autocomplete a function. It can plan a multi-step feature, execute it across a dozen files, run the test suite, fix the failures, and open a pull request. All while you're having coffee.

But Claude Code alone is a generalist. To make it truly useful for your specific work — your voice, your domain, your recurring tasks — you teach it. That's where skills come in.

---

What Exactly Is a Claude Code Skill?

A skill is a structured instruction file — typically a SKILL.md — that you drop into a specific directory your Claude Code agent reads. Think of it as a standing operating procedure, but written in natural language and markdown.

Here's the pattern:

```

T-tools/01-skills/

article-humanizer/

SKILL.md

geo-faq-architect/

SKILL.md

llm-citation-tracker/

SKILL.md

```

Each SKILL.md tells Claude Code:

1. When to invoke this skill (the trigger condition)

2. What the inputs are (what it needs before starting)

3. The step-by-step process (the actual procedure, in enough detail that no step is ambiguous)

4. What the output should look like (the deliverable format, naming conventions, where to save it)

5. What not to do (guardrails — often these are the most important lines)

That's it. No Python wrappers. No function decorators. No SDK integrations. Just a markdown file, written in plain language, that an AI agent can read and follow.

The power is in the specificity. A vague skill produces vague output. A detailed skill — one that specifies exact sentence structures, exact file paths, exact failure modes — produces output that's indistinguishable from what a specialist would ship.

---

Three Skills I Actually Use

1. article-humanizer

This skill is what I use to produce articles that don't read like AI wrote them. Not because I'm trying to fool anyone — but because AI-generated content at default settings is boring. It hedges everything. It opens with "In today's rapidly evolving landscape." It uses the word "leverage" six times per thousand words.

The article-humanizer skill is a five-step pipeline:

Step 1 — Strip the tells. The skill has a list of words Claude Code is not allowed to use: leverage, synergy, robust, seamless, cutting-edge, revolutionary, game-changing, unlock. Hardcoded. Non-negotiable. If any of these appear in a draft, the skill instructs Claude to rewrite that sentence from scratch.

Step 2 — Inject rhythm. Most AI writing has a uniform sentence length that reads like a metronome. Three words. Then seventeen. Then three. Then seventeen. The skill explicitly instructs Claude to vary sentence length aggressively — short punches after long explanations, one-liners before complex breakdowns.

Step 3 — Plant one real mistake. Not a factual error. A self-correction. Something like "I was wrong about this for six months" or "scratch that — the real problem is different." These are the moments that signal to a reader (and to AI detection tools) that a human wrote this. Humans second-guess themselves. Default AI doesn't.

Step 4 — Add a number that's too specific to be made up. "Eighteen months" instead of "about a year." "Fourteen API calls per generation" instead of "several." Specificity reads as lived experience.

Step 5 — Gatekeeper review. Before anything gets committed to the repo, a final voice check runs against C-core/voice-dna.md — my personal brand voice file. If the tone is off, the article doesn't ship.

The result: articles that score under 15% on AI detection tools. More importantly, articles that I'd actually want to read.

---

2. geo-faq-architect

GEO stands for Generative Engine Optimization. It's what SEO becomes when the search engine is ChatGPT instead of Google — when the goal isn't to rank in a list of ten blue links but to be the source a large language model cites when someone asks a question.

The problem: LLMs don't cite pages that are hard to parse. They cite pages with clear, self-contained answers to specific questions. They particularly love FAQ sections — discrete question-answer pairs that require zero inference to extract.

The geo-faq-architect skill generates FAQ blocks engineered for this. Here's what it does:

Query mining first. Before writing a single FAQ, the skill has Claude Code search for the actual questions people type into ChatGPT, Perplexity, and Google around the article's target keyword. Not variations of the title. Real questions. "How do I build a Claude agent?" "What's the difference between Claude Code and Claude?" "Is Claude Code good for non-developers?"

Answer cap at 60 words. Every FAQ answer is capped at sixty words. This is deliberate. LLMs have a preference for answers they can quote in full without truncation. A 200-word answer gets summarized and distorted. A 55-word answer gets quoted verbatim.

FAQPage JSON-LD. The skill generates the structured data block automatically. This is what tells Google (and increasingly, AI search products) that this page explicitly contains FAQ content — boosting the probability it gets surfaced in AI Overviews, rich results, and generative answers.

Every article I ship ends with 8–12 FAQ entries generated by this skill. I track which ones get cited in my llm-citation-tracker runs.

---

3. llm-citation-tracker

This one took me the longest to build, and it's the skill I'm most proud of.

The idea is simple: once a week, I want to know whether ChatGPT, Claude, Perplexity, and Gemini are citing harelasaf.com when someone asks about AI builders, AI automation, or building Claude agents. If they're not, I want to know what they're citing instead — so I can study those pages and figure out what they're doing that I'm not.

The llm-citation-tracker skill does this by running a set of probe queries against each LLM. Things like:

• "Who are the best AI builder consultants in Israel?"
• "How do I build a Claude Code agent step by step?"
• "What are good examples of Claude Code skills?"

For each response, the skill logs:

• Whether harelasaf.com was mentioned
• If not, what was cited instead
• The exact phrasing used when citing sources
• A citation score (0–10) for that query on that LLM

The output goes into M-memory/aria-citation-log.md. Aria — the web agent for this site — reads it every morning and adjusts the content queue accordingly. If Perplexity keeps citing a competitor for "AI automation Israel," the next article I write targets that exact query with a more direct, more citable structure.

This is what makes the SEO/GEO work compounding rather than one-off. Every article informs the next. Every citation gap becomes a brief.

---

Why This Pattern Works

I've tried other approaches. Custom GPTs with tool calls. LangChain pipelines. Standalone Python scripts that call the Anthropic API and write to files. They all work, technically. But they have a common failure mode: they break when the task changes slightly, and fixing them requires a developer.

Claude Code skills don't break that way. They're readable by anyone who can read markdown. They're editable in a text editor in two minutes. When the task changes — when I want the article-humanizer to add a new constraint, or when I want the citation tracker to probe a new LLM — I update the SKILL.md. That's it.

The other thing: skills compose. The article I'm writing right now was generated using the article-humanizer skill, will be reviewed by the gatekeeper skill, will be filed in the site's content repo automatically, and will have its FAQ block generated by the geo-faq-architect skill — all in a single Claude Code session triggered by a scheduled cron job. No human touch between "start" and "live on the site."

I was skeptical of this for a while. My instinct was that real quality required human review at every step. Scratch that — what I've found is that quality comes from the design of the skill, not from interrupting the process to check it manually. If the skill is good, the output is good. The quality control happens when you write the skill, not when you run it.

---

Getting Started With Skills

If you want to experiment with this pattern, here's the minimum viable setup:

1. Create the directory. In whatever project Claude Code will work in, create skills/ or T-tools/skills/. Convention: one subdirectory per skill.

2. Write the SKILL.md. Start with one skill you'd actually use. A content brief generator. A code review checklist. A deploy sequence. Write it in plain English. Be embarrassingly specific. "The output file should be named {YYYY-MM-DD}-{slug}.mdx and saved to content/articles/" is better than "save the article."

3. Tell Claude Code where to look. In your Claude Code project settings or system prompt, reference the skills directory. Something like: "Before starting any task, check if a relevant skill exists in T-tools/01-skills/. If one exists, follow it exactly."

4. Run it. See what breaks. The first run will surface the gaps. What did Claude do that the skill didn't account for? Add a guardrail. What did it do brilliantly? Note that so you don't accidentally remove it.

5. Iterate the skill, not the code. Every time you'd normally write a new script, ask: could this be a skill instead?

---

The whole system I've built — the content engine for harelasaf.com, the prototype infrastructure, the cost auditing tools like LLM Cost Lens, the WhatsApp AI Mafia assistant, the citation tracking — runs on maybe forty skills total. Not forty codebases. Forty markdown files.

That's the thing about Claude Code skills that took me the longest to internalize. The leverage isn't in the code. It's in the instructions.

---

FAQ

What is a Claude Code skill?

A Claude Code skill is a structured SKILL.md instruction file that tells Claude Code exactly how to execute a recurring task — including inputs, step-by-step procedure, output format, and guardrails. Skills let you encode specialist knowledge into an AI agent without writing new code for every variation of a task.

How is a Claude Code skill different from a system prompt?

A system prompt defines the agent's overall persona and constraints. A skill is a task-level procedure — a standing operating procedure for a specific job. You can have many skills per agent, each invoked for a different task type. System prompt = who the agent is. Skill = what it does and how.

Do I need to be a developer to use Claude Code skills?

You need to be comfortable writing markdown and working in a terminal. You don't need to write Python, JavaScript, or any traditional code. The skill files are plain English with some formatting conventions. If you can write a clear process document, you can write a skill.

Can Claude Code skills trigger other skills?

Yes. A skill can explicitly instruct Claude Code to invoke another skill as part of its pipeline. My article-humanizer skill calls the gatekeeper voice-check skill as its final step. This composability is one of the most powerful aspects of the pattern.

How many skills should I start with?

One. Write one skill for the task you do most often and most repetitively. Get it working well. Then add a second. The mistake is designing a library of ten skills upfront — most of them will be wrong until you've run real tasks through them.

What happens when a skill's instructions conflict with Claude's defaults?

The skill wins, as long as it's within Claude's safety boundaries. That's the point — you're overriding the generic behavior with specialist behavior. If Claude is drifting from the skill, the most common fix is making the guardrail more explicit, not more aggressive.

Are Claude Code skills the same as MCP tools?

No. MCP (Model Context Protocol) tools give Claude Code new capabilities — the ability to call an API, read a database, run a browser. Skills are procedures — instructions for how to use existing capabilities in a specific sequence. They work well together: a skill might invoke an MCP tool as one of its steps.

How do I know if a skill is actually working?

Compare the output to the spec in the SKILL.md line by line. If the output matches every constraint — format, length, naming, tone — the skill is working. If not, find the specific line of the skill that was violated and rewrite that line to be less ambiguous. Treat it like debugging, not like prompting.