AI Skills with Matt Pocock Summary — The Pragmatic Engineer

Matt Pocock, creator of Total TypeScript and popular AI coding skills like “grill me” and “wayfinder,” shares his journey from voice coach to software engineer to AI educator, and explains how classic software fundamentals become more critical when working with AI agents.

Matt spent six years as a voice coach and singing teacher in London before transitioning to software engineering around 2017, motivated by the desire to work remotely from the countryside.
He taught himself JavaScript and TypeScript by building tools for his students, including a web audio analyzer for voice spectrogram analysis.
His teaching background gave him an interview advantage: he could communicate clearly despite limited initial technical knowledge, allowing him to rise quickly through agency roles.
At his first dev job, a senior engineer (who lived on a canal boat) gave him a hardcore Linux onboarding (CentOS 6) and mentored him deeply.
He moved through several agencies, working with TypeScript and React, and solved a front-end/back-end contract mismatch by introducing TypeScript, which dramatically improved team velocity.

Matt contributed to XState (state machine library) after using it for a complex real-time video collaboration project, eventually joining the core team alongside David Khourshid and other elite engineers.
XState raised funding to form Stately; Matt joined as a developer advocate, earning “American money” for the first time — a life-changing compensation shift.
He spent three months at Vercel on a 3-day/week contract while building Total TypeScript on the side, contributing to Turbopack docs and attending Next.js Conf.
A pre-sale of Total TypeScript generated ~30–40x his Vercel salary, making it clear he had to go full-time on the course.

Total TypeScript, built with course creator Joel Hooks, hit seven-figure revenue quickly and eventually $2.5M total; Matt favors a direct product model over sponsorships or donations.
When AI coding agents matured (especially post-December 2024 “winter break” with Opus 4.5), Matt realized tactical coding knowledge was being commoditized, but strategic wisdom — architecture, design decisions, long-term thinking — remained hard to acquire.
He initially tried building courses on integrating AI into apps, but found the real leverage was in teaching developers how to direct agents strategically.
Inspired by Ralph loops (Jeffrey Huntley) and his own experience embedding agents in apps, Matt began designing reusable “skills” — markdown-based prompt workflows that agents can invoke — to structure planning, implementation, and review.

“Grill me” forces the agent to interview the developer relentlessly before writing code, surfacing decisions about auth, rate limits, error handling, etc. — mimicking a senior engineer’s design review.
Matt discovered “leading words”: repeating terms like “tracer bullet,” “vertical slice,” “deep module,” “ubiquitous language” in prompts causes the model to adopt those concepts in its reasoning, because they exist strongly in its training data (Pragmatic Programmer, Philosophy of Software Design, Domain-Driven Design).
“Grill with docs” extends this by co-creating a domain language (e.g., “materialization cascade” for nested ghost/real entities), which then appears in code, making the codebase more navigable for both humans and agents.

Wayfinder handles projects too large for a single context window by maintaining a persistent “map” (spec + tickets + fog of war) across multiple grilling/prototyping/research sessions.
It treats planning as a directed graph: each session clears the model’s context but persists state in the filesystem, enabling “day shift” planning and “night shift” agent execution.
Matt uses it for non-code projects too (course planning, building a garden office), showing the generality of the process.

Software is uniquely agent-friendly because all inputs (code, docs, specs) and outputs (code, tests, lint, type errors) are text-based; agents struggle with non-text feedback (UI animations, physical simulations).
If other engineering disciplines can express their work as text (simulations, linters), agents will work well there too.

Strategic programming (architecture, module boundaries, deployable units) has a 9-month feedback loop — mistakes surface late. AI accelerates code production, so strategic mistakes arrive faster.
Matt visualizes strategic choices as sliders on a mixing desk (e.g., microservices ↔ monolith); you can’t hear the distortion until the track plays back months later.
The solution: optimize the environment the agent operates in — clean code, strong tests, clear domain language — because agents start fresh every session (Memento-style) and cannot build tribal knowledge.

Organizations need observability over every agent run (success/failure rates, token usage) to A/B test workflows and spread what works — something never feasible with human devs.
Shared skill repos become the team’s “software factory”; Matt runs a daily “improve codebase architecture” loop that proposes refactorings, which he can approve and ship.
The “gardener” metaphor: every team needs people quietly tending the codebase, suppressing lint debt, noticing smells — now automated via review agents that enforce standards and catch tautological tests.

TDD optimizes for human working memory (one failing test = anchor); agents have larger working memory but still need tight feedback loops.
Matt uses a “TDD evidence” prompt: “prove your change works by showing a test that would fail without it” — this forces agents to build their own verification without strict red-green-refactor.
Agents often write tautological tests (asserting implementation details); automated review agents help catch this.

Jared Friedman (YC) claimed tech debt is no longer inevitable; Matt countered: “now you can live with it even in a tiny codebase” — agents produce entropy faster than ever.
Tech debt = anything making future changes harder. Constant battle required: automated review, strong test suites, strategic oversight.

Matt embraces being outside Silicon Valley: no privileged access forces focus on what works now; lifestyle (family, countryside) outweighs proximity to labs.
Teaching hasn’t changed fundamentally: humans need curation — a linear path through the dependency graph of knowledge — which is strategic work AI still struggles with.
Pivoted from TypeScript (tactical) to AI strategy (strategic) at the right moment; acknowledges luck and timing, not just foresight.
Advice for juniors: use agents intensively, but stay curious about process. The best learners are those who introspect on their own workflow and encode it for the agent — “naval-gazing programmers” thrive.

The Pragmatic Programmer (tracer bullets, vertical slices, don’t outrun your headlights)
A Philosophy of Software Design by John Ousterhout (deep modules, complexity management)
First three chapters of Domain-Driven Design by Eric Evans (ubiquitous language, domain modeling)