↓Skip to main content
Zeitgeist — a spike by Chris Gathercole
  1. Creators/

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).

Index #

2026-08-21 — LIVE: Uncle Bob on Software Fundamentals in the Age of AI #

YouTube · Watch/Read

  • The core discussion revolves around the enduring relevance of software fundamentals for developers, even in an age where AI acts as a coding agent.
  • The conversation explores specific points of agreement and disagreement between Matt Pocock and Robert C. Martin (Uncle Bob) regarding how these fundamentals apply when working with AI.
  • The implicit takeaway is that developers must still master software fundamentals to effectively collaborate with, guide, and critically evaluate the output of AI coding agents.

2026-08-10 — New Skills! v1.2 brings /wait-what, /writing-for-agents, and fixes /grill-me #

YouTube · Watch/Read

  • Matt Pocock has released Skills v1.2.0, a significant update designed to enhance AI agent capabilities through new tools and improved clarity.
  • Key new skills include “/wait-what” for managing Opus verbosity, “/writing-for-agents” for better agent communication, and the powerful “/wizard” skill for infrastructure provisioning.
  • The “/grill-me” skill has been updated to support multi-question rounds, and the release also features a new documentation site and Claude Code marketplace integration for easier access and discovery of skills.

2026-07-30 — /wayfinder: Nothing is too big to plan anymore #

YouTube · YouTube

  • Dedicated deep-dive on /wayfinder, previously mentioned only in passing in the July 8 skills-changelog video — positions it as a “big-idea on-ramp” for efforts too large and foggy to spec in a single sitting.
  • Core mechanism: figures out the frontier of decisions that can be made right now, uncovers the route ahead incrementally as work proceeds, and runs research/prototyping/discussion sessions along the way rather than requiring an upfront full spec.
  • Maintains a living map in an issue tracker of the user’s choice (GitHub, Linear, etc.) — a single parent issue whose children are the tickets, growing as new unknowns surface and shrinking as questions get answered.
  • Positions it as the next evolution of /grill-me//grill-with-docs, now acting as an orchestrator over the top of them rather than a replacement invoked standalone.
  • Practical takeaway: reach for /wayfinder specifically when an effort exceeds what one agent session can hold and the destination is still foggy — Pocock reports using it to plan an entire course over four days and ~100 grilling/prototyping/research sessions, and says it’s revolutionized his planning even outside of coding.

2026-07-23 — Don’t waste time on specs: /prototype instead #

YouTube · YouTube

  • Argues detailed up-front specs are inefficient for UI-heavy work compared to prototyping directly with AI; introduces “design fidelity” as the concept for how much prototype detail is worth building before implementation.
  • Demonstrates a new /prototype workflow inside Wayfinder — build a rough interactive prototype (search-bar example), iterate on the prototype directly, then transition from prototype to production once the design is validated.
  • Practical takeaway: skip the exhaustive written spec for design-heavy work; let the prototype absorb the design decisions, then formalize afterward.

2026-07-21 — There is no such thing as greenfield #

YouTube · YouTube

  • Argues the greenfield/brownfield distinction is mostly meaningless in modern AI-assisted development — real-world constraints, existing conventions, and documentation/design choices make every project effectively “brownfield” almost immediately.
  • Practical takeaway: don’t defer establishing conventions and documentation on a “greenfield” project on the assumption there’s time later — brownfield-style constraints show up within days.

2026-07-20 — Using /grill-me for interviews?! #

YouTube · YouTube

  • Demonstrates repurposing the /grill-me skill (originally a planning/interrogation tool) as a technical-interview evaluator for candidates’ AI collaboration skills and strategic thinking.
  • Emphasizes clear communication and appropriate long-term perspective as the evaluation criteria when assessing how someone works with AI.
  • Cross-topic relevance: touches claude-teams (AI-assisted hiring/evaluation practice).

2026-07-20 — What is the dumb zone? #

