Big Idea

The argument in one line.

A skill with a pass/fail eval loop and a memory file will outperform any single prompt over time because it catches its own mistakes and accumulates your feedback without you being present.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You use Claude Code regularly and want your repeating tasks handled by reusable, tuned workflows rather than raw prompts.
You write a newsletter or long-form content and want an AI editor that actually sounds like you.
You have already built a skill or two but the output still needs heavy editing before it is usable.
You want to understand eval loops as a mechanism for autonomous AI self-improvement on a practical scale.

SKIP IF…

You have no repeating tasks -- one-off prompts do not justify this setup overhead.
You want a no-code solution; this requires comfort with Claude Code, markdown files, and a local file system.

TL;DR

The full version, fast.

The tutorial argues that a skill is only as good as the feedback loop baked into it. Building from personal examples seeds the voice; an explicit trigger description makes the skill fire reliably; a pass/fail eval loop in a separate agent context catches AI slop without human intervention; a memory file accumulates lessons that are too subjective for binary checks; and a meta skill-editor keeps every skill concise and slop-free over time. The 80-to-90 percent rule closes the video: automation handles the bulk, but the last 20 percent still requires human taste.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →

Chapters

Where the time goes.

00:00 – 01:28

01 · What an AI skill is + five-step roadmap

Definition of a skill as a folder with instructions, introduction of the edit-post skill as the demo project, and the five-step framework displayed on screen.

01:29 – 04:59

02 · Step 1 -- Build from personal examples

Seeding the skill with three example files (personal, tutorial, product posts). AI reads examples, identifies patterns, asks clarifying questions, and generates an initial skill.md draft.

05:00 – 05:58

03 · Step 2 -- Write an explicit trigger description

The skill description field is the only thing AI reads before deciding to invoke the full skill. Making the use-when clause very specific prevents missed triggers.

05:59 – 11:53

04 · Step 3 -- Build the eval loop

Running the skill on a real draft, identifying weaknesses, having AI generate up to 10 pass/fail checks in evals.md, then wiring a separate grader agent to loop until all checks pass. Live demo shows five passes to reach full green.

11:54 – 13:43

05 · Step 4 -- Add memory.md

Building a memory file that logs 2-3 sentence summaries of each session. Distinct from evals: captures subjective voice feedback that cannot be reduced to pass/fail.

13:44 – 17:43

06 · Step 5 -- The skill-editor skill

A meta-skill (/skill-editor) that runs on any skill file and removes AI slop, duplicate rules, and excess length. Demonstrated live on the just-built edit-post skill. Available to paid newsletter subscribers.

17:44 – 19:18

07 · Where human taste still matters

The 80-90% rule: even a well-built loop produces a draft that still needs a human final pass. The creator's workflow: AI does the bulk edit, human reads and handcrafts the last 20%.

Atomic Insights

Lines worth screenshotting.

Numeric AI self-scoring is unreliable -- a model cannot distinguish a 3 from a 5 on subjective quality, so pass/fail checks are the only eval worth building.
Run evals in a separate agent with a clean context window; the same agent that wrote the output will be biased toward passing it.
Separating personal examples from skill.md means the skill stays shareable while your private context stays private.
Give AI at least two or three examples per output type, not one -- a single example causes overfitting to that format.
The trigger description is the most underestimated part of a skill; AI reads only the name and description to decide whether to invoke the full skill.
A memory.md file captures the subjective feedback that no pass/fail eval can encode, letting the skill calibrate your voice across sessions.
A skill that loops through eval failures and re-edits until all checks pass can run without human oversight -- the creator can leave and return to a finished draft.
Even a well-built eval loop produces output that is 80-90% there; the remaining 20% is human taste applied on the final read-through.
A skill-editor skill that audits other skills for AI slop compounds in value as your skill library grows.
The skill folder structure that works: skill.md separate from examples, plus evals.md and memory.md as peer files, not embedded in the main instructions.

Takeaway

Five habits that make AI skills self-improve.

WHAT TO LEARN

The gap between an AI skill that keeps producing mediocre output and one that gets better every week comes down to the feedback infrastructure built around it.

01What an AI skill is + five-step roadmap

Define the repeating task before building the skill; the clearer the job description, the tighter the skill stays over time.

02Step 1 -- Build from personal examples

Give AI at least two or three examples per output type; a single example causes overfitting to that one format.
Keep personal example files separate from skill.md so the skill stays shareable without exposing private context.

03Step 2 -- Write an explicit trigger description

The trigger description is the only part AI reads before deciding to invoke the full skill; vague descriptions produce missed or wrong-context activations.

