Matt Pocock — Total TypeScript

About #

TypeScript educator and author of Total TypeScript — the leading advanced TypeScript course and workshop series. Known for making complex type-level concepts approachable through tips, tutorials, and interactive exercises. Active on X/Twitter (@mattpocockuk).

2026-06-08 — Learn anything with the /teach skill #

YouTube · ~8 min · YouTube

• Introduces a stateful /teach skill for Claude Code that creates personalised lessons tracking learner progress and adapting to each person’s zone of proximal development — distinct from stateless skills because it persists state across sessions.
• Covers the skill design tradeoffs: stateful vs. stateless approaches, HTML-based interactive content for richer lesson formats, and embedding reference materials so the skill has context without requiring repeated re-uploads.
• Practical use cases: developer onboarding (consistent curriculum with progress tracking) and independent self-directed learning on complex topics (TypeScript type system, advanced patterns) where the learner wants structured feedback rather than one-off answers.
• Takeaway: skills that maintain learner state across sessions are qualitatively different from single-turn prompts — the skill becomes a persistent teacher rather than a lookup tool.

2026-05-28 — Can Cursor’s HARDCORE Review Skill Stop The Slop? #

YouTube · YouTube

• Live test of a “thermonuclear code quality review” skill for Cursor: a strict automated review prompt that demands structural improvements, enforces file size limits, challenges spaghetti code, and insists on type boundary cleanliness.
• Run against Matt’s Sandcastle project: roughly 5 of 7 suggestions were genuinely useful — ambitious review prompts produce more false positives but surface real issues that would otherwise go unmissed.
• Notable gaps in the skill: no focus on testing or seams; the prompt itself is repetitive and could be condensed. Matt treats this as a useful baseline but not a complete quality gate.
• Practical takeaway: ambitious review prompts with a high bar catch real structural problems at the cost of noise — treat them as a first-pass signal generator, not an authoritative quality verdict.

2026-05-25 — 9 Things People Get Wrong With My /grill-* Skills #

YouTube · YouTube

• Nine common failure modes when using the /grill-* structured interview skills — a suite of AI specification and challenge prompts Matt has built into his Claude Code workflow.
• Most mistakes involve timing, scope, or context preparation rather than the skill logic itself: invoking a skill without domain context established or scope bounded wastes context and planning time.
• Connects to Matt’s recent arc: Sandcastle (parallel agents), /grill-with-docs (domain-first interviewing), /handoff, /prototype — each skill has specific preconditions that determine output quality.
• Practical takeaway: treat /grill-* skills as having an activation cost — verify domain context is established and scope is bounded before invoking. The skill is not self-sufficient; the setup is the work.

2026-05-22 — Sandcastle: Matt Pocock’s Secret AI Engine [2026] #

YouTube · YouTube · GitHub

• Sandcastle is Matt’s open-source TypeScript framework for orchestrating parallel sandboxed coding agents: each agent runs in Docker (or Podman/Vercel), receives a worktree, executes, and patches commits back to the host when done. The sandcastle.run() function is the single entry point — low-ceremony by design.
• Key workflow: Sandcastle reads a backlog of issues, spawns N Claude agents in isolated Docker containers on separate git worktrees, each tackling one issue, then merges all successful worktrees back to a target branch. Entirely AFK; the developer reviews the merge, not the execution.
• The meta-demonstration: Sandcastle itself was built with 889 commits, none hand-coded. Matt used his own skills system to generate the specs; Sandcastle executed them. Self-dogfooding as validation.
• Practical takeaway: if you want parallel AFK agent execution with complete data isolation (everything stays local, no cloud inference) and TypeScript-native orchestration, Sandcastle is the current reference implementation for that pattern.

2026-05-14 — I stopped using /grill-me for coding. Here’s what I use instead: #

YouTube · ~13 min · YouTube

• Introduces /grill-with-docs, the evolution of /grill-me: adds domain-driven design concepts (ubiquitous language) to conversational AI interviewing, so Claude develops shared vocabulary with the developer before writing code.
• Core problem with /grill-me: it interviews you generically, without domain context. /grill-with-docs runs a /ubiquitous-language step first to establish shared project vocabulary, then grills with that context in mind.
• Introduces Architecture Decision Records (ADRs) as a natural byproduct: the grilling process surfaces and documents architectural decisions that would otherwise stay implicit.
• Practical takeaway: run /grill-with-docs before coding any new project or feature area to align Claude on your domain model — reduces AI drift and produces shareable architecture documentation as a side effect.

