Matt Pocock, creator of Total TypeScript and AI Hero, joined NetworkChuck to show how he really builds software with AI agents, and why strategic programming is now the human’s job. In How to Actually Code with AI, a two-hour conversation on the NetworkChuck channel, Pocock runs his Grill with Docs and Improve Codebase Architecture skills live on his own video editor, explains why he keeps Opus 5.5 on medium effort, and walks through the full loop he uses every day: grill, spec, tickets, sub agents in worktrees, code review, retro.
TLDW
Pocock’s core claim is that AI is excellent at tactical programming (solving today’s problem) and terrible at strategic programming (keeping the codebase healthy for the long run), so the strategic layer is where humans now earn their keep. His workflow aligns the agent before any code is written, keeps context small enough to stay in the “smart zone,” reviews work by merge danger instead of line by line, and ratchets up types, tests and lint rules until agents can be trusted. He closes on advice for new developers, open source in the age of slop PRs, software factories, and why knowledge work is harder to automate than coding. One word keeps coming back: care.
Thoughts
The sharpest operational advice in the whole conversation is a throwaway line about deployment: if you can choose between determinism and non-determinism, always choose determinism. Pocock applies it everywhere. Deploys go through CI/CD that has worked the same way for years and costs no tokens, not through an agent logging into a server. When a code review turns up a mistake, his retro skill tries to turn it into a lint rule or a type constraint rather than another line in a prompt the agent may or may not read. That is the real engine of his “straitjacket.” Every correction gets pushed down from soft guidance into a check that runs the same way every time, so the environment gets stricter with each session. Most people building with agents treat a bad output as a prompting problem. Pocock treats it as a missing test, and he points out that most people do not even realize they have that choice.
His answer to “what is a developer for now?” is more convincing than the usual reassurance because it is concrete. One person shipping 2,500 PRs a month is still half of what two people shipping that much would produce, and the thing that separates good products is not tokens spent but attention paid: someone using the product, noticing problems, and deciding strategically what to fix next. That is QA, product management and product design, the work that stays human or at least needs a human to tell the agent to care about it. His hiring advice follows from it. Do not worry about which programming language to learn. Show, through a shipped project, that you care about deep modules, locality and making the next change easier. Pocock has a drama degree, spent six years as a voice coach and taught himself to code in 2015, so his doubts about computer science degrees are earned.
The contrarian take on reasoning effort deserves more attention than it will get. Pocock says there is an “epidemic” of people running agents at high, extra high or max effort, and that it backfires: exploration does not get better with more effort, it just burns tokens and pushes the session into the dumb zone sooner. He runs Opus 5.5 on medium for nearly everything and is considering low. The place he does want high effort is verification, when the agent is clicking through the real app or running performance traces to prove its own work. That inversion is the useful part. Spend compute where it buys trust, not where it buys the feeling of thoroughness. It also explains why he does not jump between models: fix the environment the agent works in, and a static model gets much better.
Late in the conversation Pocock flips his own pattern. All afternoon he says coding is easier than people think; then he says knowledge work is much harder than people think, because coding is verifiable and a course plan or a video script is not. There is no automated check that tells you this course is better than the last one. His own practice proves the point. For course planning he leaves AI entirely, prints learning goals onto cards, and moves them around by hand for hours because an agent’s replies come too fast and too dense to hold the whole structure in his head. Anyone trying to bolt agents onto planning, strategy or writing should take that seriously. The tools that work so well on code work well precisely because code can be checked.
The merge-danger idea is the most practical thing to steal for anyone reviewing AI output. Pocock’s PR skill makes the agent label each change as a one-way or two-way door and estimate its blast radius. A small, reversible change might just get tested in production; an irreversible one with a big blast radius gets his full attention, and he tries to break it. That turns review from an impossible line-by-line chore into triage, and it is also the building block for the software factory he describes later, where only the one-way doors need a human at all.
Key Takeaways
- Drawing on John Ousterhout’s A Philosophy of Software Design, Pocock splits programming into tactical work (win today’s battle) and strategic work (win the war), and says AI is great at the first and “garbage” at the second because benchmarks reward finishing the task in front of it.
- Pure vibe coding never worked on its own, he argues: the code is the agent’s environment, and when nobody guards it, the environment slowly rots around the agent.
- Grill with Docs makes the agent quiz you before it builds anything, using a project glossary of agreed terms and a folder of architectural decision records (his video editor repo has 31) so the agent stops repeating past mistakes.
- The shared language comes from Domain-Driven Design: when the database, the front end, the emails and the conversation all call a refund a refund, both humans and agents navigate the code far more easily.
- Pocock gets nervous around 150,000 tokens of context, well short of the one million Opus offers, and credits the “smart zone and dumb zone” idea to Dex Horthy.
- Small features go straight from grilling to implementation. Big ones become a spec, then tickets of roughly 150,000 tokens each, run by parallel sub agents in worktrees and merged into one PR.
- Code review checks two axes: does the code match the spec (no over or under scope), and does it meet the repo’s written coding standards.
- Trust is built with feedback loops: strict TypeScript instead of JavaScript, no
anytype, fast runtime tests and harsh lint rules, so the agent can grade its own work. - Good tests run against deep modules through a narrow interface, so everything inside can change without rewriting tests. His Improve Codebase Architecture skill finds shallow modules and proposes deep ones, and runs daily as a cron job on his repos.
- His starter stack is free: GitHub, VS Code, Git and Claude Code or any harness that supports skills. For hosting, use a managed Postgres database and an easy platform such as Vercel, where he hosts his own work.
- Skills are hard and expensive to eval, so Pocock treats his users as the eval: issues come in, an agent reproduces them in a dummy repo, and it opens a PR.
- Open source contribution now means filing high-quality issues with good evidence, because turning an issue into a PR is cheap. He has closed PRs on his own skills repo, which he says is nearly at 300,000 stars.
- A software factory, in his definition, removes humans from more of the points where work needs them, but it needs brakes so it does not become a “slop cannon.”
Chapters
05:03 Tactical vs Strategic Programming, and Why Vibe Coding Wrecks Code
Pocock rejects the guru framing and starts from Ousterhout’s distinction between tactical and strategic programming. Agents are trained and benchmarked on tasks, so their focus is fully tactical, and strategic mistakes only bite months later. He says it is “ridiculous” for developers not to use AI now that tactical work can be done for less than minimum wage, and that strategic programming mostly comes down to caring more than the person next to you.
12:35 Live Demo: Grill with Docs, Glossaries and ADRs
Working in his course video manager repo, Pocock gives the agent a deliberately vague prompt about cleaning up his teleprompter. The skill explores the codebase with a sub agent, then grills him in the project’s own vocabulary of beats, scripts and animatics. He shows how Grill with Docs combines his grilling skill with a domain modeling skill that maintains a glossary and architectural decision records, and says you can start on a messy project by just grilling and letting it mint terms as you go, slowly carving out a readable corner of a vibe-coded codebase.
25:18 The Smart Zone, the Dumb Zone, and Reasoning Effort
After grilling, small jobs go to the implement skill, and anything likely to exceed about 150,000 tokens becomes a spec, stored as a markdown file or GitHub issue, then tickets. Pocock explains attention degradation as the context fills, and argues that people run far too high an effort level. He uses Opus 5.5 on medium for almost everything, raising it only for web research, performance work or hard debugging, and says fixing the agent’s environment beats waiting for the next model.
34:35 Sub Agents in Worktrees, Code Review and Retro
The implement spec skill runs parallel sub agents in worktrees, tracking tickets as GitHub sub issues under the spec, and then calls code review for a spec review and a standards review. Human review uses a PR skill that shows a visual summary, execution evidence and merge danger (one-way or two-way door, plus blast radius). A retro skill looks back at the session and the review comments and feeds improvements into the coding standards.
44:52 The Trust Ladder: Tests, Types and Feedback Loops
Citing Lauren Tan, who goes by Poteto, Pocock describes climbing a trust ladder until some PRs can merge without human review. The classic definition of a good codebase is one that is easy to change, and that requires automated checks: strong types, runtime tests and linters. Retro ratchets those checks up over time. He trusts his agents because he builds personal software, and says on banking or medical work he would burn far more tokens on verification and security.
52:31 The Starter Stack, Deep Modules and Improve Codebase Architecture
Pocock recommends GitHub, VS Code, Git and any skills-capable harness, and rejects the “dark factory” in favor of dimmer switches for different rooms of the codebase. Tests that just repeat the implementation create churn; deep modules tested through narrow interfaces let you turn the lights off inside them. He runs Improve Codebase Architecture live, and its HTML report finds two functions with 150 near-identical lines and proposes folding several shallow modules into one testable deep module.
1:08:15 What You Still Need to Learn, and the Teach Skill
When the report uses words like locality that NetworkChuck does not know, Pocock points to his teach skill, which tracks what you know, quizzes you and builds HTML lessons (it taught him to solve a Rubik’s cube). Engineers still get better results than non-engineers because they know the domain language: “fix the layout shift on the homepage” beats a paragraph of description. On the bitter lesson, he says he is not a pundit, and that harnesses may eventually make agents care about strategy.
1:14:11 Hosting, Security, Evals and CI/CD
DevOps has turned into products, so Pocock tells beginners to pick a managed Postgres host such as PlanetScale or Supabase and deploy to Vercel, Netlify or even GitHub Pages. He admits security is not his area and suggests adding a security review to the code review step. He explains why he does not eval his skills, and why deployment should stay deterministic through CI/CD rather than run through an agent.
1:26:38 Open Source in the Age of Slop PRs, and Advice for New Developers
Pocock describes his open source work, Sandcastle (agent orchestration in sandboxes) and the Evalite eval framework, and says popular projects such as Hono are closing PRs to outside contributors. For new developers he says to demonstrate strategic care through shipped projects, read the classics, and use the teach skill to work through the hard parts. His reading list includes Working Effectively with Legacy Code, The Pragmatic Programmer, Refactoring and Extreme Programming Explained.
1:44:39 Software Factories, the AI Video Editor and Agents for Your Life
A software factory removes the human from more points in the process, triggered by new issues or slow database warnings, which Pocock calls loop engineering by another name. His open source video editor, about 2,500 commits deep, cuts and transcribes clips as he records and syncs edits to his course platform. Every three hours a cron job ingests his mentions, Discord, Slack and Gmail into an Andrej Karpathy-style LLM wiki that he queries for what his audience wants, but lesson planning happens on paper cards. He ends by saying knowledge work is far harder to automate than coding because it cannot be verified.
Notable Quotes
“Now AI is really good at tactical programming and terrible at strategic programming.”
Matt Pocock, on the core idea behind his workflow
“So much of strategic programming is just caring a bit more than the person next to you.”
Matt Pocock, on what separates strategic programmers
“I think instead of waiting for the next model to fix all your problems, why not just fix all your problems?”
Matt Pocock, on improving the agent’s environment instead of chasing models
“If you have a choice between determinism and non-determinism, why would you ever pick non-determinism, right?”
Matt Pocock, on CI/CD and turning review comments into lint rules
“AI has eaten tactical programming, but it can’t do strategic programming.”
Matt Pocock, on what developers now need to show employers
“The thing that really differentiates good products these days is not the amount of tokens that have been spent on them, but the amount of attention that has been given to the product.”
Matt Pocock, on why humans still matter
“I think knowledge work is really difficult, way harder than people think it is.”
Matt Pocock, on why AI struggles outside verifiable work like coding
Watch the full conversation here.
Related Reading
- Matt Pocock’s skills on AI Hero documentation for Grill with Docs, Implement Spec, Teach and the rest of the skills shown in the video.
- mattpocock/skills on GitHub the source of the skills, ready to point an agent at.
- Smart zone (AI Coding Dictionary) Pocock’s definition of the context idea he leans on throughout.
- Domain-driven design (Wikipedia) background on the shared-language practice behind his glossaries.
- Sandcastle on GitHub his TypeScript library for running coding agents in sandboxes.