YouTube · YouTube

  • Names “the dumb zone” — the point where, despite million-token context windows, added context degrades output quality rather than improving it, due to attention degradation.
  • Teaches strategies for staying out of the dumb zone: minimizing token expenditure while preserving the information the model actually needs.
  • Practical takeaway: bigger context windows don’t remove the need for context curation — attention degrades well before the token limit does.

2026-07-20 — Do you even need human review? #

YouTube · YouTube

  • Teaches strategic repositioning of human-review checkpoints across an AI-assisted dev workflow — sometimes early human involvement (before generation) beats end-of-pipeline review.
  • Practical takeaway: place checkpoints per task — early review for alignment-sensitive work, late/no review for low-stakes autonomous work.

2026-07-17 — This change makes /grill-me SO MUCH BETTER #

YouTube · YouTube

  • Reworks /grill-me’s question flow from sequential one-at-a-time questions to a batch/rounds-based system, cutting wait time and context-switching while still handling question interdependencies.
  • Practical takeaway: for any interrogative/planning skill, batch related questions into rounds rather than asking one at a time — a transferable UX pattern for skill design.

2026-07-17 — Framework Hell, Tutorial Hell… now Skill Hell #

YouTube · YouTube

  • Names “skill hell” — the failure mode of accumulating too many frameworks/skills inside an agent’s context until it overwhelms the context window.
  • Advocates intentional user control over which skills load and deliberate skill orchestration, rather than “automate everything by default.”
  • Meta-observation candidate: directly relevant to this project’s multi-agent-cognitive-load and permission-friction quests — skill/tool sprawl as a named failure mode.

2026-07-17 — Kill your MEMORY.md #

YouTube · YouTube

  • Contrarian take: agent memory mechanisms (auto-memory, MEMORY.md-style persistent files) harm more than they help.
  • Recommends disabling Claude Code’s auto-memory feature and keeping agents stateless for predictability and reliability.
  • Directly contradicts the persistent-MEMORY.md pattern this project itself relies on (see ~/.claude/projects/.../memory/MEMORY.md) — flagged as a notable dissenting view, not something to adopt without discussion.

2026-07-17 — This change makes /grill-me SO MUCH BETTER #

YouTube Shorts · YouTube

  • Ships a batch-based question system for /grill-me: instead of asking questions one at a time, the skill now asks them in rounds.
  • Motivation: reduces wait times and context switching for the user while still handling dependencies between questions.
  • Directly resolves the tradeoff Matt was weighing days earlier in “I’m thinking about changing my most popular skill” — this is the shipped redesign of Claude Code’s most-used interviewing skill.
  • Takeaway: sequential one-question-at-a-time interviewing has a real UX cost; batching preserves dependency handling while cutting round trips.

2026-07-17 — Framework Hell, Tutorial Hell… now Skill Hell #

YouTube Shorts · YouTube

  • Names a new failure mode, “Skill Hell”: combining multiple frameworks and skills into an AI agent without a coherent strategy overloads the context window.
  • Frames it as the natural successor to “Framework Hell” and “Tutorial Hell” — each generation of dev tooling produces its own version of unmanaged proliferation.
  • Core argument: the fix is more user control, not more automation — intentional, deliberate skill orchestration rather than loading every skill into the agent’s context by default.
  • Practical takeaway: audit which skills/frameworks are actually loaded per task rather than enabling everything globally.

2026-07-17 — Kill your MEMORY.md #

YouTube Shorts · YouTube

  • Argues persistent agent memory (auto-generated MEMORY.md-style files) is net harmful, not helpful, for coding agents.
  • Recommends disabling auto-memory in Claude Code and keeping the agent stateless — deterministic behaviour beats accumulated, potentially stale or wrong context.
  • Sits in tension with Matt’s own /teach skill (explicitly stateful, tracks learner progress) — the distinction is state for a user-facing learning tool vs. state for a coding agent, where drift risk is higher.
  • Takeaway: default to stateless agent configuration for coding work; only add persistent memory where the state genuinely needs to survive sessions and drift is managed.

