P
PROMPT_ENG
MODULE 02

CUSTOM SKILLS

Extend Claude Code with reusable skills that encode domain expertise, workflows, and best practices for journalism.

MODULE 02

This module is locked

Unlocks Sunday, April 19 at 5:00 PM ET.

Check back then, or visit your course on the Knight Center LMS.

Back to home
ERRATUM

Skill file location — .claude/skills/, not .claude/commands/

Module 2 materials use skill and custom slash command somewhat interchangeably, but in current Claude Code they live in different folders and work differently:

  • Custom slash commands: .claude/commands/ (project) or ~/.claude/commands/ (personal). Typed by you as /name.
  • Skills: .claude/skills/ (project) or ~/.claude/skills/ (personal), as folders containing a SKILL.md with YAML frontmatter. Claude reads the description and invokes a skill when a task matches. Plugin-installed skills may also expose a slash command.

Question 1 of the Module 2 quiz and the slide at 1:26 in Video 2 point to the wrong folder for skills — the quiz is being corrected on the Knight Center side, and the slide clip will be re-recorded before the next run of the course. For the full skills vs. commands breakdown, see the concepts page.

Learning objectives

  • > Explain the prompt-to-skill progression — how a raw prompt becomes a saved prompt, then a custom slash command, and finally a hook
  • > Create a custom slash command by saving a reusable prompt as a file in .claude/commands/
  • > Understand the difference between notify hooks (flag issues, keep going) and stop hooks (pause before irreversible actions)
  • > Use session commands — /help, /plan, /compact, and /clear — to manage Claude Code sessions
  • > Install and use journalism skills from GitHub using the skills repository

Before you start

In Module 1, you learned to write good prompts and give Claude persistent context. But every time you started a new session, you typed the same instructions from scratch. This week, you learn to save those prompts as permanent, reusable tools. The key insight: write it once, use it forever. The concepts below explain skills, commands, hooks, and the progression from ad-hoc prompt to automated workflow.

Read: skills vs. commands — when to use each → Read: hooks as guardrails — enforcing standards automatically → Read: error logging — turning corrections into lasting improvements →

Watch

Skills, commands, plugins, hooks

Joe opens Module 2 by defining skills, plugins, and hooks — markdown files that load only when called, packaged bundles of those files, and automatic guardrails that fire on keywords. Then he runs a live end-to-end demo: scraping every recent video from NYC Mayor Zohran Mamdani's YouTube, TikTok, Twitter, Instagram, and Facebook, transcribing them with Whisper, OCR'ing frames, and generating an analysis dashboard — all in roughly two hours on one machine.

TOPICS COVERED

Skills are just markdown
Plain-language instructions that only load when invoked. No code, no tokens wasted unless the task is relevant
Plugins bundle skills
A collection of related skills packaged together — shareable, installable, editable at skills.amditis.tech
Hooks as guardrails
Automatic triggers for keywords or contexts. The one-way door hook saves you from irreversible decisions before you make them
The Mamdani scrape
Single prompt, five platforms, 76 videos pulled at full resolution without watermarks — impossible in the browser
Sub-agent driven development
Superpowers plugin dispatches a fresh agent per task. Reviews happen between steps, work tree enforces dependencies
Dashboard from one prompt
Front-end design skill auto-triggers and scaffolds the analysis dashboard while transcription runs on your GPU in parallel

KEY TAKEAWAYS

  • ›Skills only cost tokens when they're relevant. Unlike MCPs, which load into every conversation at the start, skills sit on disk until something in the task triggers them. That means you can have dozens of specialized guardrails and workflows available without bloating every prompt.
  • ›The browser can't do this. Joe pulled 76 full-resolution videos across five platforms, ran Whisper transcription on a local GPU, sampled frames for OCR, and built an interactive dashboard — all from one prompt with occasional nudges. You cannot get a web chat window to touch your files, your GPU, or your browser profile the way the terminal agent can.
  • ›Stop hooks and ask-user-question beat raw prompts. When the task was complex, the brainstorming skill fired, which uses ask-user-question to interview Joe about purpose, sampling rate, model size, and output format before writing a single file. That interview catches misalignment up front instead of debugging it three hours in.
  • ›Build skills to make one-time workflows repeatable. After the Mamdani run worked, the move is to codify what you learned — the video download flow, the Whisper config, the dashboard layout — as a skill so the next subject (any politician, any beat) runs the same pipeline automatically.

