Matt Pocock 谈 AI Skills：编码智能体商品化战术编程，grill-me 与 Ralph 循环重塑战略工程

Brief Description

Matt Pocock, creator of Total TypeScript and the viral "grill-me" AI agent skill, joins Gergely Orosz to discuss how classic software engineering fundamentals are more vital than ever in the age of AI coding agents. Drawing on his journey from voice coaching to frontend engineering and full-time technical education, Pocock breaks down how AI agents have commoditized tactical programming, shifting the engineer's core value entirely to strategic system design and context engineering. He details why concepts from decades-old engineering texts—such as tracer bullets, software entropy, ubiquitous language, and deep modules—act as high-leverage "leading words" to steer frontier models, and shares his multi-session planning workflows using specs, Ralph loops, and Wayfinder maps to maintain clean, resilient codebases.

Table of Contents

• From Voice Coach to Self-Taught Developer
• Statecharts, XState, and Joining Vercel
• The Launch and Multi-Million Dollar Success of Total TypeScript
• How AI Disrupted Technical Education
• Strategic vs. Tactical Programming: Enter Ralph Loops
• Packaging Agent Workflows into AI Skills
• The Grill-Me Skill: Bridging the Human-Agent Communication Gap
• Managing the Smart Zone: Context Windows and Specs
• Wayfinder: Navigating Complex Planning with Directed Graphs
• Why Software Fundamentals and 20-Year-Old Books Still Matter
• Leading Words and Ubiquitous Language from Domain-Driven Design
• Memento-Driven Development: Optimizing Codebases for Amnesic Agents
• Strategic Feedback Loops and Convincing Stakeholders to Value Fundamentals
• Moving Away from Local Dev: Remote Boxes and Collaborative Agents
• When to Grill vs. When to Ship Fast
• Reassessing Test-Driven Development in the Age of Agents
• Combating Software Entropy with Automated Reviewers and Code Gardeners
• Advice for Junior Engineers and Essential Reading

From Voice Coach to Self-Taught Developer

Gergely Orosz: I got the grilling of my life when building a pretty simple API endpoint using the grill-me skill. It asked me 35 questions. It was intense, annoying, and it forced me to think more deeply. Today's guest is the creator of this popular skill, Matt Pocock. Matt is a developer turned educator, well known for his Total TypeScript series and now for his AI skills and educational videos. Today we cover Matt's unusual path into tech after years of being a voice coach, building his own DIY coaching software, his popular skills like grill-me and Wayfinder, and why taking inspiration from decades-old programming books helps us build better software with AI.

Matt, it is great to have you on the podcast.

Matt Pocock: It is great to finally be here. I am a huge fan and have watched so many of these episodes. I feel like this is the Tiny Desk of software engineering, so I am glad to be here.

Gergely Orosz: It is great to reconnect after catching up at Microsoft Build. To start off, unlike many people in tech, you did not study computer science, right?

Matt Pocock: Absolutely not. For six years before becoming a developer, I was a voice coach and singing teacher working in London and in Exeter, where I went to university. I was teaching accents, singing, and voice. I completed a master's degree in it and spent a lot of time thinking that was what my career was going to be. I did not have any inkling of entering tech. I ran my own website, but that was about it. That background has been an extremely important influence on my life and personality.

Gergely Orosz: Where did the voice coaching come from, and what kind of people came to you for help?

Matt Pocock: I started as a singing teacher. I was in a band at university, had some singing experience, and set up my own business. Most clients were people who simply wanted to sing better, use their voice in choirs, or pursue it as a hobby. After completing my master's degree, I taught Shakespeare in drama schools and started coaching people in public speaking, including sessions for consulting companies on presentation delivery.

I eventually decided to leave that career because doing it at a high level required living in London. I tried living there for two years and hated it. I wanted to return to the countryside where I grew up. To do something remotely, I decided to teach myself software development.

Gergely Orosz: You were looking for a profession that you could pursue outside London that offered a viable career future?

Matt Pocock: Exactly. I had taught myself basic JavaScript because I wanted to make lessons better for my students. I built little flashcard apps, and the first major app I attempted was a web audio analyzer. It analyzed the spectrogram of a student's voice to inspect resonant frequencies and see whether their formants were properly balanced. It ran terribly, but it made my lessons better.