2026-07-16 — Do software fundamentals still matter? #

YouTube · YouTube

  • Argues code quality, entropy management, and design patterns matter more, not less, in the AI era — clean codebases make AI agents more productive; messy ones amplify agent mistakes.
  • Practical takeaway: treat codebase quality as a force multiplier for agent output, not a legacy concern superseded by AI capability.

2026-07-16 — My /teach skill is still insane #

YouTube · YouTube

  • Showcases the /teach skill teaching non-coding subjects (land surveying, Rubik’s Cubes) via interactive explanation and assessment questions, demonstrating the skill generalizes well beyond its original TypeScript-education use case.

2026-07-16 — Claude Code’s system tools are SO BLOATED #

YouTube · YouTube

  • Demonstrates trimming Claude Code’s system prompt via settings.json by disabling unused built-in features, cutting system-prompt size from roughly 25,000 to ~8,000 tokens.
  • Practical takeaway: audit and disable unused Claude Code features per-project — system-prompt bloat is a real, measurable, and fixable token cost.
  • Meta-observation candidate: concrete technique relevant to claude-expertise/claude-integrations — worth testing against this project’s own settings.json.

2026-07-16 — mattpocock/skills: A complete AI Coding workflow, end-to-end #

YouTube · YouTube

  • Full walkthrough of the mattpocock/skills repo (now past 170,000 GitHub stars), covering the complete pipeline: interviews → documentation → spec creation → ticket generation → implementation with code review.
  • Scale signal: 170,000 stars is a notable growth marker for this skills ecosystem, worth tracking.

2026-07-16 — I’m thinking about changing my most popular skill #

YouTube · YouTube

  • Deliberates publicly on whether to change /grill-me’s default questioning style from sequential to batch, or ship a separate variant — resolved two days later by the 2026-07-17 “batch rounds” video above.

2026-07-16 — My #1 book recommendation for strategic programming #

YouTube · YouTube

  • Recommends The Pragmatic Programmer for strategic, non-AI-specific development thinking.
  • Argues classic engineering principles (tracer bullets, avoiding “programming by coincidence”) remain essential for long-term codebase thinking even in the AI-agent era.

2026-07-16 — Delete (most of) your docs #

YouTube · YouTube

  • Argues excessive documentation written for AI consumption is itself an anti-pattern — it consumes tokens and generates confusion rather than serving as a clear source of truth.
  • Practical takeaway: prune documentation aggressively; a shorter, more authoritative doc set outperforms a comprehensive-but-bloated one for AI-agent consumption.
  • Cross-topic tension: worth weighing against this project’s own CLAUDE.md/dev/docs approach at some point (not now).

2026-07-16 — Do software fundamentals still matter? #

YouTube Shorts · YouTube

  • Central question: does AI coding assistance make traditional software fundamentals obsolete? Answer: no — they matter more, not less.
  • Reprises “software entropy” accelerating under AI-generated code without architectural discipline — echoes the April “De-Slop A Codebase” video.
  • Frames good design patterns as being for the AI’s benefit as much as the human’s: a codebase AI can navigate well produces better AI output.
  • Takeaway: fundamentals aren’t legacy skills being displaced by AI — they’re now a precondition for getting good results from AI.

2026-07-16 — My /teach skill is still insane #

YouTube Shorts · YouTube

  • Follow-up to the June 8 /teach skill introduction, showing expanded use beyond software — land surveying, Rubik’s Cubes — alongside development topics.
  • Demonstrates personalised, adaptive learning: interactive explanations plus quiz questions tailored to the learner.
  • Reinforces the skill’s staying power since initial release and its generalisation beyond its original coding-education use case.
  • Takeaway: a well-designed stateful teaching skill generalises across domains, not just the one it was built for.

2026-07-16 — Claude Code’s system tools are SO BLOATED #