04Step 3 -- Build the eval loop

Pass/fail checks are the only reliable eval format; numeric scores produce arbitrary results because AI cannot consistently distinguish quality levels on subjective criteria.
Run the grader in a separate agent with a clean context window so it judges output without being anchored to the process that produced it.
A well-designed eval loop can iterate five or more times unattended before all checks pass, compressing hours of editing into minutes of autonomous revision.

05Step 4 -- Add memory.md

A memory file captures qualitative feedback that no binary check can encode, letting subjective voice guidance accumulate across sessions rather than being re-explained each time.
Cap each memory entry at two or three sentences; long entries bloat the context window and introduce noise.

06Step 5 -- The skill-editor skill

A skill-editor meta-skill that audits other skills for AI slop compounds across your entire library; one pass removes em-dashes and filler patterns from every skill at once.
Keep every skill short enough to be reviewed by a human in under a minute; length is a sign of accumulated slop, not depth.

07Where human taste still matters

Even with a full eval loop, the final 20% of output quality requires human taste applied on a deliberate read-through -- automation handles volume, judgment handles finish.

Glossary

Terms worth knowing.

AI skill: A folder of markdown files that Claude Code reads when a matching task is triggered, encoding reusable instructions, examples, and context for a specific workflow.
Eval loop: An automated review cycle where a second AI agent checks the first agent's output against a list of pass/fail criteria and signals the original agent to revise until all checks pass.
evals.md: A file inside a skill folder listing up to 10 pass/fail checks that an AI grader runs against each output to catch specific quality failures like AI slop, missing structure, or wrong tone.
memory.md: A reverse-chronological log of 2-3 sentence summaries from past skill sessions, letting the skill accumulate feedback that is too nuanced for binary pass/fail checks.
AI slop: Output patterns that signal AI authorship rather than human voice: em-dashes, filler words like leverage or delve, the this-is-not-X-this-is-Y construction, and chains of very short sentences.
Skill-editor skill: A meta-skill that audits any other skill file for AI slop, duplicate rules, and excessive length, then rewrites the skill to be concise and slop-free.
Progressive disclosure: A skill design principle where the main skill.md stays short and loads detailed context files only when needed, rather than front-loading all examples into a single file.

Resources

Things they pointed at.

09:01toolWhisperFlow

17:00productBehind the Craft (newsletter + skills) ↗

00:00linkCreator Economy newsletter ↗

Quotables

Lines you could clip.

07:42

“AI can't really tell the difference between a four out of five or a five out of five. It's gonna make stuff up.”

Counterintuitive claim that reframes how to think about AI self-evaluation -- punchy and standalone→ TikTok hook↗ Tweet quote

10:43

“It's gonna keep iterating in a loop until everything passes and you as a human can just go get coffee or get lunch and have the AI do the work.”

The payoff moment -- vivid, concrete, zero setup needed→ IG reel cold open↗ Tweet quote

16:05

“I don't really believe in building super long skills that humans don't bother to read. Every skill needs to be reviewed by human eyes.”

Contrarian take against the more-instructions-equals-better instinct→ newsletter pull-quote↗ Tweet quote

18:03

“The skill can only produce output that is maybe 80 to 90% there. The difference between kind of AI slop and actually good output is you spend the last 20% reviewing and handcrafting it.”

Honest calibration of AI limits -- re-centers human judgment→ newsletter pull-quote↗ Tweet quote

The Script

Word for word.

Read-along

Don't just watch it. Burn it in.

See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.

analogystory

Hey, everyone. Today, I am going to build an AI skill from scratch and share five advanced tips along the way that you won't find anywhere else.

And that's because I've been completely AI skill built. It's just incredible to be able to encode my personal knowledge and tastes into a reusable skill that can help me save so much time every week.

And I promise you if you build your own skills, it can help you save time too. Alright. So let's do a quick recap first.

What exactly is an AI skill? Well, skill is just a folder with instructions that AI can trigger for a given task. And why don't we build a skill to edit long form post and long form copy and we'll call it the edit post skill.

And this is what the skill will look like by the end of this tutorial. So it's gonna have a bunch of files and it's gonna be in a folder.

And we're gonna build a skill live by following these five steps. So first, we are gonna create the skill by using, uh, my best examples and personal context. Then we are going to be explicit about when the skills should trigger by uploading the description of the skill.

And then we are going to test the skill manually and build an evals dot m d so that it can actually check its own work and improve its own output without us even being there. And number four, we are going to build a memory dot m d so the scale has memory of our past conversations and can actually improve itself over time.

And then finally, I'm gonna show you a skill that can help you improve all of your skills by removing AI slop, making things more concise and clear and so on. Alright.

