Matt Pocock asks an AI coding agent to clean up his teleprompter. He doesn't ask it to start editing. He watches it search his video editor, read the project glossary, then ask whether the script should still scroll automatically and which controls he actually uses. The demo shows what a vague request leaves unresolved, before those decisions turn into code.
That's the distinction Pocock makes with NetworkChuck: agents are useful at implementing a defined change; you're responsible for deciding what should change and what must keep working. His workflow turns that responsibility into things you can inspect: a glossary, a spec, tests and a pull request with evidence.
Watch the NetworkChuck Interview
Source: NetworkChuck's November 20, 2026 interview with Matt Pocock and its transcript. The workflow follows the interview and Pocock's public skills repository. The copyable prompts are independent JQ AI SYSTEMS adaptations.
What Stays Your Job
Drawing on John Ousterhout's A Philosophy of Software Design, Pocock distinguishes tactical work, getting today's change to run, from strategic work, keeping the next change easy to make. An agent can implement a setting in three places. Someone still has to notice that the three places might end up disagreeing.
You don't need a detailed architecture plan for every typo. But when a feature changes what users can do or how data flows, decide which part of the system owns the behavior and how you'll know it still works after the next edit. The strategic work is making those calls before the agent chooses for you.
Start With Grill With Docs
In the live demo, the first questions arrive before the code exploration is complete. Pocock points out that the agent can answer some of them itself. Once it has more context, it asks about real choices in the language of the editor: beats, scripts, animatics and scrolling behavior. That is the valuable part of the interview: the repository supplies facts; you supply intent.
- Glossary: A short definition of each term the team, code and agent should use consistently. If a draft and a version mean different things, say so.
- Architecture decision record (ADR): A short note on what you chose and why, especially when the choice would be expensive to reverse. The code shows what you built; the ADR preserves why you chose it.
- Spec: The contract for this change: expected behavior, non-goals and checks the reviewer can run.
Grill with Docs combines the questioning loop with domain documentation. Start with the area you're changing; you don't need to document the whole app first.
Define a feature before writing code
From Spec to Tickets and Worktrees
For a small, clear change, Pocock may go straight from the interview to implementation. For larger work, he turns the conversation into a spec and splits it into tickets he can give to fresh sessions. He credits Dex Horthy's context-engineering work for the distinction between the useful early context and the point where a long session becomes harder to steer. Pocock starts watching around 150,000 tokens in his setup; that isn't a universal cutoff. He typically uses Opus 5.5 at medium effort and reserves more effort for work such as harder debugging or verification.
| Step | What you should get back |
|---|---|
| 1. Grill | Decisions on scope and behavior, grounded in the repo. |
| 2. Spec | One approved brief with acceptance checks and non-goals. |
| 3. Tickets | Small, testable changes with dependencies made explicit. Start with one thin piece that works end to end. |
| 4. Implement | Separate changes that can be integrated and tested together. |
| 5. Review | Evidence against the spec, repo standards and release risks. |
| 6. Retro | One specific improvement to the tests, instructions or code layout for the next run. |
Implement Spec coordinates ready tickets and brings the work back to an integration branch. Git worktrees give contributors separate checkouts of the same repository. They don't prevent conflicting designs, replace integration tests or isolate credentials. Parallelize tickets only when the necessary interfaces and dependencies are clear. Start with one ticket if you're still learning how to review the output.
Review by Merge Danger
Pocock checks two things before human review: did it build what the spec asked for, and did it follow the repo's standards? Then he asks for a screenshot or other proof the change actually ran, plus a judgment about what could go wrong after merge. Automated review helps direct attention; the human still decides.
Think about blast radius (who and what would be affected) and reversibility (what rollback can really undo). A reversible label change might need a quick diff and a preview. A schema migration, change to who can see private data, or bulk email requires deliberate review and checks in staging. Reverting a commit won't unsend an email or restore deleted rows.
Review a pull request by merge risk
After the review, the retro skill proposes a fix for the workflow itself. If you keep writing the same review comment, decide whether it belongs in an automated check, a short repo rule or a clearer interface. Review that change too, instead of converting every comment into a permanent instruction.
Tests, Types and Deep Modules
Give the agent feedback it can run and you can verify: a type check for incompatible values, a linter for known patterns, runtime tests for behavior and a preview for the actual user flow. Require checks in CI before merge. A green type check doesn't prove the teleprompter scrolls as intended, and a screenshot doesn't prove the failure case is handled.
A deep module hides substantial behavior behind a small interface. Test from that interface, where possible, so you can change the internals without rewriting tests that just repeat the old code. For example, a hypothetical teleprompter test could check that text stops advancing when the user pauses, without asserting which timer or state variable the implementation uses.
In the architecture demo, Improve Codebase Architecture flags near-duplicate logic in the editor's course submission and duplication paths, then proposes putting the shared behavior behind one interface. It's a before-and-after proposal, not proof the refactor shipped. Before accepting it, capture what each flow must preserve and run the same checks after the change.
Deploy Without Handing Over the Keys
In the hosting chapter, Pocock starts with where the data will live and favors a repeatable CI/CD pipeline over asking an agent to log into infrastructure and deploy. For your first app, separate previews from production, give previews test data and scoped credentials, and decide who can approve release. Test the rollback before relying on it, including how to recover the data if a migration is involved.
The open-source chapter applies the same idea to contributing: follow the project's rules, file a reproducible issue and attach evidence a maintainer can use. A small test case with expected and observed behavior is more useful than an unsolicited patch the contributor can't explain.
What to Learn Next
Pocock argues against treating any one language as the prerequisite, not against understanding code. Learn to trace a request through your own app, find where its state is saved, reproduce a bug, and explain what a test actually checks. His Teach skill offers a way in: give it an architecture report you don't understand, then ask it to walk through one concrete example from your project.
His Course Video Manager shows how those decisions add up. It started with a personal problem: using pauses in a recording to make clips as he films. It grew to include a custom teleprompter, diagrams linked to clips and course publishing workflows. The useful takeaway isn't the size of the tool. It's that he knows what a better recording workflow looks like because he uses it.
Books, Skills and Links
- A Philosophy of Software Design by John Ousterhout, on managing complexity and designing deep modules.
- Domain-Driven Design by Eric Evans, on using the language of the problem consistently across people and code.
- Working Effectively with Legacy Code by Michael Feathers, on getting existing behavior under test before you change it.
- Matt's skills catalog and GitHub source; AI Hero and Total TypeScript; Matt on X and Matt on YouTube.
Video Chapters
| Time | Topic |
|---|---|
| 00:00 | Do you still need to learn a programming language? |
| 00:54 | Who Matt Pocock is |
| 05:03 | Tactical vs strategic programming |
| 12:35 | Live demo: Grill with Docs |
| 25:18 | The smart zone and the dumb zone: Write a spec first |
| 34:35 | Subagents in worktrees and code review |
| 44:52 | The trust ladder: Tests, types and feedback loops |
| 52:31 | The starter stack and deep modules |
| 1:01:01 | Improve Codebase Architecture live |
| 1:08:15 | What you still need to learn |
| 1:14:11 | Where to host your app and how to deploy safely |
| 1:26:38 | Open source in the age of low-quality PRs |
| 1:34:41 | Advice for new developers: School, degrees and hiring |
| 1:44:39 | Software factories and Matt's AI video editor |
| 1:56:49 | Agents for your life |
| 2:01:01 | A prayer for you |