TIMESTAMPS

00:00Module 2 intro and guest lecturer Reese
01:13What is a skill, what is a plugin
03:40Hooks and the one-way door pattern
05:59Skill vs command vs plugin recap
07:28The Mamdani social media task
09:04Launching Claude Code with --dangerously-skip-permissions
11:34Brainstorming skill fires, ask-user-question interview
17:53Sub-agent driven development plan
21:33Twitter, Instagram, Facebook fail — switching to browser automation
26:2876 videos downloaded, moving to transcription
28:02Whisper large crashes OBS, switching to turbo model
33:48Reviewing the dashboard output and noting fixes

Installing and using journalism skills

Joe takes the working Mamdani pipeline and turns it into a reusable Claude Code plugin — four modular skills plus a plugin.json, an index page, and an SVG-animated docs site — all generated by the agent using Anthropic's official plugin development skills. Then he debugs the one gotcha (wrong install path), tests that the slash commands actually show up, and hands off the module assignment.

TOPICS COVERED

Modular vs monolithic
Four small skills that chain together beat one giant orchestrator. You can call just the parts you need on future projects
Plugin structure
plugin.json, a skill.md per capability, helper scripts in subfolders — all generated by the plugin development skill
Docs page with SVG
Plugin ships with an index.html that explains what each skill does, with animations, for the next person who installs it
Reload plugins trap
The skill was created at the wrong path (.claude-plugins instead of .claude/plugins). Restart and reload-plugins didn't fix it — reinstall did
Verify before claiming done
Type a forward slash, confirm the commands show up, run one end to end. "I did it" without a test run is not done
Shareable as a proper plugin
Bundled with versioning so colleagues can install it, fork it, and swap their own defaults without rewriting the pipeline

KEY TAKEAWAYS

  • ›There is no secret sauce. Joe's whole pitch in this video is that turning a working workflow into a skill is as simple as saying "let's save this for later" after you've confirmed it works. The bot already has plugin development skills from Anthropic baked in and knows the file layout — your job is describing what was useful and testing that the commands load.
  • ›Modular skills beat one big orchestrator. Joe started leaning toward a hybrid — one orchestrator with four stage skills — but switched to pure modular. The reason: you want to pull individual pieces (video download, transcribe, frame extract, dashboard) into projects that don't need the whole pipeline.
  • ›Even the plugin-creator misfires. Claude wrote the plugin to the wrong directory on the first try. Reload-plugins didn't catch it, quitting and resuming didn't catch it — Joe had to paste the docs and tell the agent to use the proper install method. This is why you test.
  • ›Use these tools to build things that don't need these tools. The output of this video is a Python pipeline and an HTML dashboard. Once built, it runs on its own. The AI was the means of constructing it, not a runtime dependency for executing it.

TIMESTAMPS

00:00No secret sauce — just describe what you want
00:27Picking which pipeline pieces to turn into skills
00:55Modular vs one orchestrator, project-local vs global
01:52Proper plugin vs loose skill files
02:15Plugin development skill takes over
04:02Skills.md files being written
05:41Video dashboard skill auto-generates a docs page
06:43Testing the plugin — slash commands not showing
09:11Wrong install path — fixing and retesting
10:27Skills load, running the first command
11:18Module assignment and skills.amditis.tech

Key concepts

The prompt-to-skill progression

Most people start by typing the same instructions over and over. The videos this week show skills in the context of a full CLI workflow — and the progression from a one-time workflow to reusable tools:

  • > Ad-hoc prompt — You type instructions each time. Works, but slow and inconsistent.
  • > Saved prompt — You save that prompt in a document so you can copy-paste it. Better, but still manual.
  • > Custom slash command — You save the prompt as a file in .claude/commands/, and Claude Code loads it when you type the slash command. Consistent and shareable.
  • > Hook — An automated check that runs in the background. No invocation needed — it fires on its own when certain conditions are met.

Skills vs. commands

Both are markdown, but they live in different folders and fire differently. A skill contains domain knowledge Claude consults and applies using judgment — Claude reads the skill's description and invokes it when a task matches. A custom slash command is a deterministic trigger you type yourself — the same steps, the same sequence, every time. The journalism analogy: a skill is a style guide (reference material, applied with judgment). A command is a mandatory pre-publication checklist (fixed sequence, no skips).