Let's get into it. So this is Clock Code. I have a empty window right here.

And, uh, let's go ahead and paste our five steps here and give us some instructions. So I am doing a live tutorial to, uh, build an AI skill from scratch.

I want you to work with me and follow these five steps but wait for my instructions. Now let's start with step number one, which is create a skill using your best examples and personal context.

Alright? So as I mentioned before, I have a newsletter with, uh, different kinds of posts. I have these tutorial posts.

I have opinion takes and a bunch of other content. Right? And to prepare for this tutorial, what I've done is I made three text files with examples.

So here are some examples of my personal posts. Here are some examples of my tutorial posts and some examples of my more product related pros where I break down AI products and other tools.

Okay. So now let's go back to Claude, and let's paste the three example files here and just say, I wanna create an edit post scale that helps me edit a draft newsletter or any kind of long form post based on these examples.

Review the examples and ask me the questions, and let's try to create a scale that's around one page. Okay.

So that's pretty much it. That's the prompt that I typically start with to kick off building the scale. And the important thing to remember here is that to give it just as much examples and personal context as you can.

Okay. So you see here that AI has read the examples and, uh, it's found, like, dear subscribers opener, hook, the voice, the short paragraphs, and one liners that I like.

And it's asking me a few questions now. So what should the skill do when you invoke it? Edit a draft, that makes sense.

How should it handle three post types? Let's say auto detect then confirm. And there we go.

And now, uh, because we've given examples, it should have enough to actually create a fairly good initial stab at a scale. So let's skip ahead and see what it comes up with.

Alright. So you can see here that it's created scale.md and it has a bunch of workflows, detect the post type, and then list the gaps, and then rewrite it.

It has post types with the links to the examples. It has a skeleton and the voice rules. So it's pretty good.

Right? It's pretty good initial first stab at the scale. And there are several pretty important lessons here.

So the first lesson is to always separate the skill dot m with your personal context and examples. And this has a few advantages. Number one is that because we didn't just load all these examples into the actual skill dot m d, it doesn't have to read through our crazy examples each time.

It can figure out from the draft post that we give it, whether it's a tutorial post or a personal post, and it can only load the relevant context. Right? The second benefit is that if you ever share your skill dot empty with somebody, like, you don't have to actually include a bunch of personal information.

Like, everything here is, like, generic and not so confidential to share.

But if you start sharing, like, all your example posts and everything, might just be sharing a little bit too much. Right? Okay.

And the third tip I wanna share is that when you're giving AI examples, be sure to give it at least a couple of different examples. Right?

Don't just give it one example. Otherwise, it's gonna overfit to that single example and basically not give you the output that you actually want. Okay.

So now let's move on to step two, is be explicit about when AI should trigger the skill. So go back to the skill here and you can see, uh, right here, right, in the description.

So the way that skills work is that when you just ask AI random question in ClockCode or Codex or whatever app you use, it doesn't actually read the whole scale. It just reads like the name and the description.

And based on description, it then decides whether to trigger the full scale or not.

So it's very important to be very explicit here about laying out exactly when you should use this skill.

So here it has use when Peter paste a draft post on newsletter or ask to edit, tighten or punch up a long form piece. I think it's pretty good. That's why I'll leave it alone right now.

But just make sure that you audit this section here because otherwise your skill will not reliably trigger. You can of course still trigger the skill manually with edit dash post, but it just takes a little bit more work.

So that's tip number two, pretty straightforward. Now let's talk about tip number three which is testing the skill manually and building evals so that it checks its own work.

And this is a tip that I feel like other skill tutorials don't talk about. Right? So let me, uh, go ahead and run the scale through a real post.

So let's say, let's move on to step three. Here's a draft post to edit.

Let's go ahead and paste the post right here. Alright. So this is gonna be a very meta because the post is basically about how you follow these five steps to create a scale and now I'm using the scale to edit actual post.

And you notice here that it's detected that this is a tutorial style post, is totally correct. Right? And it's gonna do a manual pass, Sponsored block is missing.

No number preview upfront, so on and so forth. And then it's going to create a draft right here.

Okay? So it's a little bit hard to tell what actually changed from the draft, so I think we should give some instructions of when you make edits, make sure to bold any changes you make.

And let's just take a quick look at the draft post. So it looks like it's got watched now on YouTube, which is great. I think, yeah, this looks pretty good.

And and, normally, I would take a much closer pass through this and make a bunch of more other suggestions. But why don't we just ask them now to build the evals for our scale? So what is a eval, first of all?

An eval is asking AI to basically check its own work. Right?

