# Watch me ship a 21,000-line feature with mattpocock/skills

> Source: <https://www.aihero.dev/watch-me-ship-a-21-000-line-feature-with-mattpocock-skills~ez95n>
> Published: 2026-11-18 17:16:55+00:00

**Recommendation:** Dictate the problem and its rationale rather than a fixed spec, keep a glossary of project concepts in the agent's context, and validate candidate names against real sentences before building tables and modules from them.
More in the playbook "Working with AI coding agents": <https://wpnews.pro/playbooks/coding-agents>

# Watch me ship a 21,000-line feature with mattpocock/skills

A real feature, in a real repo, end to end: grilling, prototyping, a spec and tickets, AFK implementation, and reviewing a 21,000-line PR.

## On this page

You've been asking again and again for me to show you what my development process looks like. This is a real walkthrough, not a tutorial: one real feature in my Course Video Manager, from a vague idea to merged code, using the [skills](https://www.aihero.dev/ai-coding-dictionary/skill) from my skills repo at [aihero.dev/skills](https://www.aihero.dev/skills).

I focus hardest on two of them: Grill With Docs and Retro.

## [The feature](#the-feature)

The Course Video Manager is where all of my courses and videos get created. It has a thumbnail creator: it captures my face, cuts out the background, and lets me paste a diagram next to it.

The problem is the diagram. I have to swap over to the diagram view, screenshot part of the window, paste it in, and if I've positioned it wrong, go back and screenshot it again. What I really want is to draw on the thumbnail itself, with the diagram integrated with the picture of me.

I really didn't have a clue how I was going to build this. I just knew it was something I wanted.

## [Choosing a skill](#choosing-a-skill)

When I start a new piece of work, I think through a decision tree. What I'm creating is a diff between the old codebase and the new one. If that diff is really small, I can probably just one-shot it. This one was big, so I went with Grill With Docs. If it turns out bigger than I thought, it can always bail out into Wayfinder. I prefer starting with Grill With Docs because if it ends up smaller, I don't pay the overhead of a Wayfinder session.

## [Grilling: prompt with the why](#grilling-prompt-with-the-why)

I explain the problem by dictation, and I think a lot about the *why*. If I give the agent the why, it feels a lot more empowered to produce a solution itself, or to have a discussion about the solution. If you come to it with a *what*, "I want to do X, Y, Z", it often won't come up with that creative an answer.

Notice how loose the language is at the start. We haven't figured out the right names for things yet. As [grilling](https://www.aihero.dev/ai-coding-dictionary/grilling) goes on, the idea gets clearer and clearer until we end up with a nice set of words for the things we're building. And once we're there, we've kind of built the feature.

You should be driving this conversation. The agent is not grilling you; you're in a conversation with it. So feel free to say "we've talked enough, let's go and create some code now." And when you're at the crux of something, you can narrow it: "for now, let's just focus on this question. Ask me one question at a time until I say otherwise."

## [The glossary is the data model](#the-glossary-is-the-data-model)

The CVM has a `GLOSSARY.md` that is my pride and joy: about 560 lines defining every main concept in the repo. A diagram, for instance, is a group of diagram snapshots, each a copy of the diagram's drawing at the moment a clip is filmed.

Because the glossary is in the agent's context, I can say something pretty rich in very few words: the thing we're putting in the thumbnail isn't really a diagram, it's more like a single snapshot. That probably sounds like jargon if you don't know the project. The model understands it.

We're this obsessed with language because the language forms the data model that everything else sits on. Once we have names for these things, we have names for database tables, we know how they reference other parts of the system, and we can create tables and modules from that.

The naming wasn't easy. The agent proposed "thumbnail drawing", which I hated: a drawing and a diagram conflict really hard. So I asked for scenario testing: a table of candidate names (thumbnail diagram snapshot, thumbnail diagram, thumbnail scene) run against real sentences you'd say about the system. "Thumbnail scene" got all the ticks, but it's not how I talk, and we already have a scene elsewhere in the glossary. We landed on **thumbnail diagram**, with an ADR saying it's a diagram, but not a diagram.

## [ADRs: Chesterton's fence](#adrs-chestertons-fence)

The glossary describes the application as it is now, as does the code. The ADRs explain *why* we made those decisions. When you're touching a part of the app that's old and mature, without them you'd be guessing.

It's a classic Chesterton's fence: don't remove a fence until you know why it was put up. ADRs keep track of why the fences were put up. I'm investing time in them so that future runs understand the context for every decision, and I keep getting better grilling sessions on this project.

At its best, grilling feels like rubber ducking with a really respected colleague who understands the codebase. By talking your thoughts through, you get to a more concrete solution before you've written any code.

## [Grilling keeps you in touch with the codebase](#grilling-keeps-you-in-touch-with-the-codebase)

Talking about your system surfaces little things to improve. Here, "component" in the glossary bumped up against React components, so it became **diagram component**. Grilling isn't only about the feature you're on. It's a ritual, a ceremony for thinking about the code. That's why I spend so long on it.

## [Prototypes](#prototypes)

Some questions are about feel: how does it look, how does it feel to use? I won't know the trade-offs until I have a go. So the agent ran my prototype skill in a [subagent](https://www.aihero.dev/ai-coding-dictionary/subagent) and built three variants while we kept grilling.