2026-05-13 — Anthropic’s “dedicated monthly credit” is actually a huge cut #

YouTube · YouTube

• Analyses Anthropic’s June 15 change: Pro/Max subscriptions receive a “dedicated monthly credit” for AFK workflows via Claude Agent SDK and GitHub Actions — framed positively in marketing, but Matt argues this represents a material reduction in available Claude usage for automated/background tasks relative to current offerings.
• Core concern: the “dedicated” framing implies a quota separate from (and smaller than) the general usage allocation, which would limit autonomous agent workflows that currently run uncapped within the subscription.
• Practical takeaway: developers building AFK pipelines on Claude Pro/Max should audit their current usage before June 15 and consider whether to shift to API billing to avoid hitting the new quota ceiling.

2026-05-12 — New Skills! /handoff, /prototype, /review and /writing-* | Skills Changelog #

YouTube · YouTube

• Introduces several new skills published to the Claude Code skills ecosystem: /handoff (session handoff protocol for continuing work across context resets), /prototype (rapid prototyping workflow), /review (structured code/PR review), and a suite of /writing-* skills for long-form writing workflows.
• The /handoff skill in particular addresses a common pain point in multi-session agentic work — maintaining continuity of context when context windows reset.
• Also covers bug fixes and improvements to existing writing skills. Changelog-format video: useful as a reference for what new community-contributed skills are available.

2026-05-07 — Burn through the backlog from hell with /triage #

YouTube · YouTube

• Introduces the /triage Claude Code skill for managing GitHub issue backlogs at scale — argues that messy human-written issues need to be translated into structured, machine-actionable tasks before AI agents can work on them effectively.
• Uses state machines and labels as the mechanism for categorising issues: the triage step isn’t just sorting, it’s a translation layer from human intent to agent-legible state.
• Core insight: the bottleneck in AI-driven development is often not the agent’s capability but the quality of its input — badly-specified issues are a tax on every subsequent step.

2026-04-30 — I Open-Sourced My Own AFK Software Factory #

YouTube · YouTube

• Introduces Sandcastle, an open-source TypeScript library for orchestrating Claude Code and other coding agents in isolated sandboxes — enabling “AFK” (away-from-keyboard) autonomous development loops.
• Sandboxed isolation is presented as necessary, not optional: agents need a clean environment to avoid polluting the working codebase while operating autonomously.
• The framing of “software factory” positions this as infrastructure for multi-agent pipelines rather than single-session assistance — agents hand off work between stages rather than one agent doing everything.

2026-04-29 — How To De-Slop A Codebase Ruined By AI (with one skill) #

YouTube · YouTube

• Argues that AI accelerates software entropy: codebases degrade faster when AI generates code without architectural discipline, accumulating “slop” — shallow modules, duplicated logic, unclear boundaries.
• Positions deep modules (a concept from John Ousterhout’s A Philosophy of Software Design) as the architectural defence: well-defined interfaces with complex hidden implementations give AI agents clear targets and reduce the surface area for slop.
• Practical path: AI-assisted refactoring fundamentals, not from-scratch rewrites — the goal is progressive densification of the codebase, not a big-bang restructure.
• Cross-column note: overlaps directly with the vibe-coding-applications journal — architecture discipline as AI scales is a recurring theme.

2026-04-17 — LIVE: Watch me build a brand-new project from scratch #

YouTube · YouTube

• Live session demonstrating end-to-end project creation using AI-assisted development — from blank repository to working feature.
• Less structured than scripted content; value is in observing real decision-making under uncertainty rather than polished technique demonstration.

2026-03-27 — Never Trust An LLM #

YouTube · YouTube

• LLMs hallucinate constantly — they fabricate facts, invent entities, and ignore context even when the correct answer is present. This isn’t a temporary alignment problem but a structural property of how models work.
• Explains why it happens (probabilistic next-token prediction has no truth-grounding mechanism) and what patterns of input reliably trigger hallucination.
• Practical defence: treat LLM output as a hypothesis requiring verification, not a source of truth. Design workflows where LLM claims are always checked against authoritative sources before being acted upon.

2026-03-23 — Claude Code tried to improve /init… Is it any better? #

YouTube · YouTube

• Reviews the redesigned /init command following community feedback — candid assessment of what improved and what didn’t.
• The core critique persists: auto-generated CLAUDE.md and agents.md produce verbose, low-signal context files that consume token budget without adding useful structure.
• Useful as a benchmark of what Anthropic considers “good” default context — and implicitly, what conventions are worth overriding in your own setup.