Custom slash commands are single .md files in .claude/commands/ — the filename becomes the slash (source-check.md → /source-check). Skills are folders in .claude/skills/ containing a SKILL.md with YAML frontmatter. Plugin-installed skills (like /source-verification from the journalism-skills plugin) also expose a slash command so you can call them directly.

Where skills live

Skills are stored in several locations:

  • > Personal: ~/.claude/skills/ - Available in all your projects
  • > Project: .claude/skills/ - Available only in that project, can be checked into the repo
  • > Plugin: installed via /install-github-plugin, bundled with related skills and hooks

Custom slash commands are different — those live in .claude/commands/ (project) or ~/.claude/commands/ (personal). The Module 2 exercise uses that folder because Part 1 has you build a custom slash command.

Hooks: notify vs. stop

Hooks are event-driven rules configured in settings.json. They fire automatically at specific points in your workflow — before a tool runs, after a session starts, when a file is written — without any input from you. There are two kinds, and the distinction matters:

  • > Notify hooks run in the background and flag issues without stopping your work. Think of them as an automated second reader — problems get marked for your review, but the work continues. A notify hook might flag an unattributed quote or highlight filler language.
  • > Stop hooks pause execution and ask for confirmation before proceeding. These exist for one-way doors — actions that are difficult or impossible to undo. Before Claude Code deletes files, pushes to a repository, or publishes something, a stop hook can pause and require your approval.

The journalism parallel: editorial workflows don't just catch errors, they build in deliberate pause points before irreversible actions. A stop hook is the automated version of "does a human need to see this before it goes out?"

Skill trust and safety

Skills are just text files with instructions — they can't run arbitrary code. However, they can influence Claude's behavior, so review skills before installing them. Prefer skills from trusted sources, check what instructions they contain, and be cautious of skills that ask Claude to access external services or sensitive data.

Session commands

Module 1 introduced the commands you use inside a Claude Code session. Here's a quick reference for the ones you'll use most this week:

  • /help — list available slash commands, including the one you build this week
  • /plan — ask Claude to think through an approach before acting (useful before writing a command or skill file)
  • /compact — compress conversation history when a long session slows down
  • /clear — start fresh without leaving the session

When CLI tools are worth the setup cost

Not every task justifies leaving the browser. CLI tools pay off when you have repeatable work — the same kind of document, the same verification steps, the same data format — and the upfront cost of writing a skill or context file is recovered across many uses. If you're doing a one-off task you'll never repeat, the web interface is fine.

The question to ask: "Will I do this same thing next week?" If yes, the time you spend writing a skill now saves time every future run. If no, a browser prompt is faster. Skills, context files, and hooks are investments — they only pay off with repetition.

EXERCISE

GOAL: Build your own custom slash command for a task on your beat, install the journalism skills repository, and use source-verification to check a viral claim. The exercise follows the same progression shown in the video: ad-hoc prompt to saved command to tested tool.

Part 1: Build your own custom slash command

~20 minutes

01 Choose a task

Pick one thing you do repeatedly that involves a consistent process — not a one-off question, but something with steps you follow every time. The video used a social media content analysis pipeline as its example, but your task can be much simpler — it just needs to be specific to your work.

Good candidates:

  • > Reviewing a specific type of document (press releases, budget reports, public records)
  • > Drafting a recurring story format (meeting recap, weekly data brief)
  • > Checking a specific category of claim (health statistics, crime data, budget numbers)
  • > Extracting structured information from a specific source format

Not good candidates: "Summarize text" (too generic) or "Be thorough" (not a process, not checkable).

02 Plan the skill before writing it

Open your terminal and launch Claude Code, then use plan mode to think through the structure before writing anything:

terminal 
claude
claude code 
/plan

I want to create a custom slash command called [your-command-name]. Here's what it should do:
[describe the task and the steps in plain English]

Plan out the structure of this command file — what sections it will have, what steps it will include, what instructions you'd put in each section. Don't write the file yet.

Review the plan. Are the steps in the right order? Is anything missing? Is anything too generic? Redirect here if needed. Once the plan looks right, tell Claude to proceed.

03 Write and test the command

Tell Claude to write the file based on the plan:

claude code 
Go ahead and write the command file based on that plan. Save it to .claude/commands/[your-command-name].md

Review what Claude writes. Apply the deletion test: read each instruction and ask whether removing it would change Claude's behavior. Cut anything that wouldn't.

