AI Skills with Matt Pocock

Stream the latest episode

Listen and watch now on YouTube, Apple, and Spotify. See the episode transcript at the top of this page, and timestamps for the episode at the bottom.

Brought to You by

• turbopuffer – Here’s a crazy idea: what if AI agents could search its entire history, but without RAG or other clever workarounds? turbopuffer’s cheap storage, combined with fast performance makes this surprisingly practical, for any and all agent memory use cases.

• Linear – Agents are only as good as what they know about your product, and for teams like OpenAI and Coinbase, Linear is where that lives. You can use Cursor, Codex, Claude Code, Linear Agent, or the agents you built; then delegate work to them right inside Linear, and everyone can see what they did.

• WorkOS – The fastest AI-native teams have to slow down for the hard problems. WorkOS makes sure auth, for your app and your agents, is never one of them.

In this episode

Why is the “grill-me” skill so popular, and why does its creator swear by the importance of software fundamentals? Matt Pocock created this widely-used skill – and many others – alongside being an educator, content creator, and engineer. His latest course is AI Hero, and he previously created the Total TypeScript course that generated more than $2.5 million in total sales.

In this episode, Matt and I discuss his unconventional path from working as a voice teacher to becoming a developer and going all-in on technical education. He reveals how communication skills helped him break into tech, why he took an unusual three-days-a-week contract at Vercel, and how he built Total TypeScript through workshops, courses, and lots of free tutorials.

We also explore “strategic coding,” and how he uses skills like “grill me” and “wayfinder” to plan, delegate, and course-correct with AI agents. Matt explains his “day shift” and “night shift” approach, why splitting context up can keep agents in their “smart zone,” and how concepts from classic software engineering books can guide agents to do better. In this episode, there’s also local versus cloud workflows, whether agents need TDD, how AI is changing the ways that engineers learn the fundamentals, and why humans are still essential in teaching.

Takeaways from the conversation with Matt

1. Matt hacked together a web app for students while working as a voice coach. He taught himself JavaScript to build a web audio spectrogram analyzer for singing students, while he was teaching singing, accents, and Shakespeare at drama schools. He also ran his own company at university, studied for a Master’s qualification in voice, and coached consulting firms on public speaking.

2. Matt took a Vercel job in case Total TypeScript did not work out. Matt produced a lot of two-minute TypeScript tip videos which became popular. When he received a fulltime job offer from Vercel, Matt negotiated to work three days per week as a contractor so he could develop his TypeScript course on the other days. When it took off, Matt quit Vercel to focus entirely on his educational projects.

3. Matt does not work on weekends and dislikes the concept of ‘9-9-6.’ He explained that everything he does is an effort to build a lifestyle where he can spend most of his time with his family. That’s the goal.

4. The ‘grill-me’ skill was inspired by from Anthropic’s Thariq Shihipar. The grill-me skill is surprisingly simple and short: it instructs an agent to interview the user relentlessly. Thariq shared his approach of an agent interviewing its user about a topic – and how it was surprisingly useful –, and Matt created a skill around the novel concept.

5. Is “strategic programming” the future of devs’ work? Borrowing from John Ousterhout’s “tactical programming” vs “strategic programming” categorization, Matt believes that agents are more than capable of tactical programming, leaving us engineers to spend more time at the “strategic” level.

6. Using the right “leading words” makes agents produce better results. Matt noticed that agents try to build software layer by layer and that this causes bugs between the layers. Reading The Pragmatic Programmer, he discovered the concept of a “tracer bullet.” When he instructed the agent to use “tracer bullets” to build an app (aka implement a “golden path”), the agent started to produce better code! Since then, Matt has started reading classic software engineering books to discover other “leading words” that guide agents efficiently.

7. Cloud-based agent setups make more sense than running agents locally. Matt is moving his coding sessions to cloud agents because doing so means agents run when he closes his laptop and cloud agents can be made “multiplayer” (collaborative) in ways that local agents cannot.