Around 2017, I started looking at job postings and realized I knew enough JavaScript and Sass to try applying. I quit my job, took a couple of months off to study, and landed my first role. In the UK back then, demand for engineers was high, and boot camp graduates were getting opportunities. Because I had spent years communicating professionally, I could interview like a reasonable, articulate person rather than someone who struggled with communication. My technical knowledge was limited initially, but my ability to explain technical concepts was strong. Once I paired that with intense passion and accelerated technical learning, I was able to progress quickly.

Statecharts, XState, and Joining Vercel

Gergely Orosz: How did you take the next steps on the ladder after that first role?

Matt Pocock: My first role was at a tiny company with some inspiring, hardcore developers. The engineer who mentored me got me to set up CentOS 6 on my Windows PC because that was what ran in production. Unfortunately, the company ran into financial trouble, so I moved to an agency. Over the next few years, I moved between agencies, eventually diving deeply into TypeScript and open source.

In my second job, I was already presenting on the importance of TypeScript. We were building a learning management system for an automobile manufacturer with a small frontend team and a backend team in Portugal. The backend team kept changing API contracts without telling us, causing bugs and slowing our velocity. Introducing TypeScript solved that disconnect, accelerated our delivery, and made the frontend team faster than the backend team.

Gergely Orosz: How did you make the jump into open source?

Matt Pocock: I was actively tinkering with open-source projects on the side and following developers on Twitter. I came across David Khourshid, who created XState. On a client project, we needed a complex state machine for an application where two users on a video call could navigate a 3D house model in real time. We used XState version 4, and it was a massive success.

I started wondering how to make the integration more type-safe. I built some tooling and a CLI around XState, which caught David's attention. He invited me onto the XState core team. Contributing to issues and architectural discussions brought me into contact with world-class engineers like Mateusz Burzyński. When David raised funding to turn Stately into a commercial company focused on statecharts and visual programming, he hired me. That was my first role being paid US-level compensation, which completely transformed my financial perspective and flexibility.

While at Stately, I did developer advocacy alongside engineering because I believed deeply in the product. That advocacy caught the attention of Vercel. At the time, Lee Robinson was leading developer education alongside Delba de Oliveira and Lydia Hallie. I took an engineering role at Vercel under Jared Palmer.

The Launch and Multi-Million Dollar Success of Total TypeScript

Gergely Orosz: How long were you at Vercel before transitioning to education full-time?

Matt Pocock: I was only at Vercel for about three months. I had negotiated an unusual three-day-a-week contract because I missed teaching. Having spent six years teaching voice before coding, I wanted to create educational content again. While working on type-safe statecharts at Stately, I had developed techniques for extremely advanced TypeScript typing.

I started producing two-minute TypeScript tips and posting them on Twitter. They exploded. One Sunday, I recorded about 15 short tips and queued them up. My following shot up rapidly, and I realized there was tremendous appetite for high-level TypeScript material.

Vercel had offered me a full-time role, but I asked for a part-time contract to test building an educational course. Two months in, during the release of Turbopack where I helped write the initial documentation, I ran a pre-release sale for Total TypeScript. The pre-sale generated thirty to forty times what I was earning at Vercel in that time frame. It became obvious that I had to commit full-time.

I partnered with Joel Hooks, the co-founder of Egghead who had previously worked with Kent C. Dodds. Joel encouraged me to treat this as a high-leverage business targeting enterprise education budgets. We launched the full course in early 2023, and it crossed seven figures in revenue shortly after launch, eventually passing $2.5 million in total revenue. That success gave me the freedom to design my work life entirely around my family, avoiding grind culture like 996 schedules and rarely working weekends.

How AI Disrupted Technical Education

Gergely Orosz: Total TypeScript was a massive success, but then modern generative AI arrived. Many online educators have seen traffic and course revenues decline as developers turn to LLMs instead of comprehensive video courses. How did AI impact your business and your view of teaching?

Matt Pocock: AI has completely shifted which forms of knowledge are valuable. When teaching, there are two distinct layers: the syntax, which is the "what", and the underlying architectural principles, which is the "why". You cannot easily teach the why without demonstrating the what, but pure knowledge acquisition has become practically free. Anyone can ask an LLM or use an AI skill to retrieve exact syntax or implement a pattern instantly.

However, architectural wisdom has not become easier to acquire. Developers still encounter the exact same systemic failure modes when they lack architectural judgment, even with AI assistants. Revenue for Total TypeScript naturally tapered off because developers feel less need to memorize intricate syntax.