Test on material you already know. Use a press release you already fact-checked, a council vote you already looked up, notes from a meeting you attended. Compare what the command produces against what you found yourself. If it misses something you caught, add that instruction. If it flags something that wasn't a problem, cut or refine it.

04 Commit it

Once you're satisfied with the command, commit it to your beat project repository:

claude code 
Commit this command file to my beat project with a message describing what it does

Your first custom slash command is now versioned alongside your project context.

Part 2: Install the journalism skills

~15 minutes

05 Install the skills repository

The journalism skills repository (36 skills, 13 hooks) can be installed as a Claude Code plugin. In your Claude Code session:

claude code 
/install-github-plugin https://github.com/jamditis/claude-skills-journalism.git

Verify the installation by typing /source-verification — you should see Claude acknowledge the skill.

Take a minute to look at a skill file and a hook file in the repository. Notice the structure: YAML frontmatter, step-by-step instructions, and whether a hook is notify (flags and continues) or stop (pauses for confirmation).

Part 3: Use source-verification on a viral claim

~20 minutes

06 Verify a viral claim

A post is circulating on social media with this claim:

"A new study from Harvard Medical School found that drinking coffee before 8am increases cortisol levels by 400%, leading to long-term adrenal fatigue. Doctors are now recommending waiting until 10am for your first cup."

Invoke the skill and provide the claim:

claude code 
/source-verification

Claim to verify: "A new study from Harvard Medical School found that drinking coffee before 8am increases cortisol levels by 400%, leading to long-term adrenal fatigue. Doctors are now recommending waiting until 10am for your first cup."

Follow the SIFT process Claude walks you through: Stop (note your assumptions), Investigate the source (is there an actual Harvard study?), Find better coverage (what do fact-checkers and medical journalists say?), and Trace claims (where does the "400%" figure come from? Is "adrenal fatigue" a recognized medical condition?).

07 Document your findings

As you work through the verification, Claude will help you document what evidence supports or contradicts the claim, which parts are accurate vs. misleading vs. false, what the original source actually said (if it exists), and a summary suitable for editorial decision-making.

Checkpoint

Self-check: Make sure you can answer these before moving on.

  • ? What are the four levels of the prompt-to-skill progression, and when is each one appropriate?
  • ? What is the difference between a notify hook and a stop hook?
  • ? What does the filename of a command file determine, and where does the file need to be saved?
  • ? What do /plan and /compact do inside a Claude Code session?

Resources

  • [REQUIRED] The complete guide to building skills for Claude (PDF) — Anthropic's official skill specification and best practices
  • [DOCS] Claude Code documentation - Official guide to skills and commands
  • [ORG] International Fact-Checking Network - Standards and resources for verification
  • [GUIDE] First Draft: verifying online information — the essentials
  • [GUIDE] Bellingcat online investigations toolkit — open-source investigation techniques
  • [OPTIONAL] Journalism skills library (36 skills, 13 hooks) — a collection of pre-built Claude Code skills covering source verification, FOIA requests, data journalism, and editorial workflows. Browse it for ideas or install individual skills to supplement the one you build in this module. Not required — the focus this week is on creating your own skill from scratch.
  • [OPTIONAL] NICAR 2026: Skills in Codex and Claude — Aaron Kessler's NICAR session repo with examples of building and using skills across Claude Code and OpenAI Codex CLI for data journalism workflows.

Troubleshooting

Your new slash command doesn't appear in /help

Make sure the file is in the correct directory (~/.claude/commands/ for personal, or .claude/commands/ in the project) and has the .md extension. The filename becomes the command name.

Your slash command doesn't seem to affect Claude's responses

Type it as /your-command-name in the session to run it. The file's instructions only load when the command is invoked.

"Permission denied" when creating files

Ask your agent to create the ~/.claude/commands/ directory and make sure it's writable — something like "can you make sure ~/.claude/commands exists and you can write to it?" If the agent is still blocked after that, paste the exact error into the web version of claude.ai or gemini.google.com and let it walk you through fixing the permission.

Installed skill isn't firing on its own

Skills load when Claude judges the task matches the skill's description, so your prompt needs to clearly name what you want. For /source-verification, type the slash command directly — the journalism-skills plugin exposes it as a command so you don't have to wait for auto-detection.

Your command or skill is too generic or not helpful

Both work best when they're specific. Edit the file to add detailed instructions, examples, or checklists relevant to your work.