And there's two types of evals. There's evals where you can get AI to give it a score. So for example, how useful and practical is this post?

Give it a score out of five and justify why. And those evals, some people like them, but they actually aren't that good because, um, AI can't really tell the difference between a four out of five or a five out of five or a three out of five.

It's gonna make shit up. Right? So a more straightforward eval is just to ask the AI to do a bunch of pass fail checks.

Okay? So can you create up to 10 pass fail checks and document it in an evals.

Md? And let's put some checks in these categories. So number one, the introduction.

The introduction needs to catch the reader's attention. It needs to be crisp and concise. Tutorial based introductions need to have a wash down YouTube link.

The voice. The voice sounds really authentic. It needs to not have any kind of AI slop like Em dashes, a bunch of filler words like leverage and delve and also AI slot patterns like this is not x, this is y or a bunch of really short sentences.

That's what AI likes to do. So let's get rid of all that slot and let's check for that stuff. And substance is, can you make sure that, uh, there's actually practical insights here that people can put into practice right away?

Can you make sure that the tone is helpful and genuine and authentic? Alright? And is there a clear call to action at the end for the reader to take some sort of action with a list of steps?

Okay. So we just dictated all this. And by the way, to dictate all this stuff, I'm using this app called WhisperFlow, which I really love, and you can find a link to it in the video description.

Alright. Let's submit this. And hopefully, AI also uses our, uh, tutorial post examples and other post examples to come up with the evals.

So now let's skip ahead until it builds the evals empty so we can all take a look. Okay. AI has created the evals to empty, and here we are.

So is there an opening hook? Is there a crisp first two or three sentences? Is there a link to YouTube?

No em dashes, no filler words, the AI slop stuff. It looks like it passed most of the evals except for these two. Now there's one very important instruction that we forgot to include, so let me go ahead and tell AI now.

Include in skill.md that when you run these evals, you should spin up a separate agent to run them, so there's a clean context window.

And if any of the evals fail, you should get the original agent to continue to edit the post until all the evals pass. Okay? So now it's gonna make sure that scale.md is aware of eval dot m d.

And, uh, basically, now we are trying to set up a loop, right, where you get one agent to edit our newsletter post or whatever long form you have, then the AI will spin up a separate agent to run the evals here to check the post.

And because it's a separate agent, it has a clean context window. It's not gonna be biased by the previous results.

And if anything fails, then it's gonna get the original agent to do another edit pass until everything passes. And this is where the magic of building skills is and using evals.

Right? Basically, it's gonna keep iterating in a loop until everything passes and you as a human can just go get coffee or get lunch and have the AI do the work. Okay?

Now, of course, you still have to check the AI's results at the end, but I think building this kind of loop is so much more powerful than just building the skill and calling it a day. Alright? Okay.

So it claims that it built a loop. Let's actually test it now by running the evals loop, and let's see if it actually does loop or not.

So here's the results. So first, it did one loop first and three out of the 10 eval's failed.

Right? There's some hypotheticals in there. It's using some AI slot phrases.

It ran again and then two failed. It ran a third time and two failed and it ran a fourth time and only one failed. And finally, after five loops, it looks like everything is working.

I got rid of all the m dashes, all the this is x not y slop and things look good.

And it looks like there's some problems of our evals, so you have to be here to both make sure that evals are working correctly and that they're actually doing their job. But you can see this looping action. Right?

It's doing a lot of work without us even being there. Alright. Now let's move on to step four, which is building memory dot m d for the scale so it gets better over time.

So basically, the eval runs loops to improve the output from the scale, but we also wanna improve the scale based on our conversations. Right?

So let's say, yes, let's move on to step four, build the m b dot m d and list the lessons learned from our conversation so far. Okay.

So this is the memory dot m d and it's basically like a reverse chronological order of summaries of past conversations that we have with AI while using this skill. So you see here that this is it for today.

There's a bunch of stuff here And there's a little bit too much here, so I'm gonna give you some more feedback. I'm gonna say, make sure whatever you include in memory dot m d doesn't overlap with evals dot m d.

Memory dot m d is for improving the skill itself. And try to capture each day in, let's say, just two or three brief sentences.

You can add more if you want, but generally speaking, try to be concise.

Okay? Because what I don't wanna do is have this memory be super long and then having Claude or AI get confused again. Okay.

This is the new memory dot m d. It's much shorter now. The key lesson was that I wanted to keep the grading agent and the editing agent separate.

And So this is, I would say, super useful. But if we did this for real, I would give a bunch more feedback about the draft, and it's gonna remember a lot more things. And I think memory dot m d is actually optional, but I think it's useful when you can't find easy pass fail evals for feedback that you wanna give.