YouTube Shorts · YouTube

  • Concrete claim: Claude Code’s default system prompt can run ~25,000 tokens; disabling unused built-in features/tools cuts it to ~8,000 tokens.
  • Mechanism: customising the global settings.json to turn off tools/features that aren’t being used, rather than accepting the default tool surface.
  • Positions this as pure efficiency — same capability, roughly two-thirds fewer tokens spent on system-prompt overhead per turn.
  • Practical takeaway: audit and trim settings.json tool/feature flags before treating context-window pressure as an unavoidable cost of using Claude Code.

2026-07-16 — mattpocock/skills: A complete AI Coding workflow, end-to-end #

YouTube · YouTube

  • Full walkthrough of the mattpocock/skills repo (noted in the description at 170,000 stars) — install, setup, and the main end-to-end workflow.
  • Chaptered structure: install → setup/configuration → “Ask Matt” onboarding → main workflow → /grill-with-docs interview session → creating specs and tickets → implementation with code review → recap.
  • Ties together the whole recent skills arc — /grill-with-docs, /to-spec, /to-tickets, /implement, /code-review — showing them chained into one pipeline rather than covered piecemeal.
  • Takeaway: the reference onboarding video for the skills package — how the individually-covered skills compose into one workflow.

2026-07-16 — I’m thinking about changing my most popular skill #

YouTube Shorts · YouTube

  • Open deliberation (pre-decision) about changing /grill-me’s default behaviour: ask all questions simultaneously vs. the current one-at-a-time sequence.
  • Frames it as a genuine tradeoff — considers whether to change the default or ship a separate/alternate skill instead.
  • References his own prior “9 Things People Get Wrong With /grill-me and /grill-with-docs” critique as the friction this would address.
  • Resolved the same day/next in “This change makes /grill-me SO MUCH BETTER,” which ships the batched-question version — a useful before/after pair on the design decision process.

2026-07-16 — My #1 book recommendation for strategic programming #

YouTube Shorts · YouTube

  • Recommends The Pragmatic Programmer (Hunt & Thomas) as the top book for “strategic programming” in the AI era.
  • Highlights two named concepts as still directly relevant: “tracer bullets” (thin end-to-end implementations to validate direction early) and “programming by coincidence” (code that works without the author understanding why — a risk AI assistance can amplify).
  • Argues classic software engineering fundamentals set the frame for thinking long-term about codebases, not just tactically.
  • Takeaway: a decades-old book stays load-bearing because AI shifts programming toward more strategic, less tactical work — its concepts map onto today’s AI-coding decision points.

2026-07-16 — Delete (most of) your docs #

YouTube Shorts · YouTube

  • Core claim: treating extensive documentation as an AI codebase’s “source of truth” is an anti-pattern — costs tokens and creates confusion when docs drift from the actual code.
  • Advocates a code-centric approach: well-structured, well-named code should be the primary source AI agents read from, with docs trimmed to only what can’t be inferred from source.
  • Consistent throughline with Matt’s /init/CLAUDE.md critiques (Feb 2026 videos) — the same “verbose generated context is a token tax” argument, now applied to project documentation generally.
  • Takeaway: audit project docs for what AI agents actually need vs. what’s redundant with readable code, and delete the redundant majority.

2026-07-15 — AI Coding is exhausting #

YouTube Shorts · YouTube

  • Central argument: AI has eliminated the tactical, routine parts of programming (boilerplate, mechanical edits) but shifted developers to operating constantly at a higher strategic level.
  • Net effect isn’t less work, it’s a different kind of fatigue — less grunt work, but significantly more mental strain from continuous high-level decision-making.
  • Frames this as an underdiscussed cost of AI-assisted development that pure productivity metrics miss.
  • Takeaway: expect a shift in where effort is spent (strategic judgement) when adopting AI coding, not a straightforward reduction in total effort.

2026-07-15 — Don’t know which model to choose? taps the graph #

