How to Build Elegant Claude Skills (for Investing)

Claude Skills are the most underrated feature Anthropic has shipped this year.

A Skill is a folder of instructions Claude follows every time, without you re-explaining the workflow. Think of it as a saved recipe your AI runs against any input you throw at it.

For investors, this matters because most of what we do in research is repetitive (initiation memos, earnings reviews, 13F screens, channel checks). A Skill collapses each of those into a single trigger phrase Claude follows every time.

I’ve spent the past month testing this against the workflows I run for clients, and the leverage is real. Today I’m sharing both halves of the playbook: a pre-built skill you can install in 60 seconds, plus the four-step process I used to build it. Here’s the plan:

1. What this skill actually does
2. How to install it on Claude.ai in 60 seconds
3. The 4-step process I used to build it
4. How to extend the recipe to any workflow

A preview of what we're building below....build a 13F dashboard for any fund with just 1 prompt!

What this skill does

The skill is called Smart Money 13F Tracker. You point it at any institutional investor, fund, or manager, and it pulls their latest SEC 13F filing.

It compares the period you care about against prior quarters and surfaces what changed: new positions, exits, adds, trims, concentration shifts, sector drift, top-issuer changes, and (optionally) the stock’s price drift from the filing date to now.

You get back two things:

• A memo a retail investor can read in five minutes
• A self-contained HTML dashboard with every row mapped back to its CUSIP, accession number, and EDGAR link

Guardrails are baked in. The skill is research-only and never gives personalized buy, sell, or allocation calls. Every memo opens by flagging the 45-day 13F lag and the partial-portfolio nature of the filing, so the reader never confuses “what the manager reported last quarter” with “what the manager owns right now.”

That’s it. One trigger, one deliverable, fully auditable back to the SEC.

How to use it on Claude in 60 seconds

The easiest path is uploading the skill to Claude.ai. The whole install takes about a minute and 5 clicks.

Step 1. Download the skill zip from here. Save it somewhere easy to find. smart-money-13f-tracker.zip​

Step 2. Open any Claude.ai chat. Click the + button in the composer and choose Skills.

Step 3. In the popover that appears, click + Add skill.

Step 4. You’ll land in the Customize panel. Click the + next to “Skills,” then Create skill, then Upload a skill.

Step 5. Drag the skill zip into the drop area. Claude reads the SKILL.md and registers the skill on your account. (Again, here is my pre-built .zip file for this skill: smart-money-13f-tracker.zip)

Step 6. Start a new chat. The trigger is dead simple: type “Use the /smart-money-13f-tracker skill on Berkshire Hathaway’s latest 13F” and hit send. Claude picks up the skill and starts working.

A note on environments. The skill runs on Claude.ai, but it gets meaningfully more powerful if you upload it to Claude Cowork or Claude Code instead.

Those environments give Claude a file system, the ability to run scripts, and live MCP connections to data feeds. On Claude.ai you get a synthesized memo.

On Cowork or Code, you get a fully audited analysis with the underlying EDGAR XML pulled, parsed, and joined to your watchlist in one pass. Same skill file, more horsepower.

The 4-step process I used to build it

This is the part most people skip past. Building a skill that holds up under repeated use is a different exercise from writing a good one-off prompt.

Here are the four steps I used. Each one maps to a real file inside the 13F skill, so you can open it up and see what the finished version looks like.

Step 1. Start with the end goal, not the prompt.

Before opening any editor, I write down what the skill should deliver. Skip the methodology and skip the prompt, just lock the output.

For the 13F skill, the deliverable spec was a memo a retail investor can read in five minutes, plus an HTML dashboard that opens offline weeks later and still renders every chart. Every row in that dashboard has to map back to a CUSIP and an accession number so the analysis is auditable to the source filing.

That spec ran the whole project.

If you can’t describe the deliverable in two sentences, the skill isn’t ready to build yet. The output spec is what tells Claude when it’s done, what fields it needs to collect along the way, and what failure looks like. Inside the skill, this became instructions/output-structure.md, which locks down the required dashboard fields, the mandatory caveats, and the exact language guardrails so the skill says “reported position as of the quarter” and never says “buy.”