[Prototyping](https://www.aihero.dev/ai-coding-dictionary/prototyping) several options helps most when it builds something you don't like, because that often tells you more than something you do like. Variant B was worse than I expected. The split view was garbage. Variant A, with a "ghost face" while the pointer is in the frame, was the one.

This [human-in-the-loop](https://www.aihero.dev/ai-coding-dictionary/human-in-the-loop) time is so essential because it reduces the decision space for the agent. We know exactly how it should look, and exactly the data model. All the agent then has to do, once we run it AFK, is plug those two things together.

## [Smart zone, dumb zone](#smart-zone-dumb-zone)

The prototype agent got reopened at about 260k tokens, which is already punching deep into its dumb zone. I'd have preferred a fresh subagent with just that one problem.

Do I still stand by the [smart zone and dumb zone](https://www.aihero.dev/ai-coding-dictionary/smart-zone)? The more tokens in the [context window](https://www.aihero.dev/ai-coding-dictionary/context-window), the more relationships between tokens the model has to keep track of. But for me it's become less about the risk of hallucinations and more of a cost and optimisation thing. The agent just produces worse work in the dumb zone, and I get better results in the smart zone. Plus, running at 750k tokens is very expensive, because all of those previous tokens get billed again.

## [Spec and tickets](#spec-and-tickets)

To Spec writes the [spec](https://www.aihero.dev/ai-coding-dictionary/spec): a destination document for where we want to be at the end of all the sessions. To Tickets scopes each session: every subagent gets a single [ticket](https://www.aihero.dev/ai-coding-dictionary/ticket) as its piece of work. Ours came out as a GitHub issue with around 47 user stories, the implementation decisions, what's out of scope, a link to the prototype, and nine sub-issues that can run in parallel.

By implementation, I'm trying to give the agent no decision space. As soon as you ask an agent to make a decision, it might make a bad one. The more decisions you give it, the more likely it is to choose a bad one.

## [Compact, then run it AFK](#compact-then-run-it-afk)

Then I [compact](https://www.aihero.dev/ai-coding-dictionary/compaction). Auto compact is still a little dodgy, but compacting right after we've turned the conversation into a document is so safe it's almost free, and we're back down to our starting context. Then Implement Spec takes the spec and tickets and builds them, as much in parallel as it can. This is where I step away and trust it to run [AFK](https://www.aihero.dev/ai-coding-dictionary/afk).

It came back with a massive PR, about 21,000 lines, and an [automated review](https://www.aihero.dev/ai-coding-dictionary/automated-review) against my coding standards that found one hard violation and a couple of cases of scope creep.

## [Stacked diffs: two-way doors, one-way door](#stacked-diffs-two-way-doors-one-way-door)

To review it with you watching, I asked the agent to break it into stacked diffs, each reviewable on its own: a run of two-way doors finishing in a final one-way door. A two-way door is a PR you can merge and revert anytime. A one-way door is very difficult to unmerge: it might mess with data, speak to an external service, or open a security window. I'm cosplaying a production system here, so I also asked about a feature flag, so both implementations run side by side until the last PR turns it on.

## [Human review: I'm reviewing the system](#human-review-i-m-reviewing-the-system)

I don't think you need to review every single line yourself. The point of [human review](https://www.aihero.dev/ai-coding-dictionary/human-review) here is that I'm not just interested in what the code does. I'm interested in the system that produced it. If I see a pattern I don't like, and I have a hypothesis that it's hurting the environment my agent works in, I want a lint rule so it never happens again.

My comments, in short: too many code comments, everywhere (more surface the agent has to update, and often just notes to itself from one session). No `as` outside shared utilities. Prefer `interface extends` to intersections. A typed helper instead of raw `fetch`. No magic strings with `useSearchParams`. "Find a lint rule we can ratchet" means a deterministic rule we don't impose on day one, but ratchet up over time.

The only PR where I'd call review mandatory is the one-way door: the additive migration for thumbnail diagrams in `schema.ts`.

## [Retro](#retro)

With the merges running in a background subagent, I ran the Retro skill over the 30-odd session transcripts and my 12 review comments. Compacting doesn't matter here; the sessions are saved on disk, and it pulls my comments with the GitHub CLI. If you have a [software factory](https://www.aihero.dev/ai-coding-dictionary/software-factory), save your sessions somewhere Retro can read them.

All 12 comments had one root cause: nothing in my written standards covered them, and the existing docs taught the opposite, with thousands of instances on main. I'm trying to turn an oil tanker around. The fixes became ratcheted lint checks, doc fixes, and issues on my skills repo. That's often how my skills get improved: I raise issues about my own skills based on what I find in retros.

On comments: 18% of lines in the new feature were comments, against a 12% repo average. The comment next to a workaround often acts as a fig leaf. If you were banned from writing the comment, you might not take the workaround. Pushed to be more aggressive, the audit found 22 comments that could simply be deleted, 18 workarounds that need changing, and three that should be ADRs.

## [Where I add value](#where-i-add-value)

The feature works: I capture my face, draw next to it, insert icons, and the thumbnail is ready for YouTube. Next I'd QA it, file what I find as issues, and one-shot them with an agent.

I'm most valuable early on, in the alignment phase: we talk through everything, I understand exactly what's being built, we make a prototype together. And I'm useful at the end, where my technical expertise comes in and I impose my coding standards. Grilling and retro are the two main points where I interact with the system. Then QA, and putting in my taste.
