§ 01 · The Hook
The bait, then the rug-pull.
Process is the product. Matt Pocock opens with a deceptively plain observation: AI agents have no memory, which means the only way to get reliable output is to encode senior engineering decision-making into the prompts themselves.
What the video promised.
stated at 00:30 "These skills help me encode my process so that AI has a really strict path it can walk down every single time." delivered at 16:18
Where the time goes.
00:00 – 01:18
01 · Intro - process is the product
Sets up the argument: agents have no memory, so process documentation is the multiplier. Shows the skills repo README.
01:18 – 03:55
02 · /grill-me
Three-sentence skill forcing Claude to interview you about every branch of a design tree before touching code. Live 16-question session demonstrated.
03:55 – 06:00
03 · /write-a-prd
Five-step skill producing a GitHub issue PRD with problem statement, solution, user stories, and implementation decisions.
06:00 – 08:29
04 · /prd-to-issues
Converts the destination PRD into tracer-bullet GitHub issues with blocking relationships, safe for parallel agents.
08:29 – 12:04
05 · /tdd
Red-green-refactor loop for autonomous agents. Tests verify behavior through public interfaces, not implementation.
12:04 – 16:18
06 · /improve-codebase-architecture
John Ousterhout deep-module philosophy. Spawn 3+ sub-agents with radically different interfaces, compare, recommend hybrid, create GitHub RFC.
16:18 – 16:42
07 · Course pitch + outro
Claude Code for Real Engineers - 2-week cohort. Curriculum overview shown.
Visual structure at a glance.
Named ideas worth stealing.
02:00
concept
Design Tree
From Frederick Brooks: walk every branch of a design decision tree before committing to implementation.
Steal for Mental model for why upfront design matters in AI-assisted development.
08:05
concept
Deep Module Philosophy
A deep module has a small interface hiding a large implementation. Makes code testable at boundaries and easier for AI to navigate.
Steal for Backbone for why TDD and architecture improvement go together.
07:00
concept
Vertical Slice / Tracer Bullet
Each issue cuts through ALL integration layers end-to-end, not a horizontal slice of one layer. Flushes unknown unknowns first.
Steal for Task breakdown framework for any multi-issue agent project.
08:30
model
Skill Chain
- grill-me
- write-a-prd
- prd-to-issues
- tdd
- improve-codebase-architecture
Five skills chaining: idea to shared understanding to destination doc to journey to implementation to refactor.
Steal for Template for a Claude Code workflow presentation or course structure.
Lines you could clip.
00:59
"Skills don't have to be long to be impactful. You've just gotta choose the right words for the LLM at the right time."
15:05
"If you have a garbage code base, the AI is gonna produce garbage within that code base."
15:15
"The most successful way to get code quality up from agents is just to treat them like humans. Humans with weird constraints."
00:30
"At your fingertips now, you have access to a fleet of middling to good engineers that you can deploy at any time. But the weird thing about these engineers is they have no memory."
How they spent the runtime.
Hook length78s
Info densityhigh
Filler5%
Sponsor blocks
- 00:56 – 01:18 · own course
- 15:38 – 16:42 · own course
Things they pointed at.
01:50bookThe Design of Design
08:05bookA Philosophy of Software Design
How they asked for the click.
00:56
product
"Claude Code for Real Engineers. Two week cohort starting March 30, 40% off for 7 days."
Pitched twice - near the top and at the end. Course landing page shown full-screen via picture-in-picture.
Word for word.
HOOK opening / re-engagementCTA the pitch metaphor analogy
00:00HOOKI've been an engineer for nearly a decade. And in all of that time, right now, process has never been more important. At your fingertips now, you have access to a .
00:13HOOKBut the weird thing about these engineers is they have no memory. They do not remember things they've done before, and so you need extremely strict and well defined processes to get those agents to actually do things that are useful. So this means that you as a developer are looking constantly for ways to steer your agents, to keep them on the right track.
00:32HOOKAnd for me, that has resulted in a lot of skill building. Here's the repo of all the skills that I'm using right now, each of which I have gone through and designed. Some of these I use relatively rarely, but some of them I use every single day.
00:44HOOKCTAAnd these skills help me encode my process so that AI has a really strict path it can walk down every single time. And as a result of using all of these skills, the code quality that the AI is producing has shot up. Now if you think that process is important and that real engineering skills are important, then boy, do I have a course for you.
01:02CTAThis course is called Claude Code for Real Engineers. It's a two week cohort that starts on March 30. And for seven more days, it is 40%
01:11CTAoff. If you feel like you're behind the curve on Claude code and you want to get way ahead of the curve in just two weeks, then blimey, this is the place for you. But let's start talking about our skills with number one, which is maybe my favorite.
01:23This is the grill me skill. This skill, yes, it is just three sentences long, and let's just read it out in full to describe what it does. Interview me relentlessly about every aspect of this plan until we reach a shared understanding.
01:35Walk down each branch of the design tree resolving dependencies between decisions one by one. And finally, if a question can be answered by exploring the code base, explore the code base instead. The concept of a design tree comes from this book by Frederick p Brooks,
01:48which is the design of design. Actually, Actually, don't know if it comes from this book, but this book is where I saw it first. The design tree is this idea that as you're coming towards a design, you need to walk down all of the branches of a design tree.
02:00For instance, you might be designing a search page and you need to decide whether you want an advanced search or a text box. If you choose advanced search, then you need to figure out all of the filters and all of the sorting methods that you need on advanced search. And you keep on walking down the tree until you figure out your design kind of in full or as full as you can before committing to code.
02:18This grill me skill, when I invoke it, I invoke it when I want to reach a shared understanding with the LLM. I found that relatively recently, Claude code will tend to just spit out a plan really early when I go in plan mode, and it tends to just create a document before I feel I've reached a shared understanding with the LLM.
02:36But the grill me skill forces that conversation. It forces the LLM to interview me about every single part. Here's a conversation I had with Claude recently about adding a feature to my course video editor code base.
02:47I gave it some research that I'd done in a markdown file and I said, grill me. I'd like to think about adding this to the right page. It loaded up the skill and the thing I want to show you is just how many questions it asked me.
02:58So the first thing it did is it just explored the relevant stuff in the code base, which is good. Then we zoom down, we can see it ask question one, where does the document live? Question two, what's the UI layout?
03:07Question three, which modes get the document panel? Question four, the document life cycle? Question five, what does the right document tool look like?
03:14Question six, the edit tool shape. Question seven. Question all the way down to question nine, question 10, question 11,
03:21question 12, all the way down to question freaking 16 here. And this is a relatively short grilling session in my book. I've had sessions where I've sat there for nearly half an hour forty five minutes with the AI answering questions on really complex features.
03:34You know, that could be thirty, forty, 50 questions
03:38all from this absolutely tiny skill. That's one thing I want you to take from this.
03:43Skills don't have to be long to be impactful. You've just gotta choose the right words for the LLM at the right time, and this design tree resolving dependencies has just been absolutely great for me.
03:52By the way, if you want these skills, then they will be at a link below. Once I have reached a shared understanding with the LLM, once I have grilled my idea and sort of understood all of its ramifications, if I then decide I want to implement it, then I invoke my next skill, is a write a PRD skill.
04:08I actually did this in the conversation we were just looking at. So it said anything I've missed or got wrong, and I said write a PRD. I was suffixing it with user because I have some that sort of live in the project.
04:18So that's the reason why I did that. Here's what the skill looks like. This will be invoked when the user wants to create a PRD.
04:23You may skip steps if you don't consider them necessary. So for instance, in the previous conversation, it said, we've already done a deep interview. Let's move to step four.
04:29So step one is to ask the user for a long detailed description. Then number two is to explore the repo to verify their assertions. Number three is basically to interview the user relentlessly.
04:38So just a copy of the grill me skill again. Next, we sketch out the major modules you will need to build or modify to complete the implementation. We're gonna look at this later because it links to skills I'm gonna show you in a bit in this video.
04:49And finally, once you have a complete understanding of the problem and the solution, use the template below to write the PRD, and the PRD should be submitted as a GitHub issue. The way that my dev flow works is I take these PRDs in GitHub, I turn them into more GitHub issues that reference the parent PRD, and then I have a Ralph loop that just loops over each issue until it's done.
05:09If we go back to the conversation where we were before, we can see that it created this PRD here. This was four days ago as you can see. We've got a problem statement.
05:17The article writing page currently regenerates the entire document on every AI interaction. And the solution was to add a split pane document editing experience to the article writer. Chat stays on the left, a new document panel blah blah blah.
05:27So this is a big feature. We're adding document editing to a kind of AI chat feature. The important thing here is the user stories.
05:34There are many, many user stories as part of this. And this comes from agile methodology, and we're basically trying to describe the kind of desired behavior of our system in language, which is not an easy thing to do.
05:44I still haven't properly, like, landed on the right format for these. This is just something I sort of like. But you could easily use, like, Cucumber language for these or whatever you're kind of used to do, used to working with.
05:55We then zoom down to the bottom, and we just sort of pass in some implementation decisions. The implementation decisions here, we don't want to be, like, over prescriptive because we want these to be durable. Because if the code ends up getting out of date with the PRD, then we're gonna have issues when we actually go to implement it.
06:11But you can see the theory here. This is the kind of it's a really good description of the destination that we're going to.
06:18But what we don't have from the PRD is the actual journey, is the is the way we're gonna get to this destination. And if we lead back to that conversation, this is where I use my next one, which is PRD to issues. What this does is it takes a PRD, takes the destination, and it turns it into a Kanban board of different issues that can be independently grabbed.
06:38So the first step in here is it locates the PRD. If the PRD is not already in your context window, fetch it with this instruction. Explore the code base if you need to.
06:46And then draft vertical slices. It's not always clear how you should break a PRD down into individual tasks.
06:54This is something that developers have been doing for yonks. Right? And we've developed a kind of intuition for how to do it.
07:00In my opinion, the best way to do it is to break it into tasks that flush out the unknown unknowns really quickly. For instance, if you're integrating with a new kind of service or integrating two things which you haven't integrated before,
07:12then you should do that work first because it's gonna give you feedback on whether your approach is even valid. The right analogy here is the tracer bullet analogy. I won't go into what that means, but basically each issue is a thin vertical slice that cuts through all integration layers,
07:25not a horizontal slice of one layer. In the conversation, it broke down that really complicated PRD into just four slices. It first created a kind of engine with some tests applied to it.
07:35This is actually quite a good vertical slice because this was the engine that was going to then power the rest of the kind of setup. If this engine wasn't working for whatever reason or it wasn't feasible, then we would need to flush that out quickly. And this is what this, um, breakdown does.
07:49The PRD two issues also establishes blocking relationships between the tasks. For instance, number two here is not actually blocked by anything, so it can be picked up independently to one. This is really useful if you have a parallel agent setup where you can actually fire two agents at it at once, for instance, in, like, background tasks.
08:07And it also means that in the future, you can add other issues to this, like, uh, QA issues that you find or things that need to be improved, and you can then establish blocking relationships between that and the other things. We can see that number three here is blocked by one, the editing engine, and the number four, the Monaco editor toggle is blocked by number two.
08:25So I said yes to all of these, and it created then all of these GitHub issues. These issues reference the parent p r d so that the local agent can fetch it and view it. And it sort of just breaks down what to build really.
08:37And crucially, it references the previous user stories in the p r d. We can then see a comment actually from Claude code that ended up implementing this.
08:45It said a pure function document editing engine with 28 tests covering all acceptance criteria. And we can then take a look at the commit that references this issue. So this was basically my Ralph loop came and just implemented this based on the issue, commented on it, closed it, and then the next issue was unblocked.
09:00So so far, the grill me skill can help you flesh out an idea. The write a PRD skill can help you take that idea and turn it into a document. And then the PRD ish or PRD two issues skill helps you then turn that destination document into an actual journey.
09:16But then how do you actually execute on that skill? How do you make it like how do you make the implementation really rock solid and increase the code quality of what gets produced? We have got a TDD
09:27skill. TDD means test driven development. And when you invoke this skill, it basically forces the agent or encourages the agent rather to follow a red green refactor loop.
09:37Unusually for my skills, there is actually a lot in here. So it's not just the skill itself. It's also, uh, ideas on refactoring, on mocking, on what deep modules are.
09:46Doing really really good TDD has been the most consistent way that I've improved agents outputs. So let's have a look at what's actually in here. What we can see is I'll just skip over the philosophy stuff.
09:57I'll let you guys read that. We are basically looking at this workflow. Yeah.
10:00Now the first one here is really important. Confirm with the user what interface changes are needed. Now I made a video on interfaces and implementation recently, but let me just give you the pricey.
10:10When an AI looks at a bad code base, it will look at or it will see something like this where it has a ton of tiny modules here that are kind of undifferentiated. They're not really grouped together. It doesn't really understand how these things relate.
10:24And And so it has to do a lot of work kinda working out, okay, what's responsible for what? What are the dependencies? How does this actually how does the code base even function?
10:31Whereas if you restructure this into several larger modules with just kind of thin interfaces on top, the interface being the functions that are actually exported from this, the, uh, things that the callers actually call, then it's a lot easier for AI to navigate this code base, and it's a lot easier to work out how to test these modules because you just test them at their interfaces.
10:52You test them at their boundaries. You can check out the whole video on that below. So what this TDD skill is encouraging here is basically trying to make these interface changes
11:01really top of mind for the AI to get it to understand that when it changes an interface, that's an important decision it needs to take time over. You confirm with the user which behaviors to test. You design the interfaces for testability linking to a doc.
11:14And then we have some more stuff around planning here. It then goes into a lovely loop where it writes one test at a time and it writes the test first. Now I've talked about red green refactor before, so I'll link the video below if you're interested.
11:26But I found that red green refactor with agents is incredible. And it basically does this loop until it's complete. It just writes a failing test, then writes the code to make that test pass.
11:36And finally, it goes through and looks for refactor candidates. I haven't found that this is amazing. It hasn't been brilliant because often LLMs are quite, uh, no.
11:46They're quite reluctant to refactor their own code. If you were to clear the context of the LLM, then it would just sort of wipe its own memory, and it would be a lot less precious about the code that it's just written. But while its own code is sitting in its own context window, it's quite reluctant to change it.
12:00So this TDD skill is what I prompt my Ralph loops with in order to get them to do red green refactor. Now TDD demands a lot of you or rather it demands a lot of your code base. TDD is really hard to do in a badly structured code base because the test boundaries of this are really unclear.
12:16Should it just sort of test these modules on their own? Should it test these modules on their own? What are the boundaries here?
12:23Whereas when your code base looks more like this, then it's a lot easier to test because the module boundaries are really clear. So wouldn't it be great if there was a skill that made your code base look more like this? Well, isn't it nice?
12:34We've got an improved code base architecture skill. The process for this one is that we explore the code base and explore it kind of like naturally as an agent would. We're trying to find confusions.
12:44We're not like we're trying to sort of surface naturally what the AI finds confusing so that it can then sort of, like, help it out later. Where does understanding one concept require bouncing around between many small files? Where have pure functions been extracted just for testability but the real bugs hide in how they're called?
13:01Where do tightly coupled modules create integration risk in the seams between them? All of these are questions that a senior engineer would be asking about your code base. Number two is you present candidates.
13:12So you present a numbered list of deepening opportunities. In other words, opportunities to deepen shallow modules in your code base into deeper ones. The user then picks a candidate,
13:22and then you design multiple interfaces. So it says to spawn three sub agents in parallel, each of which must produce a radically different interface for the deepened module.
13:32In other words, we're extracting that code and designing possible ways that it could look in the future. Designing it in multiple different ways is a really great way that you can then decide on the right idea. I've seen this agent spawn like five different sub agents for a really big refactor.
13:47The coolest thing about this is you don't need to know a lot about interface design in order to get this working. After comparing, give them your recommendation which design you think is strongest and why. And if elements from different designs would combine well, then propose a hybrid.
13:59Notice that I've made this really language agnostic, really kind of sort of everything agnostic, really. You can just run this in any code base and just get a decent answer for how it could be improved.
14:09There might be four or five candidates that really could use some work. But really, I think you should only be sort of doing one of these at a time because they really are quite hard to get your head around. And they require a human in the loop to sit with them and improve the code base because these decisions do require taste.
14:26Finally, it creates a GitHub issue. So it creates a refactor RFC as a GitHub issue using g h issue create. Usually, once this is done, I will then go with my PRD to issues, uh, skill, reference that GitHub issue that's just been created and get it to, you know, this describes the destination.
14:42We then need a journey to get there. So just doing this every so often in a code base, you know, once a week just to identify opportunities. Or if you have a sudden surge of development and you kind of create a whole sort of extra wing of features, then this skill will be really really useful in just making sure it conforms to the rest of the code base, making sure that it's not too sloppy.
15:03And as you keep running this, as you keep refining your code base, you're gonna notice the quality of the agent's output goes up. Because the old adage really does apply. If you have a garbage code base, then the AI is gonna produce garbage within that code base.
15:15Because to be honest, if you took all of these skills and just said, okay, this is like a little mini markdown book of processes for humans, then it wouldn't look out of place. I found that the most successful way to get code quality up from agents is just to treat them like humans.
15:30CTAHumans with weird constraints. Sure. Humans that, uh, have no memory and are just sort of cloned come out of the birthing pod and go right to work.
15:38CTABut if you like me think these real engineering skills are super important, then this course is absolutely for you. What I noticed while I was creating the course is that I'm really not teaching Claude code that much. I'm teaching kind of what are sub agents.
15:50CTAI'm talking about the constraints of LLMs, the sort of weird smart zone dumb zone stuff with a context window. We're talking about steering, which is essentially just a way of documenting stuff inside your code base. How to tackle massive tasks,
16:03CTAunderstanding tracer bullets, and building those into our skills. Understanding how to build really great feedback loops and doing exercises with them and crucially how to hook these up to an autonomous agent. Every part of this course just sort of like leads onto the other and I'm super happy with how it turned out.
16:19CTASo over the course of two weeks, you'll be working through that self paced material with me as your guide in Discord and on live office hours. And if that sounds fun to you, then the link is below. Thanks for watching folks.
16:29CTAI'll be coming back with a lot more stuff this week. What would you like me to cover next? I find the intersection between this real engineering and AI is like it's such a awesome place to make content about.
— full transcript
§ 05 · For Joe
Steal the skill chain.
Process-first Claude Code playbook
The five skills form a complete, repeatable workflow from vague idea to production-quality code, and each one is three to fifty lines of markdown.
- Build a grill-me skill first: three sentences that force the model to interview you before touching code. Ship nothing before this.
- Make write-a-prd output GitHub issues, not local docs. Issues become the memory the agent fetches on every task.
- Use prd-to-issues to break work into vertical slices through ALL layers, not horizontal layer-by-layer sprints.
- Wire tdd into your autonomous loop so every issue gets red-green-refactor by default.
- Run improve-codebase-architecture weekly. Shallow modules are the number one reason AI outputs degrade over time.
- Skills compound: the chain is the system, any skill in isolation is half the value.
§ 05 · For You
How to think before you build.
For anyone using AI coding tools
The reason AI-generated code often disappoints is not the model, it is skipping the thinking step. These skills are structured ways to think first.
- Before asking AI to build anything, spend 10 minutes describing the problem fully. The interview process surfaces gaps you did not know existed.
- Write down what done looks like before starting. A one-page problem statement prevents three rounds of rework.
- Break big tasks into the smallest possible pieces that still work end-to-end.
- If AI-generated code feels hard to test, that is a signal the code structure needs work, not the tests.
- Revisit architecture periodically. Small structural improvements compound into dramatically better AI outputs over time.
