SMART AGENT COLLECTIVE
July Group Call · Live Build

Build a Real Skill

Turn a whole workflow into a system that runs itself, with you in the loop at the right moments.

60 minutes · build your own, live
Where we were → where we are going

From a shortcut to a system

June — a shortcut
A one-shot skill

Plain instructions for one task. You say the trigger, it does the thing. Great, but it is a single step.

July — a system
A multi-step skill

Phases, checkpoints, memory, and its own reference material. It handles a whole task and stops to check with you before anything you cannot undo.

The difference
A shortcut saves typing.
A system does the job.
The worked example

The RealMarkAI newsletter skill

Same shape you will build today: it does the heavy lifting, you keep the judgment calls.

Research
Reads the curated queue + this week's AI news
Draft
Writes the newsletter from the sources
◆ Checkpoint
"Does this angle work?" It waits for Tom
✓ Send
Goes to the list, only after a confirm

The diamond is the human in the loop. That is the part that makes it safe to hand off.

The payoff
Hours under 30 min

And it is better, because the time goes into editing and judgment, not building from scratch every week.

The one lesson that makes it work

Map the workflow first

You do not start by writing the skill. You map every step, the order, and where a human decision has to happen. Then you hand that map to your AI and it builds the skill around it.

"If you can map it, you can build it. If you cannot map it, you do not understand your own process well enough yet, and that is the real work."

Anatomy of a real skill

Four parts, one folder

~/.claude/skills/your-skill/
SKILL.md
The instructions: a name, a description that tells the AI when to use it, trigger phrases, and the steps in plain English.
references/
Big reusable context: templates, formats, voice rules. Keeps the main file short and readable.
scripts/
Small scripts for the exact, repeatable steps (sending, formatting) that should run the same way every time.
LEARNED.md
The memory file. Every correction gets written here and read at the start of every run. Correct once, never re-explain.

Today you build SKILL.md, one references file, and LEARNED.md. Scripts come later.

The five patterns

What turns instructions into a system

01

Phases + triggers

Break a big job into callable pieces you fire one at a time.

02

Human checkpoints

The AI does the work, you keep control at the risky moments.

03

references/ files

Keep templates and rules out of the main instructions file.

04

scripts/ for exact work

Deterministic steps run identically every single time.

05

LEARNED.md memory

Corrections stick. Quality climbs week over week on its own.

The most important pattern

The checkpoint is the point

Before the newsletter writes a word, it prints its plan and asks "does this direction work?" and waits. Before it sends, it confirms.

"The checkpoints are not a weakness. They are the point. The AI does the heavy lifting, you keep the judgment calls."

Before you build

Three things you need

A · You

Claude Code running, an editor open, one recurring task you can describe step by step, and a ~/.claude/.env for secrets.

B · Services

The accounts your task touches: where your data lives, and any tool you send or publish to. Each needs an API key.

C · Building blocks

Reference files, memory, and other skills your skill can lean on. You are building small skills that call each other.

Dependencies, mapped

What mine uses → what yours needs

The newsletter skill usesYour equivalent
Notion (content queue)Where your data lives: Notion, a Google Sheet, a folder
Gmail (source feed)Any inbox or feed you pull from
Web searchBuilt into Claude already
Acumbamail (sends)Your email tool with an API: Mailchimp, MailerLite
Slack / Google TasksOptional: a notification and a reminder
One rule, no exceptions
Keys go in .env

Every API key lives in ~/.claude/.env. Never in the skill file. Never in a shared folder. Say it out loud so it sticks.

Now we build

30 minutes. Your own skill.

Follow along in your own Claude Code. Open the companion guide for every copy-paste prompt.

tom.here.now/build-a-skill
1

Pick + map

Choose a task, map every step and decision on paper.

2

Scaffold

Create the folder and SKILL.md with a trigger.

3

Steps + phases

Lay out the order, split draft from send.

4

Checkpoint

Add the stop-and-confirm before anything risky.

5

references/

Move your template or rules into a file.

6

Memory + test

Add LEARNED.md and run it for real.

Step 4 is the one that matters most. Nobody moves on until their skill stops and asks.

Step 1 — the prompt that starts it all

Map before you build

# Paste this into Claude Code, then answer its questions I want to build a skill for [your task]. Before we write anything, help me map the workflow. Ask me questions until we have every step, the order, and every point where I need to approve something before it continues.

You should end up with a numbered list of steps and at least one "I approve here" marked.

The ceiling is high

What to add as it grows

Scripts

For exact, repeatable steps like sending or formatting.

API connections

Wire it to your real tools: email, CRM, calendar. Keys in .env.

Calling other skills

One skill triggers another as your workflow grows.

A quality check

The skill scores its own output and fixes low scores itself.

Homework

Finish it, then feed it

1

Finish

Get your skill running your real task end to end.

2

Correct once

After the next real run, add one fix to LEARNED.md.

3

Share

Post in Skool: what you built and the time it saved.

The whole idea
Small skills that
call each other.

That is how mine works, and it is how yours should grow. Build one this week. Then build the next.

Companion guide + prompts → tom.here.now/build-a-skill
← → or space to navigate