Initially, in late 2023, I tried building courses about integrating AI into web applications, but that felt like the wrong bet. The real turning point came around December 2024. During that period, frontier models like Claude 3.5 Sonnet and Opus reached a threshold where you could reliably delegate substantial implementation tasks to them.

I realized that AI had effectively automated tactical programming—writing boilerplate, constructing functions, and adjusting syntax. The remaining human responsibility is strategic programming: system design, constraints, and long-term codebase architecture.

Strategic vs. Tactical Programming: Enter Ralph Loops

Gergely Orosz: That distinction mirrors John Ousterhout's concepts in A Philosophy of Software Design. How did you begin structuring work around that division?

Matt Pocock: John Ousterhout's book is a massive influence on me. Once AI commoditizes tactical programming, our job is managing the strategic layer.

I started exploring Ralph loops, a concept popularized by Geoffrey Huntley. Instead of generating an entire plan upfront and hoping an agent executes thirty steps without drifting, a Ralph loop assigns the agent a high-level goal and tells it to make the smallest viable change that moves the project forward. The agent modifies the files, updates its state, and then completely clears its context window before the next iteration.

Because the state lives in the codebase, file system, and environment rather than inside a deteriorating context window, the model starts each step completely fresh. Having spent years building state machines in XState, this process felt immediately familiar. It is essentially a finite state machine orchestrating agent operations.

When I experimented with these structured loops on my internal tools—like my custom video editor—and compared them to default agent harnesses, the difference was massive.

Packaging Agent Workflows into AI Skills

Gergely Orosz: How did you move from these individual workflow experiments to creating reusable skills?

Matt Pocock: I wanted a simple distribution mechanism. AI skills are fundamentally just folders of Markdown files that define structured prompts, system instructions, and workflows. They can be invoked directly by the user via slash commands or loaded automatically by the agent when relevant.

I open-sourced a collection of my personal workflows as a skills repository. At first, I simply put it online without much promotion. Soon after, it accumulated stars faster than anything I had previously built.

In April, I gave a talk titled "Software Fundamentals Still Matter" at AI Engineer Summit in London. That talk reached over a million views, and the skills repository grew to over 230,000 GitHub stars, becoming one of the most starred repositories on GitHub. It was the second time in my career where I felt a massive, organic wave of industry interest.

The Grill-Me Skill: Bridging the Human-Agent Communication Gap

Gergely Orosz: Let's talk about the most famous skill from that repository: grill-me. When I tried using it to design an API endpoint, it interrogated me with dozens of pointed technical questions about tokens, rate limiting, and failure modes. What inspired it?

Matt Pocock: The biggest mistake people make with AI agents is underestimating the communication gap. Because the agent is an LLM with vast general knowledge, people assume it inherently understands their mental model and implicit priorities. When you simply type a command like /go and ask it to build a feature, it hallucinates assumptions and produces misaligned code because it does not know your boundaries.

The grill-me skill instructs the agent to interview you relentlessly before writing a single line of code. It asks you about edge cases, scopes, constraints, and architecture. It forces you to make conscious engineering trade-offs upfront.

The emergent behavior from the model is striking. It challenges you like a seasoned principal engineer. It reminds me of the senior engineers who mentored me early in my career, forcing me to justify every architectural decision. Once the agent understands your exact value hierarchy, the quality of its downstream implementation increases by an order of magnitude.

Managing the Smart Zone: Context Windows and Specs

Gergely Orosz: Once you finish a thorough grilling session, how do you convert that discussion into actual production code without overwhelming the model's memory?

Matt Pocock: You have to design around context window limits. Dex Horothy previously discussed the concept of the "smart zone" versus the "dumb zone." As a context window fills up with tens of thousands of tokens, every token competes for attention. When you cram too many tokens into a prompt, the model loses track of subtle relationships and begins making careless mistakes.

Even with multi-million token windows, frontier models perform best within their initial 150,000 tokens—the smart zone. To complete work larger than that threshold, you must break it across multiple isolated sessions.

My workflow uses two key artifacts:

1. A Specification (Spec): A single source of truth describing the target destination and acceptance criteria.
2. Individual Tickets: Granular, self-contained units of work derived from the spec, designed to be executed in a single, focused session.

You conduct a grilling session to establish all architectural constraints, compile the findings into a spec, break that spec into 30 or 40 tickets, and then execute each ticket in a clean context session.

This approach enables an ideal division between the "day shift" and the "night shift." During the day, you invest high-focus time into planning, refining