Matt Pocock

Matt Pocock is the creator of Total TypeScript and AI Hero. His TypeScript teaching brings library-maintainer techniques into application development through practical exercises. His AI work applies software-design principles to the requirements, architecture, testing, and review surrounding coding agents’ implementation work.

A teacher becomes a developer

Before programming professionally, Matt taught voice, singing, and public speaking. From 2015 to early 2018, he worked at VoiceHacker, giving individual lessons and workshops on presentation, confidence, accent training, and actor training.

His professional development career began at Canary Care in 2018, maintaining and refactoring PHP software, building React views, and working with automated tests. At The Virtual Forge, he contributed to learning and apprenticeship applications within small development teams. He subsequently worked on a commercial multi-tenant application at ONE, then led a small team at Yozobi, combining development with client conversations and technology decisions. He also launched AgentRelay while working at the agency.

In 2021, Matt joined Stately to work on the XState core team. He moved from lead development into a combined development and advocacy role, rewriting XState documentation and helping launch Stately’s beta. His XState Codegen inspected state-machine definitions to generate types for transitions, actions, guards, services, and state references. The exploratory project was subsequently superseded by improved type generation integrated into XState itself.

Solving XState typing problems brought Matt into contact with experienced TypeScript authors and application developers. He turned what he learned into videos, began publishing TypeScript tips in early 2022, and announced an advanced course that April. A three-month, part-time Vercel contract gave him time to develop it. There, he rewrote Turborepo documentation, helped write Turbopack documentation, and recorded monorepo resources. Successful live workshops helped him commit to Total TypeScript full-time when the contract ended.

Making the difficult part worth doing

Matt developed Total TypeScript with Badass’s production team. He created and taught the curriculum; collaborators supplied platform development, design, production, accompanying written material, and commercial support.

Workshop feedback changed his exercises. He moved from introducing concepts through simple examples to giving learners challenging code that made the concept useful. But leaving too much code unwritten created busywork. He learned to concentrate the challenge into the particular line or decision that mattered, rather than ask learners to reconstruct boilerplate around it.

Matt also connected his conversational, unscripted recording style to years of individual teaching and dramatic training. He prepared the curriculum and its sequence carefully, then explained the code as though teaching one person.

Total TypeScript puts that method into an exercise-driven sequence: examine problematic code, attempt a solution, consult documentation, and then watch Matt solve it. Generics, inference, type transformations, and advanced library patterns become tools for a problem the learner has already encountered.

His open-source ts-reset addresses recurring friction in TypeScript’s declarations for common JavaScript APIs. JSON.parse and response .json() return unknown rather than any, requiring callers to establish what the data contains before treating it as a known type. Other rules improve filtering and membership checks. These changes have a consequential limit: they affect global declarations, so the package belongs in applications rather than published libraries, whose consumers would otherwise inherit the changes simply by importing them.

Changing his mind about AI coding

Matt’s AI teaching developed through experiments that disappointed him. He tried repeatedly generating code from specifications while minimizing attention to the implementation. He initially looked for ways to improve that process, but found the resulting code increasingly difficult to change. His response was to return to software-design principles and make the codebase’s structure part of planning.

That experience underlies AI Hero. Matt argues that poor architecture becomes more costly when agents can add code quickly: tangled dependencies and weak tests make subsequent automated work harder to direct and assess. His Skills for Real Engineers turns established practices into small, editable agent procedures that developers can adapt to their projects.

Several ideas make that position concrete:

• Shared understanding before implementation. Grill Me makes an agent question assumptions and dependent decisions before the human commits to an idea. Matt developed this approach after finding planning tools too eager to produce a document. He later dropped his advice to make plans extremely terse: questioning had become more useful to him than reading a compressed plan. His guidance also limits the technique. Automatic agreement can produce unwarranted confidence, and questions about an interaction’s feel require a prototype rather than another round of conversation. Grill with Docs connects the questioning to a codebase and records shared terminology and architectural decisions.

• Vertical slices and early feedback. Matt adapts the tracer-bullet technique from The Pragmatic Programmer: build one small path through the necessary layers and test it before expanding. In his own work, he connected a backend operation to one interface location before adding the remaining entry points. Completing a database, then an API, then an interface postpones discovery of integration failures; a working slice exposes them while the change is still small. Test-driven development and static checks supply feedback during implementation, followed by manual quality assurance.

• Deep modules with simple interfaces. Drawing on John Ousterhout, Matt favors substantial behavior behind a compact interface. In his course-video-manager application, he applied this thinking to a browser video editor, making an interaction across frontend and backend testable from outside the implementation. His architecture-survey skill identifies opportunities for that restructuring and presents candidates for human consideration. It queues work for a separate implementation phase; it does not automatically untangle an entire legacy system. Testable interfaces also let engineers understand a module’s purpose while delegating its internals, with closer scrutiny for critical functionality.

• Skills that earn their instructions. Matt’s skill-design framework separates procedures from reference material, moves information needed only for particular branches out of the main file, and removes duplication and instructions that do not affect behavior. He favors deliberate human invocation for workflows he wants to control: it avoids relying on the model to select the right procedure, but demands more knowledge from the operator. He also separates questioning from document creation when an agent rushes the first stage to reach the second.

Making review change the next result

Matt’s work on the pull-request bottleneck extends those concerns beyond generating code. He gives automated checks, agent review, and human review different jobs.

A passing test can conceal a poor test. Checking a constant against its own value proves little; checking the order of text in a source file does not establish the order a user sees on screen. Matt connects those failures to architecture: tests through a simple module interface can assess behavior without becoming attached to internal file structure.

He gives standards review its own agent context. An implementer must explore, edit, and debug the code; a separate reviewer can concentrate on the change and the project’s standards. Matt favors reviewers that commit concrete fixes, reserving comments for questions that need human judgment. Otherwise, automated review can simply add another stream of work for the human reviewer.

Human review, in turn, should reflect the consequences of merging. A localized, reversible change warrants different attention from an expensive migration, potential data loss, or a change that sends an email to thousands of people. His Retro procedure examines how the work was produced and proposes better checks, standards, instructions, or navigation. A recurring review comment becomes a candidate for improving the next run.

Tools for evaluation and execution

Matt’s Evalite brings language-model evaluation into TypeScript. Built on Vitest, it provides a local interface for examining outputs, traces, and logs, with score thresholds that can fail a continuous-integration build. Developers can compare model behavior within familiar testing tools.

Sandcastle makes coding-agent execution programmable through TypeScript. It manages sandbox environments, branch strategies, and the commits agents produce, supporting unattended execution, parallel implementation, and review pipelines. Matt built it after finding existing unattended-agent options unsatisfactory. Its orchestration leaves prompts and task management to the developer, allowing the same execution machinery to support different workflows.