YouTube Shorts · YouTube

  • Uses the DeepSWE Benchmark (deepswe.datacurve.ai) to compare models — explicitly names Claude Sonnet 5, Claude Fable, and GPT 5.6 Sol — across different effort/reasoning levels.
  • Framing device (“taps the graph”): a cost-to-performance chart as the practical decision tool, rather than qualitative impressions of which model “feels” better.
  • Emphasises effort level as a second axis in the cost/performance tradeoff — the same model at different effort settings lands in different places on the graph.
  • Takeaway: pick models empirically off a cost-to-performance benchmark, and treat effort level as a tunable dimension alongside model choice.

2026-07-15 — A dictionary of AI Coding #

YouTube Shorts · YouTube

  • Launches a companion resource: aicodingdictionary.com, plus an open-source GitHub repo (mattpocock/dictionary-of-ai-coding).
  • Purpose: cut through jargon with plain-English definitions for terms like prompt engineering, context windows, and tool calls.
  • Positioned as a living, linkable reference — a later video the same week (“My agent hallucinated”) links directly to a specific dictionary term (?term=attention-degradation).
  • Takeaway: a standing glossary artifact that Matt’s own subsequent content links back into, worth treating as ongoing shared vocabulary rather than a one-off video topic.

2026-07-15 — My agent hallucinated - what do I do? #

YouTube Shorts · YouTube

  • Distinguishes two hallucination types: factuality hallucinations (claims that are simply false) vs. faithfulness hallucinations (output that doesn’t match the given context/instructions) — links to the AI Coding Dictionary’s “attention-degradation” entry as a related mechanism.
  • Treats this as a taxonomy question first, remediation second: the fix depends on which type occurred.
  • Covers techniques for maintaining agent reliability once a hallucination is identified — contrasts with the March “Never Trust An LLM” video, which explained why hallucination happens generally rather than how to triage it.
  • Takeaway: diagnose which hallucination type occurred before choosing a fix — factuality and faithfulness failures call for different mitigations.

2026-07-15 — Your effort level is TOO DAMN HIGH #

YouTube Shorts · YouTube

  • Core claim: defaulting to maximum effort/reasoning settings is often counterproductive — lower effort levels frequently produce better results.
  • Mechanism: better task specification (clearer, more bounded prompts) reduces the tokens the agent needs to spend reasoning, making lower effort settings sufficient and often more reliable.
  • Connects to the same DeepSWE benchmark framing used in “Don’t know which model to choose?” — effort level as a tunable axis independent of model choice.
  • Takeaway: treat “max effort” as a default to question, not a safe default — pair effort-level tuning with tighter task specs rather than compensating for vague prompts with higher effort.

2026-07-08 — New Skills! v1.1 brings /wayfinder, /research, /implement, /to-spec, /to-tickets #

YouTube · YouTube

  • v1.1 release of the mattpocock/skills package — the first major version bump since the initial release. Key additions: /wayfinder (graduated from in-progress; planning tool for large, multi-session efforts with tracker-native blocking and HITL/AFK classification), /research (background agent for primary-source investigation, returning cited Markdown notes), /implement (full implementation cycle complement to /code-review), /to-spec (renamed from /to-prd, “spec” is now the single through-line term), /to-tickets (merges /to-plan + /to-issues into vertical-slice tickets with blocking-edge declarations).
  • /wayfinder is the headline feature: it moves the planning map off a local Markdown file onto the repo’s issue tracker — a single wayfinder:map issue whose tickets are its child issues. Pocock describes using it for four consecutive days planning an entire course, closing in on 100 grilling/prototyping/research sessions all contributing back to a central map that grows as you learn and shrinks as you find answers.
  • /code-review now uses a fixed “Fowler smell baseline” (~12 named code smells: Mysterious Name, Duplicated Code, Feature Envy, etc.) as a standards reference — the “Martin Fowlerized” version Pocock previewed in the July 3 journal run is now shipped.
  • /grilling gets a confirmation gate before plan enactment and separates facts (codebase exploration) from decisions (human input required) — making the human-in-the-loop boundary explicit.
  • Install/update: npx skills@latest add mattpocock/skills

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.