§ 01 · The Hook
The bait, then the rug-pull.
Matt Pocock had been copy-pasting handoff notes between Claude Code sessions for weeks before he admitted it was a pattern worth formalising. The result -- a five-line skill that compresses context into a markdown file and hands it off to a fresh agent -- turned out to be the most-used tool in his workflow.
What the video promised.
stated at 01:01 "In this video, I will show you a deep dive of the skill, why I designed it, what is the point of it, how it compares to built in tools in some of these harnesses like compact, and also how you can get the most out of it." delivered at 16:30
Where the time goes.
00:00 – 01:30
01 · Discovering the handoff skill
Hook: too-simple-to-be-a-skill pattern becomes essential. Introduces the skills repo (97.8k stars), explains handoff concept.
01:30 – 03:20
02 · Course CTA + context window primer
Soft pitch for AI Coding for Real Engineers cohort (June 1). Transitions into explaining context windows and the Smart Zone / Dumb Zone model.
03:20 – 04:49
03 · The Dumb Zone explained
Animated context-bar diagram. Attention quality degrades past ~120k tokens despite 1M context advertised.
04:49 – 06:10
04 · /compact vs /handoff -- the core distinction
/compact resets to smart zone but clobbers session state. /handoff preserves the current session and spawns a clean parallel session.
06:10 – 08:20
05 · The /compact sediment problem
Repeated compaction builds up sediment layers from prior sessions. Useful for debugging long-runners, but inefficient for parallel work.
08:20 – 10:14
06 · Why handoff exists -- the split-session problem
Discovers a refactoring opportunity mid-session. Neither extending nor compacting works. Handoff keeps the current session pure.
10:14 – 12:20
07 · Pattern 1: Handoff during grilling for scope isolation
Live demo: Sandcastle grilling session. Spots an API split. Handoff with stated reason sharpens the grilling (Q2 collapses) and files a GitHub issue via a parallel agent.
12:20 – 15:00
08 · Pattern 2: Grilling to Prototype and Back
Grilling hits an unknown (TLDraw SDK). Handoff spawns a 169k-token prototype session. Prototype returns a handoff doc back to the parent. DIY sub-agent loop.
15:00 – 16:30
09 · Cross-agent handoff (Claude Code to Codex, Copilot)
Because handoff is just a markdown file, it works across any agent. Enables adversarial review workflows.
16:30 – 18:30
10 · Skill design decisions read live
Reads SKILL.md line by line: suggest skills, use pointers not duplication, save to OS temp dir, redact sensitive info, tailor to stated purpose.
18:30 – 19:04
11 · Wrap-up and course CTA
Recap: handoff is essential. Cohort outro.
Visual structure at a glance.
Named ideas worth stealing.
02:15
concept
Smart Zone / Dumb Zone
Context windows have a high-attention early zone (~120k tokens) and a degraded attention zone beyond. Even 1M context windows get dumb past ~120k.
Steal for Any content about AI productivity, context management
13:20
model
DIY Sub-Agent Loop
- Session 1 does scoped work
- Handoff to Session 2 (prototype/task)
- Session 2 returns handoff doc back
- Session 1 continues with enriched context
A manual sub-agent pattern using handoff docs as the communication layer between sessions.
Steal for JoeFlow Sessions orchestrator -- this is the exact model
10:14
model
Scope Isolation via Handoff
Stating WHY you are handing off sharpens the current session by declaring something out of scope, collapsing unnecessary questions.
Steal for Focus content; agent workflow tutorials
Lines you could clip.
02:15
"There is actually a smart zone and a dumb zone in these context windows."
02:58
"Around by the 120k token mark, I start to feel like I am in the dumb zone."
08:53
"What I really wanted to do was just say, okay, I want to complete this other thing in a separate session and keep my current session pure."
15:06
"It is almost like you have done a kind of DIY sub agent where you are able to use a context window for one specific task, compress your learnings from that task, and pass it back to the parent."
How they spent the runtime.
Hook length90s
Info densityhigh
Filler5%
Things they pointed at.
10:22productSandcastle (software factory)
How they asked for the click.
01:15
product
"AI coding for real engineers. A two week cohort for folks who want to use AI coding tools for shipping quality code, not slop. It starts on June 1."
Double-pitched (1:12 and 12:00). Non-intrusive, woven in naturally, relevant to audience.
Word for word.
HOOK opening / re-engagementCTA the pitch metaphor analogy story
00:00HOOKA few weeks ago, I noticed myself doing something with agents that I thought was very clever, but I thought it was just too simple to require a skill. For those who don't know, I'm constantly thinking about skills.
00:13HOOKI'm constantly thinking about how to package my instincts and coding practices into reusable skills. And this has meant my skills repo has almost a 100,000 stars at the time of recording.
00:23HOOKThe skill that I started to think about was a handoff skill. And the theory was that this skill would take the context window of the current session and compress it down into a markdown file that could be handed off to another session. And so a couple of weeks ago, I shipped this.
00:38HOOKIt's inside skills, inside productivity, and it's inside handoff here. And it's a very, very simple skill.
00:45HOOKIt says to write a handoff document summarizing the current conversation so a fresh agent can continue the work. Save it to the temporary directory of the user's operating system, not the current workspace. I put this into my skills folder as an experiment to see how much I would use it, and it turns out I used it a lot.
01:02HOOKCTAIn this video, I'm gonna show you a deep dive of the skill, kind of why I designed it, what is the point of it, how it compares to built in tools in some of these harnesses like compact, and also how you can get the most out of it to make the most of your grilling sessions. And if you dig the kind of stuff I've been showing you, then you will love the course that I've put together which is AI coding for real engineers.
01:24HOOKCTAA two week cohort for folks who want to use AI coding tools for shipping quality code, not slop. It starts on June 1. We're doing a discount right now.
01:33CTAGet into the link below so you can check out. Let's start first of all by explaining why I made this skill and how it differs from compaction which you may have heard of before. When we're inside a session like this, uh, coding session, we essentially as we, you know, converse with the agent, as it does tool calls, as it makes file edits, then this context window is gonna be filled up and filled up with more and more stuff in it.
01:57More and more tokens will fill up the context window. Now in the harness I use, Claude code, it's the context window is huge. Right?
02:03You get 1,000,000 tokens worth of context window. But there is actually a in these context windows. Early on in the context window, you are gonna get much better performance from the agent because the attention relationships
02:18are not so strained there. Because there's much fewer tokens to calculate,
02:24fewer attention relationships between those tokens, then the agent's attention isn't so diffuse. In other words, it's better able to focus when there's less content in there. This means that as your conversation develops, you're going to get dumber and dumber and dumber responses from the agent all the way up to going up to, you know, 800,000
02:43tokens, which personally I've never been in because around by the 120 token mark, I start to feel like I'm in the dumb zone. So this means, yes, that even though Anthropic advertises a ton of context window on these models,
02:58really for, you know, proper smart tasks, you've only got about a 120 to work with, which means you need to budget really efficiently and you need to be aware of your context window at all times. So the question then becomes, what do you do when you're starting to hit up against this dumb zone?
03:13How do you recover your conversation? How do you continue the conversation beyond the dumb zone while staying smart? And the answer to that is compact.
03:22What compact does is it will take a large conversation like this and summarize it. So you go essentially from near to the dumb zone to all the way into the smart zone here.
03:34And there's even sometimes an auto compact buffer depending on what harness you're using and whether you've got it turned on, Which means that when you're near to the end of the context window, let's say deep in the dumb zone, the auto compact buffer will kick in and automatically summarize your conversation inside
03:50a new session. This summary usually looks like the files reference, so just a list of files that have been referenced. The things that you said in the conversation are usually included,
04:00and the general tone of the conversation as well. This is then included as a little nugget at the start of the new session. And as you build up context in the new session, then you're continually referencing the old session.
04:12This means as you continue to compact and compact, you're gonna end up with this kind of here from previous conversations. And this can be a little bit inefficient, but it's also a decent way if you want to do certain types of sessions where you just need to barrel on on the same problem again and again and again.
04:30It can be really useful for debugging actually because you can compact all of the other options that you've tried and then continue to try different things, hit the barrier, and then compact again to just save your state essentially. So it's a way of doing a long running session,
04:47but it's only really one session. So I continue to find compact a really really useful tool for creating these long single sessions. But what I started to notice was I wanted to do other things with compact.
04:59I wanted to compact into another session. For instance, let's say I was in one session here and while I was in this session, I noticed a little refactoring opportunity. Something that was totally out of bounds, out of scope from my current session, but I knew I would need to get there eventually.
05:15So what were my choices? I could extend my current session, but then I would end up with this sort of like diluted context where I was half working on one thing, half working on the other, and I would definitely hit the dumb zone.
05:27Right? So I probably wouldn't be able to finish my initial goal. I could compact,
05:32but then I would clobber all of the progress that I'd made in my current session. Right? What I really wanted to do was just say, okay, I wanna complete this other thing in a separate session and keep my current session pure.
05:45In other words, this was what I wanted. I wanted to essentially take the context or take just the slice that pertain to this extra bug fix, hand it off to another session, and then these two could just run independently. And so for a while, what I was doing was saying, okay, take the stuff in my current session.
06:02I want to fix this particular bug. Write me a hand off dot m d document so that I can then just pass that into another agent. And it turned out I was doing this so freaking often that I just decided, okay, I need a skill for this.
06:14I most often use hand off while I'm grilling here. Here, I'm inside a grilling session that I did for planning some future features for Sandcastle, which is my sort of software factory.
06:24And what you can see here is that I'm kind of answering some questions. I'm only in q two of this grilling session, so not a long one. And I say here, I think in future, we may want to move the iterations and the completion signal onto a separate API.
06:37In fact, let's hand off that task to a separate agent. You can see here that when I'm defining hand off, what I'm saying, I'm saying the reason why I'm handing off and exactly what should be in that document.
06:50This does two things. First of all, it actually sharpens the current grilling session I'm on. So it says that given that constraint q two collapses.
06:58So it doesn't actually like, it helps my current grilling session because I'm saying that's out of scope. We'll pick that up somewhere else. It then goes and creates a markdown file just here with the focus for the next session, file a GitHub issue, and eventually design for splitting iterations in the completion signal into a separate API.
07:15And then later, I just pass this into a another agent in order to create the issue. Simple. Another pattern that I really strongly recommend is handing off during a grilling session to prototype.
07:27When you're grilling, when the agent is asking you questions from a grill me or grill with docs, which are more of my skills, you will often find those two categories of questions you need to answer. There are the kind of known unknowns, the ones that the agent can ask you about.
07:42And then there's stuff that you really need to see in code or need to see prototyped. This can be really true with like UI prototypes or complicated bits of logic that you're not quite sure how to deal with yet.
07:53So in this grilling session, we're down to question 13 actually, and we've got a sort of final, uh, resolution from the agent. And then we can see I say hand off to prototype the difficult bits here.
08:05The window communication, the TL draw SDK integration, which was something I was building at the time. It creates the hand off and then I go and implement the prototype on that branch. So in the prototype session, this ended up being a huge session.
08:17So a 169 k tokens. So way bigger than would have fit inside the grilling.
08:22And what I did was I created this prototype of the UI and the kind of interaction that I wanted to see. And then I said, okay, let's hand this off back to the grilling session that spawned this. Take all of the learnings from the prototype, anything that's not directly captured in the prototype itself or that's non obvious, give me a hand off document that I can pass back to the planner.
08:43This is actually a really common pattern that I'm using here where you have the initial session where you do some work, you hand off to another session. That session then creates another hand off document and then passes it back to the original session. It's almost like you've done a kind of DIY sub agent where you're able to use a context window for one specific task, compress your learnings from that task, and pass it back to the parent.
09:07Then I was able to finish the grilling session and create some proper PRDs and issues with the prototype in there. So it's incredibly rich pattern for
09:18actually getting what you need out of AFK agents and using prototypes. It's very very cool. It's worth saying too that the thing that's cool about just using like a markdown document here and not relying on kind of native agent stuff is that you can have this first session be Claude code, but you can just pass this to another agent.
09:37Right? You can pass it to codecs or pass it to, you know, Copilot CLI, whatever you're using. So if you want to do any kind of adversarial review or any kind of,
09:46you know, interaction between different coding agents, this is a very, simple way to do it. We should also just read through the final bits of the skill here just so you understand the reasoning behind everything. The theory here is include a suggested skill section in the documents which suggest skills that the agent should invoke.
10:02I added this because sometimes it would I use skills to kinda define the flavor of that session.
10:10And so having a suggested skill section means that you can kind of just paste the hand off document into the new session. It will invoke the skills needed like grill with docs or diagnose or prototype or something. And then you're kind of good to go.
10:24So you don't need to think about the skills that you need to use in the next session. It's pretty handy. Another one is do not duplicate content already captured in other artifacts.
10:32I would often find these hand off documents just got really big, and they were just duplicating stuff that was already present either in other markdown files or in resources like GitHub issues or things like that. So it's basically saying just use pointers instead of, um, you know, repeating everything that's in the documents.
10:48I also really strongly believe that you should save these hand off files to the temporary directory of the user's OS. In other words, these hand off files are disposable. They are not something to be kept around for a long time to rot in your code base as documentation.
11:02Another one is redact any sensitive information, API keys, passwords, or PII. This is, you know, pretty essential. You don't want these floating around in markdown files in just random places.
11:13And finally, if the user passed arguments, in other words, what the next session will be used for, treat those as a description as to what the next session will focus on and tailor the doc accordingly. I think of this as essential for handoff because in order to write a decent document, the agent needs to know what the next agent session is going to focus on.
11:30Every time I use handoff, I always describe the purpose, the reason that we're handing off because I just can't see how you would write a good handoff document otherwise. And of course, dictation makes this really easy because I just blast it out and then we're good to go.
11:44So there we go. That's hand off. This is an essential skill in my toolkit that you know just like a lot of my other skills didn't exist but a few weeks ago.
11:52If you've been enjoying my skills then you should check out the cohort course. It is an absolute banger. We had about 2,500
11:58people take it last time and I'm expecting, you know, a decent whack this time too. Other than that, thank you so much for watching. My bookshelf behind me is filling up with new coding books that I'm gonna be reading over the next couple of I'm thinking about maybe making a sort of what's on my bookshelf video of recommended books.
12:15CTAAnd I don't know, if you like that, then maybe give us a like and a comment or let me know what you want to see next. Either way, thanks for watching and I'll see you very soon.
— full transcript
§ 05 · For Joe
The skill-as-content flywheel.
Steal the workflow
Matt ships a real tool he uses daily, makes a 12-minute video about it, and sells a cohort -- each step feeds the next.
- Ship a real tool you use every day, not a tutorial about someone elses tool.
- The /handoff pattern maps directly to JoeFlow Sessions -- DIY sub-agent is the same mental model as morning batch launcher.
- The Smart Zone / Dumb Zone metaphor is steal-worthy for any content about AI productivity.
- Demonstrated patterns beat explained patterns -- every demo here uses real session footage, not slides.
- The state-the-reason-for-handoff rule sharpens the current session by declaring scope -- worth building into JoeFlow UX.
§ 05 · For You
How to stay sharp across long AI sessions.
If you use Claude Code or any AI coding tool
Your AI coding sessions get noticeably worse after about 120,000 tokens -- here is the practical fix.
- Keep sessions focused on one thing. When a second task surfaces, hand it off rather than pile it in.
- Always describe why you are handing off, not just what. This forces clarity and scopes the new session correctly.
- Handoff docs go in your OS temp folder -- treat them as working notes, not permanent documentation.
- You can pass a handoff doc to any agent (Claude, Codex, Copilot) -- it is just a markdown file.
- The DIY sub-agent loop (grilling to prototype to grilling) is a repeatable pattern for any feature you cannot fully plan without trying it first.
