The Five-Step AI Coding Method: Mastering Agents Like an Engineer

A Course on AI Coding Fundamentals

While most AI coding tutorials are still teaching you how to write cleverer prompts or wrestle with the quirks of a specific tool, Matt Pocock's AI Coding Crash Course takes a fundamentally different path: returning to the core principles of software engineering.

Matt Pocock is a well-known instructor in the TypeScript community. His Skills repository had just crossed 200,000 stars at the time of recording, placing it among the top 20 most popular repositories in GitHub history, with over 13 million downloads. The "Skills" mentioned here are a standardized configuration mechanism in the AI coding agent ecosystem, typically existing as Markdown or YAML files in project repositories (under directories like .cursor/rules, .claude/commands, etc.). These files provide agents with project-level instructions, coding standards, workflows, and constraints. The core value of Skills lies in being "portable wisdom" — unlike proprietary configurations of specific IDE plugins or tools, Skills files are essentially plain-text engineering knowledge that can migrate between different agents and development environments. Matt's TotalTypeScript/skills repository went viral precisely because it provides a community-validated, directly reusable set of TypeScript best practice rules that enable agents to automatically follow these conventions when generating code. The numbers behind this send a clear signal — what developers truly need isn't another flashy collection of tricks, but a methodology that can reliably deliver code in real-world work.

He spent approximately two years exploring AI coding, and the core insight he distilled is remarkably simple: The key to improving code delivery quality isn't waiting for models to become more powerful — it's making the developer themselves more capable.

The Five-Step AI Coding Delivery System: An Engineering Method That Runs Through Everything

At the heart of this course is a five-step delivery system. Matt emphasizes that no matter how many other approaches he's tried since, these five steps have never changed — they are essential for delivering excellent work.

The Five Unchanging Steps

1. Interrogation: Before taking action, thoroughly clarify requirements and boundaries through deep questioning, rather than rushing the agent to start writing code.
2. Create a Spec: Crystallize the understanding gained from interrogation into a clear specification document that serves as an anchor for subsequent work.
3. Create Tickets for the Spec: Break the spec down into individually executable tickets, making massive tasks manageable.
4. Implementation: Actually have the agent write code, executing each ticket.
5. Review: Rigorously review the output to ensure quality meets standards.

This workflow essentially reintroduces best practices from the mature software engineering lifecycle into AI-assisted development. In traditional software engineering, the flow of requirements analysis → system design → coding → testing → delivery has long been industry consensus, and agile development further condenses it into the iterative cycle of user stories → sprint planning → development → review. However, the emergence of AI coding tools has created an illusion for many developers: since the model can "automatically write code," the upfront requirements analysis and design can be skipped. This approach might occasionally succeed with small scripts or one-off tasks, but in real projects it almost inevitably leads to rework. Matt's five-step method is essentially saying: AI changed "who writes the code," but it hasn't changed the fundamental law that "good software requires clear requirements and thoughtful design."

Matt points out that the reason many people get poor results with AI coding is precisely because they skip the preliminary interrogation and spec phases, letting the agent "guess its way through" under vague requirements.

Context Management: The Overlooked Core Competency in AI Coding

One particularly noteworthy section of the course is the in-depth discussion of context management. This is also the most easily underestimated capability in current AI coding practice.

Attention Declines as Context Grows Longer

Matt explicitly identifies a technical reality: as context windows grow longer, the model's attention actually decreases. The context window here refers to the maximum text length that a large language model can process simultaneously during a single inference, typically measured in tokens. Early GPT-3.5 had a context window of only 4K tokens, while current mainstream models have expanded to 128K or even 200K tokens. However, a 2023 research paper Lost in the Middle published by Stanford University and other institutions revealed a key finding: when context grows longer, the model's ability to retrieve and utilize information located in the middle positions decreases significantly, displaying a clear U-shaped attention curve — the model pays the most attention to information at the beginning and end, while tending to "forget" the middle portion. This means longer context windows don't equal better comprehension; they may actually cause output quality to decline as information density gets diluted.

In other words, dumping all information into the context at once won't produce better results — it may actually dilute the model's focus on critical information.

Based on this understanding, the course teaches you to make decisions among three operations:

