YT YouTube2Text

YouTube2Text → Transcripts → mattpocock/skills: A complete AI Coding workflow, end-to-end

mattpocock/skills: A complete AI Coding workflow, end-to-end — Transcript

by Matt Pocock · 3,717 words · 505 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00Hello friends, it occurs to me that I've
0:01never actually put together a proper
0:04tutorial for my skills repo. At the time
0:06of recording this repo is up to 162,000
0:09stars. We have 7.5 million downloads and
0:12I've never made a tutorial for it. I get
0:14questions all the time like what is the
0:15sequence I should use these skills in,
0:17how should I install them, how should I
0:18set them up? So this video is going to
0:20be a walk through of the main flow you
0:22use when you're using these skills.
0:25We're not going to look at the advanced
0:26stuff, we're not going to look at the
0:27new stuff really, we're just going to
0:29focus on the main flow. The stuff you
0:31need to get started. To walk you through
0:33this, I'm going to be using one of my
0:34work repos which is the AI Hero CLI.
0:37This is the command line interface that
0:38drives a lot of my exercises that I use
0:41on my courses. I've never actually set
0:43up my skills to work with this repo so
0:44now is a great chance. If you want to
0:46set up my skills on a brand new project,
0:48you just do this except you do it in an
0:49empty directory. So it works the same
0:51whether you're using a brownfield code
0:52base or a greenfield code base. I'm
0:54going to open up the command line
0:55interface here and I'm going to type NPX
0:58skills at latest add mattpocock/skills.
1:03This assumes a couple of things. It
1:05assumes that you've got Node.js
1:06installed. This NPX comes from Node.js
1:10and it runs the skills.sh command line
1:13installer from Vercel. What this
1:15basically does is it installs a GitHub
1:17repo of skills called mattpocockskills
1:20and it can walk through a few setup
1:22questions here. It first says it needs
1:24to install the following packages. Yes,
1:25that seems fine to me and then it did a
1:28couple of things and we now have a long
1:30long list of all the skills that we
1:31could install. It found 38 skills here
1:34which is a lot and you can see if I
1:36scroll up and down that they're in two
1:37groups. We've got the mattpocockskills
1:39and then we've got other skills. So the
1:42mattpocockskills are the ones that I
1:43have blessed as the skills that I think
1:46are good enough to be public facing. The
1:48other ones are ones that I'm
1:49experimenting with right now and may
1:51delete in future. What I recommend you
1:53do is you go to the top here and you can
1:55kind of go up and down. It's kind of
1:58broken, I have to say. And if you press
2:00space here, and you should see that if
2:02you scroll up, okay, they're now all
2:04selected. You press space, and then you
2:06press return, and now uh you've selected
2:09all of the official skills. I'm not
2:11terribly happy with Versel's CLI here,
2:13so I may change it in future, or maybe
2:15even just ship my own. But uh for now,
2:18that's as good as it gets. One thing
2:19that is good is that it will set up your
2:21skills to work with any agent. So, I use
2:24Claude Code, but you can go down here
2:26and sort of just select the ones that
2:27you want. I'm using space to select. I
2:30think by default, if I zoom out a touch,
2:33then it supports all of these universal
2:36ones up here. So, cursor, Codex, Claude,
2:38etc. But anything that uses like Claude
2:41skills, such as Claude Code, then you
2:42need to set up yourself. So, I'm going
2:44to press return here, and it should now
2:47be configured to set up my skills for
2:48Claude Code. The installation scope
2:50defines where your skills are installed,
2:52whether they're installed just in the
2:53current directory, or whether they're
2:55global. This will depend on what your
2:56team's conventions are. If you're
2:58working in a team, I would say that
2:59project skills are the right way to go.
3:01That way, everyone is using the same
3:03skill set on every project, and it means
3:05that you can contribute to the skills
3:07together and make those decisions
3:08together. But global is fine if you're
3:11just a solo developer working on your
3:12own stuff, like I am. So, I'm going to
3:14press return here, install it in my home
3:16directory, and I'm going to choose
3:17symlink as the recommended way. The
3:20choice here is whether you copy it to
3:22the agents folder as well as the dot uh
3:25Claude folder. And
3:27it's kind of not a nice way to do it.
3:28Symlink is just the nice, easy way to do
3:30it. So, I wouldn't even make a decision
3:31here, just choose symlink. So, it now
3:33gives you a summary of all the things
3:34that you're installing here. There seems
3:36to be an alert on Socket about to spec.
3:38I'll take a look at that later. But yes,
3:40we can proceed with installation, and
3:42it's now installed all of the skills.
3:44This means then that I can run Claude
3:46inside here, or whatever your agent is,
3:48and I'm going to create a new So, I'm
3:51just going to say hello to get out of
3:52this agent's view here. Now, depending
3:54on the harness you're using, this will
3:55show up in different ways, but on Cloud
3:57Code, I can press forward slash and I
3:59now see that I have a few skills
4:01available to me. I have grill me,
4:03grilling, way finder, grill with docs,
4:05etc. Loads of stuff. Now, the difference
4:07between my skills and lots of other
4:09skills repos that are out there is my
4:11skills are mostly user invoked. That
4:14means that if I run context here, not
4:17many of my skills actually leech their
4:19way into the description. And the
4:22descriptions I have are quite short and
4:24precise. So, that means that even though
4:26we've downloaded all of my skills, the
4:28skills only take up 660 tokens here. So,
4:32it's very, very light in terms of
4:33context load. So, okay, we got the
4:35skills. Now, what we have to do is we
4:37have to run set up Mac Pocock skills.
4:40And this will do a few things. My skills
4:42rely on some uh configuration inside the
4:46repository, and this does a few things
4:49for you. The first thing is it means you
4:51need to use an issue tracker. We're
4:53going to be saving um specs, we're going
4:56to be saving tickets, and we need to
4:57save them somewhere. You've got kind of
5:00an infinity of choices here. You can use
5:01GitHub, you can use local markdown, or
5:04you can literally use anything. The way
5:06that the skill works is that it looks at
5:09your local configuration. And so, you
5:11can set it up for Jira, you can set it
5:13up for Linear. And the way you do that
5:14is you just tell the agent what you want
5:16to set it up for, and it will go and set
5:18it up for it. I just want to emphasize
5:19that. People are asking me all the time,
5:20"How do I make my skills work with Jira,
5:22work with Beads, work with Linear?" It
5:25already does. All you need to do is just
5:27run set up Mac Pocock and just say, "Set
5:29it up with Jira." Except, I don't want
5:31to set it up with Jira. I'm just going
5:33to set it up with local markdown,
5:35please. So, that's fine by me. The next
5:37question to answer here is about triage
5:39labels. So, there are a set of labels
5:41that the skill relies on to communicate
5:42information about the tickets that it
5:44produces. It's not really that important
5:46here, so I'm just going to accept the
5:48defaults. You can look at the docs on
5:50the triage skill if you want to learn
5:51more. So, defaults is fine. The next one
5:54is about the domain documentation. So,
5:57my skills like to have a little bit of
5:59docs, a context .md file, and an ADR
6:03inside the repo. And it's basically
6:05asking if it's going to be a single
6:07context or a multi-context. I think
6:09single context is the way to go here.
6:12Multi-context is if you have a big mono
6:14repo and you need lots of different
6:17bounded contexts within it. But for 99%
6:21of people, a single context is going to
6:22be fine. All right, so it's gone ahead
6:24and written a few things here. The first
6:26thing it's written is inside claw.md,
6:28it's added a few little links here. So,
6:31this is the new stuff. It's just linking
6:33to the issue tracker docs, linking to
6:35the triage labels, and linking to the
6:37domain docs. And each of these are at
6:40docs, agents, domain issue tracker. So,
6:43we can see here that it's going to save
6:45all of the issues and specs inside a
6:49scratch file. So, with that, our setup
6:50for this repo is complete. And so, you
6:52might be thinking, how do I get started?
6:54Well, before we get started, I'm going
6:56to show you one more really cool thing.
6:58You can, if you're following along, just
7:00stop the video now and use one skill.
7:02You can use the ask Matt skill. This ask
7:05Matt skill is essentially me as a skill.
7:08It knows everything that is needed about
7:10the skills repo and what you should do
7:12first. So, we can say, ask Matt, how do
7:15I get started? I want to make some code
7:16changes here. What is the main flow I
7:18should use? I can now submit that and
7:20see what it says. By the way, I'm using
7:22Whisper flow as my transcription. So,
7:23here we go. It's saying the main flow,
7:25idea to ship. Since you have a code
7:27base, start at the top of the main flow
7:29and walk down in it in one unbroken
7:32context window. So, it's very um
7:34kind of really telling you how to use
7:38your sessions as well. I I believe that
7:40being conscious about the context window
7:43that you're using, the tokens that
7:44you're using is essential to using AI
7:46well. It says you should start with
7:48grill with docs. It interviews you to
7:50sharpen the idea and because you're in a
7:52repo it's stateful. It records what it
7:54learns in context.md and ADRs. This is
7:57where you turn I want to change X into a
7:59crisp defensible plan. Defensible is
8:01such an LLM phrase, honestly. Can you
8:03settle every open question just by
8:04talking? If a question needs a runnable
8:06answer, then you can use prototype,
8:08which I've done a video about on it.
8:10Bridged in and out of by handoff, if not
8:12skip this. Once you've done the
8:14interview and grill with docs, you can
8:15either go straight to the implement
8:17skill, or if it needs multiple sessions
8:20to go through, then you can go to to
8:22spec and to tickets. Let me make this a
8:24little bit clearer for you. The default
8:26flow looks like this. You start with
8:27grill with docs, and this interviews you
8:30based on the idea that you want to
8:31produce. For instance, if I clear out of
8:33ask math, of course I could go and ask
8:35follow-ups here, use it as a tutorial
8:37itself, but let me just show you. I'm
8:39going to say grill with docs, and I'm
8:40going to kick it off with an idea. I'm
8:42going to say, I would like to remove
8:44most of the internal tooling on this CLI
8:47to make it just only public-facing.
8:49There's a lot of craft here. I want to
8:51just take this repo down a notch. It
8:53really can be as vague as this. You
8:55don't need to do too much here. Grill
8:56with docs is going to do the heavy
8:58lifting by asking you a bunch of
8:59follow-up questions. It's going and
9:01exploring a bunch of code here. And by
9:03the way, I'm [clears throat] using
9:03Claude Code, I'm using Opus 4.8 on
9:06medium effort, but you really don't have
9:09to use the same setup as me. These
9:10skills are being used by a bunch of
9:12different people, bunch of different
9:13harnesses, different models, different
9:14effort levels. And we can see it's
9:16already asked the first question here.
9:18So, it's gotten a clear map of the
9:19entire repo. It's looking at the
9:21internal namespace with 11 subcommands.
9:23So, this is what a grilling session
9:25looks like. You go through all of the
9:27questions until you feel or you and the
9:30agent feel that you've reached a shared
9:32understanding. I'm going to do that now,
9:33and then I'll check in with you once I'm
9:35done.
9:36Okay, it didn't end up taking too long.
9:38We ended up with what, six questions?
9:41That's not very much for grilling
9:42session. Usually mine end up being about
9:44sort of 20 questions depending on the
9:46size of it, but we've ended up with a
9:48decent plan. We're going to delete uh 10
9:50command files, delete three tests,
9:52rewire shared modules. And all I did
9:55here was I just answered questions until
9:57it said, "Okay, we've walked the whole
9:59tree. We've reached a shared
10:01understanding. Let me lay out the plan."
10:03Notice here, I wasn't using plan mode
10:05for this. I was actually in auto mode in
10:06claw code, which is kind of like the
10:08default mode. And you now have a fork in
10:11the road. If you think that this work is
10:13going to be big enough that it will need
10:15multiple agent sessions, then you can
10:17skip numbers two and three here and go
10:20straight into implement. The way you
10:22would do that is you would just say, uh
10:24forward slash implement this. And in
10:26this case, I do think that is what we
10:28should do. I've still got about, uh I
10:31think of my context window is kind of
10:33like ending or getting significantly
10:35dumber around 140k
10:38mark. I think of that as kind of like
10:40the smart zone of the LLM. If you go
10:42above 140k, you end up sort of with, you
10:44know, attention degradation. It ends up
10:46getting stupider, does weird
10:48hallucinations. So, I think of having
10:50like, okay, we've got 100k of budget
10:52here to remove 10 commands. That seems
10:54super easy. Definitely something, you
10:57know, we can definitely do that. So,
10:58this is what I would usually do. I would
10:59just say implement and then I would
11:01leave it, let it run, and it would
11:03finish the work. However, in the
11:04interest of showing you everything, I'm
11:05going to pretend that this work is going
11:07to take more than one session, that I've
11:09maybe run out of context window in the
11:11current or run out of smart zone in the
11:13current window, and I'm going to need to
11:15spread this out over multiple context
11:16windows. So, I'm going to call to spec
11:19here instead. So, instead of writing
11:21implement this, I'm going to say to spec
11:23here. And that's it. What this is going
11:25to do is it's going to take all of the
11:27discussion that I've had, all of this
11:2946.1k tokens, and it's going to compress
11:32it into a document that we can use
11:34later. This is where our issue tracker
11:36comes in. So, this issue tracker we're
11:38just going to use local markdown files
11:40and so it's just going to spit out the
11:41spec into a local directory. This spec
11:43is going to be the destination that
11:45we're heading to over this multi-ticket
11:48sprint. In other words, this is what
11:50we're going to end up with. This is the
11:51description of everything of how it's
11:53going to look at the end. And then the
11:54tickets is the description of how we're
11:56going to get there. Okay, we can see
11:58it's been written and published to the
12:00issue tracker. If I open this up, we can
12:02see it is in here. So, it's very nice
12:05and detailed. It's got a problem
12:06statement, a solution, a bunch of user
12:08stories, implementation decisions,
12:10testing decisions, a lot of stuff here.
12:12And this is going to be really useful
12:14cuz we'll be able to compare this at the
12:16end to make sure that our implementation
12:19matched the spec. So, now that we've got
12:20the spec, I'm going to go into the same
12:22session, not going to change sessions
12:23here, and now I'm going to say to
12:25tickets. And this is where it will
12:28basically try to turn the spec into an
12:31implementation plan. Each one of these
12:32tickets is supposed to just be the size
12:35of a single context window or a single
12:37smart zone. And if we look here, we can
12:39see that it's kind of given us three
12:42tickets here. So, three slices. I think
12:45that these three slices are a little bit
12:47much. I actually think it can be done in
12:49one slice. Do it in one slice instead.
12:53And so it's now put this in a file. So,
12:55it's put the ticket in tickets.md. Now,
12:58this is quite a bad example cuz it's
13:00kind of copying the stuff that's in our
13:02product requirements documents. So, let
13:03me show you an actual real example. Here
13:05is a spec that I implemented a couple of
13:07days ago to remove a bunch of stuff from
13:10a repo. So, I'm on a real removal spree
13:13recently. And you can see that this is
13:15the spec and underneath it has 11 sub
13:18issues. So, 11 tickets underneath it.
13:21And each of these tickets, so this is a
13:22very detailed spec, each of these
13:25tickets is a single context window
13:27session. So, if we click into here, we
13:29can see it's just pretty short. Most of
13:32the acceptance criteria is already in
13:35the main spec, and so this one is just
13:37literally what do you build in this
13:39session? So, that's number session one,
13:41then session two, then session three.
13:44You can see that how this breaks down a
13:46huge chunk of work into manageable
13:49pieces that the agent can then go and
13:51do. However, here we are left with a
13:53single manageable piece. So, what I'm
13:55going to do is I'm going to clear the
13:57context here. Now, we have everything we
14:00need so that we can just run a bunch of
14:02agents to tackle this problem. So, I can
14:04clear the context, and then I'm just
14:06going to say at tickets here, and I'm
14:09before that I'll say
14:11implement this. So, now because we have
14:14the spec that decides where we're going
14:16and the tickets that decide how we get
14:18there, the agent has everything it needs
14:20and we're ready to implement. Now, when
14:22you're doing this by hand, the idea is
14:23that you then implement each ticket one
14:26by one. So, you don't say do every
14:28single ticket, you say okay, we go and
14:31implement, then we see if we've hit the
14:32smart zone. If we haven't, maybe we can
14:34squeeze in one more ticket here, but
14:37usually I would say you clear in between
14:39every single ticket. Then, once you've
14:41done all of the implementation, you've
14:43got your full thing all implemented,
14:46then you can go and code review and do
14:48the final check against the spec. We can
14:50see here it really was a very small
14:52piece of work actually. It's only 42
14:55.7k, and it's now about to, as part of
14:58the implement, run the code review. As
15:00part of the implement script, it goes
15:01and runs all the type check, runs the
15:03build, run is doing even more
15:06verification, checking AI Hero internal
15:08help, shows only edit commits, and it's
15:10gone and loaded the code review skill.
15:12This review is based on two axes. First,
15:15it compares the work done against the
15:17original spec. This is really useful
15:20when you've done a huge chunk of work
15:22and the agent might have forgotten
15:24things in tickets or the tickets might
15:25have been unspecified. Doing a final
15:27pass means you actually nail everything.
15:30And then it also checks against the
15:32standards documentation that you've got
15:33in your own repo. In this repo we don't
15:35really have any coding standards
15:37documented anywhere, but if it doesn't
15:39detect any, then it uses some classic
15:40ones kind of from Martin Fowler. So it
15:43looks at code smells, tries to figure
15:45out if there's any bad stuff. Doing
15:46these in sub agents is really important
15:48because if you do it in the main agent,
15:51it means that the main agent already has
15:53written the code and agents are often
15:55really bad at editing code or improving
15:58code they've just written. Because
16:00they've wrote it, so they just think,
16:02"Okay, that's fantastic. That's fine."
16:04Whereas if you spawn some agents, then
16:06they're going to have a clear context
16:07window and they're going to do a much
16:08better job reviewing the code. Okay, we
16:10can see that both came back. So
16:14cross-checked every acceptance criteria
16:16against the spec, checked everything
16:18against the standards, and cool. We're
16:20good to go. And it's now committed
16:21against the current branch. Beautiful.
16:23So that is our flow complete. We aligned
16:25before we got started. We created some
16:28spec and tickets in order to make sure
16:30it worked over multiple sessions. We
16:32then implemented it and the implement
16:33skill itself used the code review. This
16:36is the main flow that all of my work
16:38runs through. And the stuff that isn't
16:39in the main flow is stuff that I'm
16:41experimenting with, stuff that I'm
16:42improving, always trying to get this
16:44loop faster, better, easier to run. And
16:48for that, if you're interested in that,
16:50then you should check out my newsletter
16:51for these skills. This YouTube channel
16:52is a great place to be for subscribing
16:54to understanding more about the skills,
16:56but really the good stuff is on the
16:58newsletter. If you want on the day
16:59updates when I ship new skills, when I
17:01add updates to
17:03kind of that you need to keep updated
17:05with, then this is the place to be. But
17:06thank you so much for watching.
17:07Hopefully this tutorial gives you an
17:09idea on how to get set up with the
17:11skills and what the main flow is
17:12supposed to be. Thanks for watching,
17:14happy skilling, and I will see you very
17:16soon.

About this transcript

This page contains the full transcript of mattpocock/skills: A complete AI Coding workflow, end-to-end by Matt Pocock, generated from the public captions YouTube serves with the video. The transcript has 3,717 words across 505 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to choose a caption track available on the video.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, caption language selection, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.