Like, for example, maybe you want to give a feedback to, I don't know, make the voice more authentic or something that's more vague and can't exactly have a pass fail eval. Okay?

Alright. So we covered four steps already and the last step is to build your own skill to build skills.

So let's just, uh, do a hypothetical here. Let's say, we were able to build a skill that build skills for us based on our conversation here.

Don't build a skill. This is outputting chat what your one pager or you call paragraph scale will look like.

And, hopefully, it actually uses the five steps that we covered to build a scale. So let's take a look. Alright.

So here we have you build skills. Here's the target structure. You're gonna have context separate from the skill, examples, eval, and memory, and then follow these five steps.

Right? Alright. So it's as easy as that, but why do you need a skill to help you build skills?

Look, the reality is that AI is doing a lot of writing for us when building the skills. And if you don't pay attention, inevitably it's gonna add a lot of copy and stuff to it as they turn into AI slop.

So you can basically tell it to build a skill to, uh, fix its own skills or what you can do is you can copy my skill builder skill that I have here.

So skill alright.

Or okay. So okay.

So you can just tell AI to build a skill based on your conversations, building past skills like we did here, or you can go ahead and copy my skill editor skill.

And the skill editor skill just has a little bit more information in it, like preventing AI slop words and making sure that the skill itself is very concise and following some rules around progressive disclosure and so on and so forth. Let me show you it in action.

So apply skill editor to this edit post skill. And let's see what kind of changes it makes.

Alright. So we ran a scale editor scale on our own scale, and we found that it is full of AI slop amp dashes.

Right? So it's gonna get rid of all the amp dashes. It's gonna get rid of, uh, it's not why phrasing, and it's going to fix a bunch of formatting.

So overall, it looks like it just fixed a bunch of formatting, which is pretty good because it means that our original edit post skill is actually pretty sound. And, yeah, that's pretty much it. You wanna build a skill editor skill to periodically run to audit your skills or, like, to to tag when you're building new skills, uh, because, uh, it just helps you make everything more concise.

Right? I don't really believe in building super long skills that humans don't bother to read. I really think, like, every skill needs to be reviewed by human eyes and to make it actually good.

Alright. So let's recap. So here are the five steps again to build really great skills.

Number one, create a skill with AI by giving it your personal context and your best in class examples of the output that you want.

Number two, be explicit in the description of the skill about when AI should trigger. Say something like use when x y z. Just make it super explicit.

Right? Number three, test the skill mali a few times and give it feedback, and then ask it in the same conversation to build an evals dot m d with a bunch of pass fail checks on important things to do so that AI can actually check and improve its output without you even having to be there.

Number four, build a memory .md for the skill so that it actually improves over time. And finally, consider building your own skill to build skills or just copy my skill editor skill here.

Now, quick plug. My skill editor skill, full disclaimer, is available to pay subscribers of my newsletter along with all the other great skills I have here, personal adviser, health coach, uh, infographic designer, and more.

Right? And I spent a lot of time making these skills great. They're all handcrafted.

They're all AI slot free. So check out behind the craft.com if you want access to these skills.

I'll include the link in the description too. Alright. One last thing I should think about building skills.

Following these five steps is really important, but, um, the reality is that even with all these best practices, the skill can only produce output that is maybe 80 to 90% there.

The difference between kind of AI slop and actually good output is you spend the last 20% reviewing AI's output and handcrafting it and making it even better with your human taste and judgment.

Right? I've tried to encode as much of my judgment and taste into skills as possible, but it still misses stuff.

And the way that I actually write newsletter posts is similar to the way that people build days. I spent a lot of time upfront creating the first draft and maybe dictating my ideas. I then get the AI to do the initial edit pass using something similar to the edit post scale and these best practices.

And then the last 20%, I've spent a lot of time just reading through it and make sure it makes sense, applying my own common sense before sharing it with you all. So it's not AI slob, I promise you guys.

Alright. So if there's one takeaway from this video, take a look at your past week, figure out where you're spending a lot of time and build skills to streamline as much of this work as possible.

And remember to build things like evals and memory for your skills so that they can actually improve by themselves and get better over time with your input. Alright?

So if you found this video useful, please like and subscribe to this channel, and I'll see you next time.

The Hook

The bait, then the rug-pull.

Most Claude Code skill tutorials stop at paste your instructions and test it. This one starts where those end: with a live build of a self-grading, self-improving skill that runs an eval loop, remembers past sessions, and gets audited by a meta-skill that strips the AI slop out of it.

Frameworks