8. Memento-driven development: optimize your codebase for a colleague who wakes up with no memory every morning. Matt says:

“Imagine you have a human who wakes up every morning and cannot remember who they are, like the guy from Memento. We are trying to optimize our codebases for new starters, so we want the healthiest codebase we’ve ever had. A human can work around a bad codebase and they develop a memory about it, but an agent can’t do that; it starts afresh every single session. So, you need to optimize your codebase for that agent. And it turns out that software fundamentals have been trying to do that [optimize codebases for readability/understandability for someone who sees the code for the first time] for the entire time.”

9. Matt has mixed feelings on Test-Driven Development (TDD) with agents. He believes TDD is helpful for devs as we tend to have shorter working memories, and so a failing test will remind a distracted human of what is still failing. However, agents have longer context windows, so Matt has started to ask agents to produce proof that their code works – with or without TDD. We cover another take on TDD in our

The Pragmatic Engineer deepdives relevant for this episode

•

•

•

•

•

•

•

•

Timestamps

00:00 Intro

05:48 How Matt got into tech

10:14 How Matt got into open source

12:58 Joining Vercel

18:39 Total TypeScript

23:21 AI’s impact on technical education

30:32 Building reusable skills for AI coding agents

40:46 The “smart zone” vs the “dumb zone”

45:02 The wayfinder skill

47:52 Why agents excel at software engineering

50:54 “Leading words”

1:01:10 Learning the fundamentals

1:09:17 Local vs. cloud agents

1:12:36 Planning vs. course-correcting

1:18:13 TDD and agents

1:23:06 Living in the UK

1:24:21 Teaching: the human part

1:28:36 Advice for junior engineers

1:31:07 Gardeners and great engineers

1:34:01 Book recommendation

References

Where to find Matt Pocock:

• X: https://x.com/mattpocockuk

• LinkedIn: https://www.linkedin.com/in/mapocock/

• YouTube: https://www.youtube.com/c/mattpocockuk

• Website: https://www.mattpocock.com

• AI Hero: https://www.aihero.dev

Mentions during the episode:

• Microsoft Build: https://build.microsoft.com

• David Khourshid on X: https://x.com/DavidKPiano

• XState: https://stately.ai/docs/xstate

• Mateusz Burzyński on X: https://x.com/AndaristRake

• Stately: https://stately.ai

• Vercel: https://vercel.com

• Lee Robinson on LinkedIn: https://www.linkedin.com/in/leeerob

• Jared Palmer on LinkedIn: https://www.linkedin.com/in/jaredlpalmer

• Cognition: https://cognition.com

• Turbopack: https://vercel.com/blog/turbopack

• Total TypeScript: https://www.totaltypescript.com

• Joel Hooks on X: https://x.com/joelhooks

• Everything is a Ralph loop: https://ghuntley.com/loop

• Ship working code while you sleep with the Ralph Wiggum technique:

• What is “loop engineering?”:

• “Software Fundamentals Matter More Than Ever” — Matt Pocock:

• Context engineering with Dex Horthy:

• Formal methods with Hillel Wayne:

• The Pragmatic Programmer: Your Journey to Mastery: https://www.amazon.com/Pragmatic-Programmer-journey-mastery-Anniversary/dp/0135957052

• A Philosophy of Software Design: https://www.amazon.com/Philosophy-Software-Design-2nd/dp/173210221X

• The Philosophy of Software Design – with John Ousterhout:

• Domain-Driven Design: Tackling Complexity in the Heart of Software: https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215

• TDD, AI agents and coding with Kent Beck:

• Uncle Bob Martin on X: https://x.com/unclebobmartin

• Matt’s post on X, “I’m moving away from my local dev setup”:

• The third golden age of software engineering – thanks to AI, with Grady Booch:

• Software architecture with Grady Booch:

• Jared Friedman’s post on X, “tech debt..”:

• Lauren’s post on X, “every team needs a gardener...”:

• Lars Grammel on X: https://x.com/lgrammel

—

Production and marketing by Pen Name.