2026-03-18 — Building a REAL Feature with Claude Code: Every Step Explained #

YouTube · YouTube

• End-to-end walkthrough: brainstorm → autonomous implementation → quality assurance testing, with every decision point narrated.
• Demonstrates that the bottleneck in AI-assisted development is not the coding step but the specification step — ambiguous intent produces confident but wrong output.
• QA is shown as non-negotiable: AI-generated code passes syntax checks but requires adversarial human review at integration boundaries.

2026-03-16 — 5 Claude Code Skills I Use Every Single Day #

YouTube · YouTube

• Presents five skills as the core of “process-driven development with LLMs” — the argument is that skills (structured, reusable prompts with defined steps) outperform ad-hoc prompting for repeatable tasks.
• Emphasises that AI agents need process, not just instructions: a skill is a deterministic procedure the agent follows, reducing variance and making outcomes predictable.
• Cross-column note: directly relevant to the claude-expertise journal — the skills-as-process framing is a concrete instantiation of AI workflow design.

2026-03-03 — The 7 Phases of AI-Driven Development #

YouTube · YouTube

• Proposes a structured framework for shipping quality work with coding assistants: idea → research → prototype → PRD → implementation planning → execution → QA.
• The key insight: AI is most effective when it operates within a defined phase with clear inputs and outputs — treating development as a pipeline rather than a conversation.
• PRD (Product Requirements Document) as a phase is notable: Matt argues you need a machine-readable spec before the implementation phase, not just a vague prompt.

2026-02-26 — Your Codebase Is NOT Ready for AI (Here’s How to Fix It) #

YouTube · YouTube

• Most codebases aren’t structured for AI-assisted development: shallow modules, tangled dependencies, and implicit conventions create high cognitive load for agents and produce low-quality output.
• Deep modules (well-defined interfaces hiding complex internals) are the structural fix — they give AI agents clear targets and reduce the surface area requiring context.
• Architecture discipline is not an aesthetic choice; it’s a force multiplier for AI. The same codebase produces substantially better agent output after structural improvement, before any prompt engineering.

2026-02-25 — How to Actually Force Claude Code to Use the Right CLI #

YouTube · YouTube

• Argues against using CLAUDE.md as the mechanism for directing agents toward specific CLI tools — it’s context-consuming, fragile, and agents ignore it under load.
• Deterministic hooks are the correct solution: configure the environment so the right tool is the only option, rather than relying on instruction-following.
• Practical implication: the more consequential the CLI command, the more it needs to be enforced structurally rather than instructed linguistically.

2026-02-24 — Never Run claude /init #

YouTube · YouTube

• Auto-generated CLAUDE.md from /init is worse than a hand-crafted one: it produces verbose boilerplate that fills token budget without communicating project-specific conventions.
• What actually belongs in CLAUDE.md: genuine constraints the agent cannot infer from code (non-obvious architectural decisions, external system quirks, human workflow preferences).
• Implicit rule: anything derivable from reading the codebase should not be in CLAUDE.md — the agent can read code, it can’t read your mind.

2026-02-23 — Red Green Refactor Is OP With Claude Code #

YouTube · YouTube

• TDD’s red-green-refactor cycle produces substantially better results from Claude Code than unconstrained implementation: the failing test is an unambiguous success criterion the agent can verify autonomously.
• AI agents are good at satisfying explicit constraints and bad at inferring implicit ones — TDD externalises the implicit into a test, eliminating a major source of drift.
• The “refactor” phase is where agent output most often degrades; human review at that stage is disproportionately valuable.

2026-02-21 — I’m Using claude –worktree for Everything Now #

YouTube · YouTube

• Worktrees allow Claude Code to operate on an isolated branch without polluting the working directory — the agent’s changes are contained and reviewable before merge.
• Positions worktrees as the default mode for any non-trivial agent task: the cost of setup is low, the cost of an unwanted change to main is high.
• Workflow pattern: agent works in worktree → human reviews diff → merge or discard. The review step is the control layer, not the prompt.

2025-04-23 — Cursor Rules for Better AI Development #

Article · totaltypescript.com

• Argues that community .cursor/rules directories are underdocumented and lack practical code examples — most are shallow lists of dos and don’ts without rationale.
• Core recommendation: declare explicit return types on top-level module functions so AI assistants can understand function purpose without reading the implementation; exclude JSX components from this rule.
• Broader principle: cursor rules are a communication layer between human intent and AI execution — investing in them pays compound returns on every subsequent AI interaction in the project.