• When to compact: Streamline context while preserving key information. Specifically, compacting means creating summary-style condensations of existing conversation history — for example, compressing a debugging process spanning thousands of tokens into a concise summary like "Fixed Y issue in X component using Z approach," dramatically reducing context usage without losing key semantics.
• When to clear: Decisively discard completed content that's no longer relevant. Clearing is more aggressive and is appropriate when the current task is completely finished and historical context has no reference value for the new task — at that point, retaining old information only adds noise and interferes with the model's understanding of the new task.
• When to hand off: Transfer tasks between different sessions or agents. Handoff is the most refined operation, involving the transfer of structured task state between different sessions or different agents — for example, after one agent completes a database schema design, it passes the design document and constraints to another agent responsible for API implementation.

The flexible application of these three strategies is essentially managing the model's "cognitive bandwidth." Complementing this is how to break down massive work into granularities that agents can truly handle. This echoes the "Create Tickets" step in the five-step method — good task decomposition is itself a context management strategy.

A Teaching Philosophy Not Tied to Any Specific Tool

Facing the common question "Which agent should I use?", Matt's answer is quite enlightening: Use any agent that can run in the terminal and use skills.

This covers virtually all current mainstream options — Claude Code, Codex, OpenCode, GitHub Copilot, and Gemini's related tools all qualify. He personally uses Claude Code daily, while the agent demonstrated in the course is Codex (one of the most popular coding agents at the time of recording). Claude Code is Anthropic's command-line AI coding tool that runs directly in the terminal, capable of reading and modifying the local file system, executing shell commands, and interacting with Git — essentially an agent with full development environment awareness. By comparison, OpenAI's Codex CLI adopts a similar terminal-native design philosophy, emphasizing autonomous coding task completion in a local sandbox environment. Both differ from embedded IDE plugins (like GitHub Copilot's early autocomplete mode) and represent the evolution of AI coding tools from "assisted completion" toward "autonomous execution." The common characteristic of these terminal-native agents is support for agentic mode — they can not only generate code snippets but also autonomously plan file modifications, run tests, fix errors, and form a complete coding loop.

Why "Transferable" Skills Are Emphasized

The course deliberately avoids diving deep into the quirks of any specific agent, instead teaching fundamentals. The reason: all content is delivered through skills, which means the skills you learn can be taken with you and used with any agent.

This design dramatically reduces the depreciation risk of learning. In the rapidly iterating AI field, skills bound to a single tool quickly become obsolete, while underlying engineering methodologies retain lasting value.

Hands-On Practice: The Cadence Project

This isn't a purely theoretical course. The entire learning process revolves around a practice project called Cadence — a TypeScript and Node application with fairly mature functionality where users can purchase courses, study courses, and complete quizzes.

Students work alongside their agents to deliver features on this real project, walking through the complete software development lifecycle that Matt has practiced for the past decade and that has been validated to work excellently with agents. This "learn by doing" approach ensures the methodology doesn't remain on paper. Choosing a mature project with substantial existing code rather than starting from an empty repository is also a deliberate design decision — in real-world work, the vast majority of scenarios developers face involve iterating on existing codebases rather than building from scratch. Guiding agents to correctly understand project structure, follow existing conventions, and avoid introducing breaking changes within complex existing codebases — that's where the real difficulty of AI coding lies.

Extremely Low Barrier to Entry, High Returns

The prerequisites for this course are surprisingly simple — just two:

• Can you read code? — You don't necessarily need to write code, but you should have a general sense of what code looks like, be able to navigate a codebase, and understand what's happening.
• Can you use a terminal? — You can open a terminal, use basic commands like CD and LS, and roughly understand what's happening inside.

You might not have noticed, but Matt also specifically arranged a Claude Code introductory session for students with zero AI coding experience, bringing them up to a level sufficient to follow the course. But once the core sections begin, the course essentially stops talking about specific tools and focuses entirely on fundamentals that are universal across any framework and any agent.

Core Value: Upgrading Yourself

In Matt's own words, this methodology is "very light on context burden, only requiring a tiny bit of understanding from you." Its goal isn't to train developers into skilled operators of a particular tool, but to equip you with the foundational ability to master any agent, enabling you to deliver massive amounts of work at extremely high quality.

At a time when everyone is chasing more powerful models, this course offers a sobering perspective: The ceiling of AI coding often isn't the model — it's the person using it. This aligns with a classic observation in software engineering — Fred Brooks' "No Silver Bullet" thesis from The Mythical Man-Month states that the essential difficulty in software development lies in the complexity of conceptual structures, not the mechanical labor of coding itself. AI tools have largely eliminated the latter, but the former — understanding requirements, designing architecture, managing complexity — remains firmly in the hands of human developers. Matt's course is essentially teaching you how to become a better "conceptual architect" in the AI era.

Key Takeaways