Video summary
How to Actually Code with AI (ft. Matt Pocock)
Main summary
Key takeaways
Summary
Matt Pocock’s central argument is that AI agents are strong at tactical programming—completing clearly defined tasks—but weak at strategic programming, such as making choices that keep a product and codebase healthy over time. Developers should delegate routine implementation while taking responsibility for goals, architecture, quality, and long-term direction.
A practical workflow for coding with agents
Matt demonstrates a process that starts with alignment rather than immediately asking an agent to write code:
- Grill the idea. Use a skill such as Grill with Docs to have the agent inspect the project, ask clarifying questions, and uncover assumptions before implementation. This reduces the communication gap between the user and the agent.
- Build shared terminology. Maintain a project glossary so the agent and codebase use consistent names for concepts. Matt’s approach can add terminology gradually as features are discussed, rather than requiring a complete glossary up front.
- Record important decisions. Use short architectural decision records (ADRs) to preserve consequential choices that aren’t evident from the current code. These give agents context and help prevent repeated mistakes.
- Implement directly or create a spec. For a small task that fits comfortably in the current context, use an implementation skill. For larger work, turn the discussion into a specification, break it into tickets, and implement those tickets in separate sessions.
- Use sub-agents and worktrees for larger tasks. Matt’s Implement Spec workflow can coordinate parallel sub-agents working in separate Git worktrees, then bring their work together for review.
- Review and improve the process. Run a code review against both the specification and the project’s coding standards. After human review, use a Retro skill to turn recurring feedback into better standards or automated checks.
Context management and model effort
Matt recommends keeping agents in what he calls the “smart zone”: a relatively small, focused context where the model can make better decisions. A large context window does not mean every task should use it; more context can increase latency and make it harder for a model to focus on what matters. He says he becomes cautious around 150,000 tokens, while emphasizing that the exact threshold matters less than keeping context manageable.
He also argues that developers often set model effort too high. For routine exploration, he generally uses Opus 5.5 at medium effort, reasoning that exploration needs the right information, not necessarily an exhaustive search through every file. Higher effort may be more useful for demanding research, performance testing, or debugging that requires trying many approaches. His broader advice is to improve the agent’s working environment before assuming a newer model or higher effort setting will solve the problem.
Code review, testing, and trust
Matt frames human review around merge danger, rather than automatically reading every change line by line. His PR summaries include:
- A visual description of what changed.
- Evidence that the change works, such as screenshots or execution-based checks.
- Whether the change is a one-way door (difficult or impossible to reverse) or a two-way door (reversible).
- The potential blast radius if it goes wrong.
A reversible change with a small blast radius may need less scrutiny; an irreversible change with a large blast radius deserves careful review and testing. Human review also provides a chance to improve the agent’s environment so the same issue is less likely to recur.
To build trust in agents, Matt recommends strong, fast feedback loops, including:
- Static types, such as TypeScript, to catch mistakes early.
- Runtime tests.
- Linters and coding rules that prevent known bad patterns.
- CI checks that run consistently.
- More thorough agent verification for work that needs it.
He prefers turning repeatable quality requirements into deterministic automated checks—for example, a lint rule—rather than relying only on an agent to remember them. His rule of thumb is to choose deterministic automation when it can solve the problem reliably.
Architecture: deep modules and useful tests
Matt describes a healthy codebase as one that is easy to change without breaking unrelated parts. He advocates organizing code into deep modules: substantial units with a narrow interface whose internals can change without requiring widespread edits elsewhere.
Tests should verify behavior through a module’s public interface rather than simply repeat implementation details. This can reduce fragile tests that need to be rewritten whenever internal code changes. Matt’s Improve Codebase Architecture skill analyzes a repository, produces a visual report of potential problems, and suggests improvements that can then be turned into tickets and handled through the normal workflow.
He also describes running this skill on a schedule to propose incremental improvements, with periodic sampling and review. He cautions that the right degree of automation depends on the consequences of failure; his own projects are personal software, not medical or financial systems.
Deployment and security
For someone starting a project, Matt recommends using accessible tools such as GitHub, VS Code, Git, and an AI coding agent. He considers the particular agent less important than having a useful process and environment. For hosting, he suggests choosing managed options rather than taking on unnecessary infrastructure work. He mentions services such as Vercel, Netlify, and GitHub Pages, and suggests a managed Postgres database for projects that need one.
He recommends using CI/CD so deployment follows a repeatable process—for example, deploying automatically when changes reach the default GitHub branch—instead of asking an agent to deploy manually each time. On security, he says his own work is mainly personal software and that he is not a security specialist. He recommends adding a security review to the code-review process and taking extra care with sensitive applications.
Learning to become a software developer
Matt says a specific programming language is not the main thing aspiring developers need to focus on. They should learn enough to read code and understand concepts such as module boundaries, while using agents as tutors. The more valuable skill, in his view, is strategic judgment: recognizing what a product needs, using precise domain language, improving the codebase and development process, and caring about users and quality.
He suggests reading software-design and engineering books, then using a teaching tool or an agent to explain unfamiliar terms and apply the ideas to real projects. Books he recommends include:
- A Philosophy of Software Design — John Ousterhout
- The Pragmatic Programmer — David Thomas and Andrew Hunt
- Working Effectively with Legacy Code — Michael Feathers
- Refactoring — Martin Fowler
- Extreme Programming Explained — Kent Beck
For portfolios and open source, he recommends demonstrating strategic work: build and deploy something people can try, show that it is thoughtfully structured, and explain how it can improve over time. He notes that AI-generated pull requests have increased the burden on maintainers, making high-quality issues and useful evidence especially valuable contributions.
Other projects and ideas discussed
Matt describes his personal course video manager, a video-production tool he uses to record and prepare course content. Its features include transcription, clip management, diagrams linked to clips, a teleprompter, AI-assisted scripting and animatics, version history, and synchronization of edits to his course platform. He says it is open source, though he does not accept issues or pull requests for it.
He also describes a personal wiki that ingests audience messages and other inputs on a schedule, helping him identify topics people want to learn about. For course planning, however, he deliberately steps away from AI and arranges learning goals on paper, saying that slower, human-paced thinking helps him keep complex plans in mind. More generally, he argues that knowledge work can be harder to automate than coding because its quality is less straightforward to verify.
Matt’s software factory concept is a system that gradually removes human intervention from parts of the development workflow—for example, initiating work from issues or routine alerts and allowing low-risk changes to proceed with less review. He stresses the need for strategic oversight and safeguards so automation does not simply produce more low-quality changes.
Main speakers and sources
- Matt Pocock — AI-assisted software development educator and creator of the skills and workflows discussed.
- NetworkChuck — Host and interviewer; shares examples from his own AI-assisted coding and video-production workflows.
- Books and concepts referenced — John Ousterhout’s distinction between tactical and strategic programming; domain-driven design and shared language; deep modules; and the software-engineering books listed above.
Rate this summary
Your feedback will help improve summaries.
Improve this summary
Reprocess with a stronger model when the summary feels incomplete or inaccurate.
Translate summary in another language
Ask questions to this video
Chat for follow-up questions, clarifications, and source-backed answers.