Step 2. Iterate in planning mode before writing a single instruction.

I used Claude’s planning mode to whiteboard the workflow before I touched the SKILL.md.

What inputs does the user need to provide? What ambiguity has to be resolved up front? What edge cases break the flow if I ignore them?

The architecture got locked before I wrote a single line of methodology. By the time I started typing the actual skill, I already knew the shape of every file I was going to need.

My SKILL.md itself ended up being just 27 lines long. It’s a numbered list of 9 steps, and each step points to the file where the detail lives.

That’s intentional. The orchestrator stays small. The depth lives downstream.

Step 3. Build an advisory board and an eval checklist before “improving” the skill.

This is the step that separates a skill that works once from one that holds up at scale.

I wrote two evaluation files before I touched the methodology. One is a pass/fail checklist with 11 tests the output has to clear before delivery. The other is an advisory board of three personas (SEC Filing Auditor, Portfolio Data Analyst, Retail Investor Educator) that Claude mentally runs the output through before signing off.

The checklist catches mechanical failures:

• Did the memo include the accession number?
• Did the language stay research-only?

The advisory board catches judgment failures:

• Would an SEC auditor accept the source trail?
• Would a portfolio analyst trust the share-change math?
• Would a retail investor actually walk away smarter?

Without both, you’re flying blind on quality. With both, the skill self-checks every time it runs.

These two files live at eval/checklist.md and eval/advisory-board.md inside the skill. Open them and you’ll see exactly what “done” looks like, written as testable criteria the agent has to satisfy.

Step 4. Split SKILL.md from the instructions so the skill handles edge cases.

A SKILL.md that tries to do everything in one file becomes unmanageable.

Worse, Claude loads it on every chat. So bloat in the orchestrator costs you context tokens forever, on every conversation where the skill is active, even when it doesn’t trigger.

The fix is to keep the orchestrator small and push everything else into separate files Claude loads only when needed. Things like CUSIP mapping issues, filing amendments, confidential treatment, and watchlist context each get their own file the skill references when the situation actually comes up.

For the 13F skill, that means:

• methodology.md handles the filing workflow and the required caveats
• context-handling.md handles input ambiguity and defaults
• output-structure.md handles the deliverable spec and language guardrails
• examples/good/ has one fully worked example so Claude has a target pattern
• examples/bad/anti-patterns.md has 15 failure modes to avoid

This split is what makes the skill robust. The first run will surface five edge cases you didn’t anticipate.

The second run, you push those into the right reference file. By the tenth run, the skill handles cases you never explicitly thought through, because the structure forces Claude to look up the right reference before acting.

Why the recipe transfers

The skill above is mine. The bigger point is the process generalizes to any workflow you run more than a few times.

Define the end goal, design in planning mode, build the eval board, then split the skill into files.

Whatever you do twenty times a quarter, the same four steps turn it into a skill. That might be:

• earnings call reviews on the names you cover
• channel check digests
• 10-K diligence write-ups
• expert call notes
• sector concentration screens on your portfolio

The compounding starts after you’ve built two or three. You stop writing prompts and start chaining pre-built skills together, and the workflow that used to take half a day collapses into a single trigger phrase. That’s where the leverage lives.

I’d be curious what’s the first one you’d build. If something on your research stack jumps out as the obvious candidate, hit reply and tell me.

Personal

If reading this made you want to actually wire any of this up in Claude Code, that’s exactly what I’m teaching next.

I’m running a five-day live cohort June 1 to 5, called Claude Code for Investors.

I’ll walk through the setup from scratch (even if you’ve never opened a terminal), the MCP wiring that powers the data feeds, the agent stack that runs research overnight, and how to build skills like the 13F tracker above for your own workflows.

There are 100 early bird seats at $499 and they close May 25. After that the standard tier is $999. Details and the full agenda are at the link here.

If the cohort isn’t a fit but the skill was useful, hit reply and tell me what you’d build first. Always interested.

Talk soon,

Felipe