Matt Pocock’s Agentic Engineering Workflow (just copy him)

Overview

Matt Pocock argues that the real advantage in AI-assisted engineering comes from the harness, not the model: better prompts, better skills, better codebases, and better workflows let Claude Code or similar tools do far more useful work. He frames modern engineering as strategic programming—designing scope, interfaces, tests, and review loops up front—while AI handles the tactical work, then demonstrates his own skills repo, especially the stateful "teach" skill and procedural skills like "grill me," alongside Sand Castle for AFK sandboxed agents and GitHub Actions-based automation. The core message is that senior developers and strong product thinkers become dramatically more effective by improving AX (agent experience), keeping humans in control of vision, review, and product decisions, and only then choosing the model.

Key takeaways

Agentic engineering gains come more from improving the harness—prompts, skills, sandboxing, codebase structure, and review loops—than from endlessly swapping models.
Senior developers get a bigger AI multiplier because their judgment, architecture sense, and product intuition give the model richer context and better boundaries.
Stateful skills can store mission, progress, and local learning records, enabling personalized teaching workflows that are richer than terminal-only interactions.
Procedural skills like "grill me" are often more useful than automatic abilities because they keep the human in control of planning and decision-making.
AFK agents running in Sand Castle and GitHub Actions can parallelize coding, review, and checks safely, but human review still matters for security and quality gates.
AX matters: codebases designed for agents—clear scopes, strong tests, and readable structure—reduce token waste and make cheaper models more effective.

Chapters

0:00 The harness matters more than the model

Matt Pocock argues that prompts, skills, and the execution environment matter more than obsessing over the newest model.
He says the harness is more controllable than the model and includes codebase design, documentation, and prompt quality.
Token spend improves most when the codebase is easier for both humans and agents to modify.

0:42 Strategic programming replaces tactical coding

Matt Pocock applies John Osterhout's tactical vs strategic programming distinction to AI-assisted development.
AI has effectively taken over tactical programming: syntax, bug fixing, and day-to-day code writing.
The human role shifts to strategic decisions about architecture, velocity, and the long-term shape of the codebase.

2:10 Delegation skills: scope, interfaces, tests, and documentation

Good delegation still depends on the same fundamentals: well-scoped tasks, clear interfaces, and strong test suites.
Matt Pocock emphasizes designing the hard parts up front so agents can work with clear boundaries.
A codebase needs just enough documentation to point AI to the right files and patterns.

3:00 AI multiplies senior skills instead of replacing them

Matt Pocock says AI makes senior developers dramatically better because it amplifies judgment and context.
He argues junior developers get a smaller boost, while seniors can supervise a codebase and tell AI what to do.
Skill level sets the ceiling on AI output: better humans get better results from the same model.

4:45 Introducing the teach skill for personalized learning

Matt Pocock built a "teach" skill that turns teaching principles into an agentic curriculum generator.
It uses concepts like zone of proximal development plus knowledge, skills, and wisdom to tailor learning.
He says the skill works especially well for subjects like Git, systems design, and becoming a better developer.

7:00 Using teach to onboard a vibe coder into engineering basics

The example prompt starts from a simple mission: a vibe coder who can read code and use a terminal but lacks fundamentals.
The skill creates a local mission.md, a learning record, a reference cheat sheet, and an HTML lesson.
It begins with Git because version control, debugging, testing, and shipping workflow are the highest-leverage gaps.

8:30 Why stateful skills and HTML lessons beat terminal-only learning

Matt Pocock distinguishes stateless skills from stateful skills that remember a user's mission and prior learning.
Teach stores local state so it can adapt follow-up lessons and track progress over time.
Lessons are rendered as HTML for richer study than the terminal, making exercises and explanations easier to absorb.

12:00 Opinionated on models: Claude Code, Opus 4.8, and waiting a month

Matt Pocock says he mostly uses Claude Code with Opus 4.8 at medium effort for planning and implementation.
He avoids immediately chasing every new model release and prefers waiting about a month to see what holds up.
His point is that token cost, latency, and availability matter as much as benchmark gains.

15:00 What makes a good skill: procedures vs abilities

Matt Pocock separates skills into procedures the user runs and abilities the model invokes automatically.
His "grill me" skill is a procedural tool that turns the model into an adversarial interviewer before implementation.
He prefers short, controllable skills like producing a PRD and breaking it into issues before coding begins.

18:00 Knowledge, skills, and wisdom in the AI era

Matt Pocock says reusable AI leverage comes from bundling knowledge and skills into procedural chunks.
He defines wisdom as knowing when to apply the skill in the real world, which usually requires lived context.
The best engineers and teams turn repeated workflows into shared procedures that raise the floor for everyone.

25:00 AFK engineering with Sand Castle and GitHub Actions

Matt Pocock uses Claude Code inside Sand Castle, a sandboxing tool for running agents safely.
Sand Castle can use Docker, Podman, or Vercel sandboxes to isolate agents and parallelize work.
He also wires agents into GitHub Actions for PR review, type checking, and automated branch checks.

35:00 Harness over hype: codebase design, loops, and review checkpoints

Matt Pocock argues the model is only one part of the system; the harness and codebase are equally important.
He thinks better architecture can let a cheaper model do the same work with fewer tokens and less thrashing.
On loops, he prefers task queues and AFK agents with human-in-the-loop checkpoints over endless autonomous prompting.

46:00 Product thinking, AX, and practical next steps

Matt Pocock says building a business still starts with talking to customers and solving real problems.
He introduces AX, or agent experience, as the agent-side equivalent of developer experience.
His actionable advice: delete excess skills/plugins/MCP servers, observe the bare agent, then add back only procedural skills and push implementation into AFK agents.

Summary, takeaways, and chapters were generated by AI from the video's transcript and may contain errors. The video belongs to its creator, David Ondrej.