Rejecting Vibe Coding: Matt Pocock's Engineering-Driven Approach to AI Programming

When everyone is hyping "Vibe Coding" — letting AI generate code on a whim based on gut feelings — a former Vercel engineer and one of the most influential educators in the TypeScript community, Matt Pocock, has used a GitHub repository with over 80,000+ Stars to show us: In the AI era, software engineering fundamentals are not only still relevant — they're more important than ever.

"Vibe Coding" was coined by AI pioneer Andrej Karpathy in early 2025, referring to developers relying entirely on intuition and natural language descriptions to have AI auto-generate code, sometimes without even reading the output. While this approach has shown remarkable efficiency in rapid prototyping, it has sparked fierce debate in the software engineering world: when developers abandon understanding and control over code, where does software quality, security, and maintainability go?

The Three Fatal Pain Points of AI Programming

If you're using Claude Code, Cursor, or other AI programming tools, you've likely encountered these three problems:

First, requirement alignment failure. You think the AI understood you, but what it produces is completely off-target. You say "build a login page," and it immediately starts writing HTML and CSS without considering key scenarios like password recovery, third-party login, or error messages.

Second, AI's verbose filler. When AI is dropped into a new project, it doesn't understand the team's terminology or business context. It can only guess and fill in with generic vocabulary, generating code with chaotic naming and inconsistent style.

Third, accelerated architectural decay. This is the most deadly — AI writes code too fast, so fast that we don't have time to think about architectural design. In traditional development, human coding speed itself serves as a natural "speed bump" — developers unconsciously think about design issues while typing. But AI can generate hundreds of lines per second, completely bypassing this thinking phase. Originally clean code structures rapidly deteriorate into unrecognizable messes under AI's high-speed output. This phenomenon is known in software engineering as "software rot" or "technical debt accumulation" — borrowing from the second law of thermodynamics, a codebase's disorder (entropy) always tends to increase, and AI's involvement dramatically accelerates this process.

Faced with these problems, is AI programming really just a beautiful bubble?

Who Is Matt Pocock? From Vocal Coach to TypeScript Master

To understand the essence of this methodology, we need to know its author. Matt Pocock is the creator of Total TypeScript courses and one of the most influential educators in the TypeScript community. He previously served as a Developer Advocate at Vercel and worked at Stately (the company behind XState), where he was a core contributor to XState.

Vercel is the company behind the Next.js framework and one of the most influential companies in the modern frontend development ecosystem. TypeScript, as a superset of JavaScript, greatly improves code maintainability and developer experience for large projects through its static type system. XState is a JavaScript/TypeScript state management library based on finite state machines and statechart theory, bringing formal methods from computer science into frontend development and helping developers manage complex application state in a mathematically rigorous way. Matt's deep involvement in both ecosystems gives him a profound understanding of engineering practices.

But what's most surprising is that before becoming a top engineer, he was a vocal coach. This cross-disciplinary background gave him an extremely sharp intuition for communication and expression — precisely the key capability for solving "human-machine collaboration" problems.

Recently, Matt organized and open-sourced a set of AI Agent skills he uses daily. This repository named Skills has the subtitle "Skills for Real Engineers" — emphasizing genuine engineering practice rather than casual Vibe Coding. In the Readme, he bluntly criticizes tools like GSD, BMAD, and SpecKit that attempt to take over the entire development workflow, arguing they strip developers of control and make debugging extremely difficult.

Core Skills Breakdown: Harnessing AI with Engineering Thinking

GrillMe: Making AI "Grill" You Instead

Matt believes the most common failure mode in software development is alignment failure — you think the AI understood, but it actually didn't. For this, he designed the "GrillMe" skill.

Once this skill is activated, the AI is no longer a compliant assistant that just says "Sure, I'll write the code right away." Instead, it transforms into a tough interviewer. It continuously asks you pointed questions, forcing you to crystallize vague ideas until every branch of the decision tree is thoroughly clarified.

For example, if you ask AI to write a login page, it won't start immediately. Instead, it'll ask: What happens when users forget their password? Do you need third-party login support? How should login failure error messages be designed? This reverse interrogation mechanism dramatically reduces requirement misunderstandings. Matt calls GrillMe his most popular skill because it forces developers to think deeply before writing the first line of code.

GrillWithDocs: Eliminating Filler with Domain Language

When AI lacks project context, it can only guess with generic vocabulary — what Domain-Driven Design (DDD) calls "lacking a ubiquitous language." Domain-Driven Design is a software design methodology proposed by Eric Evans in 2003, with the core idea of keeping software structure and language highly aligned with the business domain. "Ubiquitous Language" is the most fundamental and important concept in DDD — it requires development teams, product managers, and business experts to use the same set of terms to describe the system, terms that appear both in daily communication and directly in code's class names, method names, and variable names. When AI lacks this ubiquitous language, the code it generates is filled with self-invented naming that conflicts with team conventions, causing codebase readability and consistency to plummet.

Matt's solution is the GrillWithDocs skill: while grilling you, the AI simultaneously checks the project's existing domain language and Context.md files.

When you use vague or conflicting terminology, it immediately asks for clarification and deposits confirmed terms and key decisions into Context.md or ADRs (Architecture Decision Records). Architecture Decision Records are a lightweight documentation practice proposed by Michael Nygard in 2011, where each ADR records an important architectural decision including context, alternatives considered, final choice, and rationale. ADRs provide decision traceability for teams — new members can quickly understand "why the system is designed this way," not just "what the system looks like." In AI collaboration scenarios, ADR value is further amplified: AI can read ADRs to understand project technical constraints and design philosophy, generating code that better fits the project's overall architecture.

GrillWithDocs isn't simply auto-extracting keywords — it transforms requirement discussions into reusable project context.

For example: if your team calls "users" "clients" and "orders" "transactions," the AI will automatically use these terms after reading Context.md, rather than inventing its own vocabulary. This not only improves communication efficiency but also makes generated code more aligned with team standards, and can even save significant inference tokens.

TDD Skill: Combating Architectural Decay with Test-Driven Development

AI writes code too fast, so fast that architecture can't keep up — this is the most deadly problem. Matt's counterstrategy is integrating classic Test-Driven Development (TDD) into AI workflows.

Test-Driven Development was systematized by Kent Beck in 2003, with a strict three-step cycle at its core. His designed TDD skill guides AI to follow the "Red-Green-Refactor" cycle: rather than writing all tests first and then implementing all code, it progresses one behavior, one test at a time in vertical slices. Vertical Slice is an incremental development strategy where each iteration implements one complete functional slice — from UI to database — rather than completing all interfaces before all backend logic.

AI first writes a failing test (Red), then implements functionality to make it pass (Green), then refactors to optimize the code, and repeats. The elegance of this cycle is that it places "specification" and "verification" before "implementation," ensuring every line of code has a clear reason to exist. Combined with vertical slices, this effectively prevents AI from generating large amounts of unverified code at once, ensuring code quality while making AI output more controllable.

Architecture Review: Regular Health Checks for Your Codebase

Even more brilliant is the "Improve Code-Based Architecture" skill. Matt recommends developers run this skill periodically, letting AI examine the codebase from a global perspective. It reviews module design, identifies areas with complex interfaces that are hard to test and prone to bugs, and suggests improvement directions. This is like giving your codebase regular deep health checkups and therapy — proactively combating the inevitable entropy increase in software systems, intervening before technical debt accumulates to an unmanageable level.

Other Practical Tools

Beyond the core skills, Matt also provides a series of practical tools:

• Diagnose skill: Provides a structured diagnostic loop — reproduce the bug, minimize it, hypothesize, verify, fix, regression test. The core isn't guessing answers directly, but establishing repeatable feedback loops first. This methodology stems from the hypothesis-verification paradigm of the scientific method, avoiding AI's common "blind-guess fixing" — modifying code without understanding root causes, often introducing more problems.
• To PRD skill: Organizes the current conversation and codebase understanding into a Product Requirements Document (PRD) and publishes it to GitHub Issues, Linear, or local files. A PRD is a core document in product development that defines what problem the product solves, target users, features, and success metrics. Linear is a project management tool that has rapidly gained popularity among development teams in recent years, known for its extreme speed and clean design, and is seen as a modern alternative to Jira. Publishing AI-generated PRDs directly to these platforms creates a seamless bridge from requirement discussions to task tracking.

Core Insight: Bad Code Costs More in the AI Era

At this point you might think: aren't these all traditional software engineering methods? Test-Driven Development, Domain-Driven Design, architectural refactoring — are these classic concepts still useful in the AI era?

This is exactly the biggest cognitive reversal Matt Pocock brings us.

Many people think that with AI, you don't need to understand architecture, don't need to write tests, or even don't need to understand programming. But the reality is exactly the opposite: AI is an extremely powerful executor, but it lacks the ability to maintain global control over complex systems. If you don't understand software engineering, AI will only help you produce garbage code at ten times the speed.

In the past, writing bad code might take days; now AI can generate hundreds or thousands of lines of bad code in seconds. Without control, this bad code will quickly drag the entire project down. This aligns with the observation Fred Brooks made in his classic work The Mythical Man-Month — the core difficulty of software engineering isn't coding itself, but conceptual integrity and system design. AI solves the coding efficiency problem, but the challenge of conceptual integrity hasn't disappeared — it's become even more acute due to increased generation speed.

The core thesis behind this methodology is: In the AI era, the cost of bad code is higher, therefore mastering solid software engineering fundamentals isn't obsolete — it has become a developer's most essential competitive advantage.

The Right Paradigm for Human-AI Collaboration

Matt Pocock's Skills repository appears on the surface to be an AI toolkit, but at its core it's a software engineering methodology for the AI era. It tells us:

• Don't try to let AI take over the entire development workflow — instead, embed AI into mature engineering practices
• Use GrillMe to strengthen requirements analysis, use Context.md to solidify domain knowledge
• Use TDD to ensure code quality, use architecture reviews to combat system entropy

The smartest approach to AI programming is actually constraining AI's degrees of freedom — through process standardization, normalization, and verifiability, making AI a truly productive tool. This aligns with the core idea of Cybernetics: any efficient system needs feedback loops and constraint mechanisms. Completely unconstrained freedom doesn't produce optimal output — instead, it leads to system chaos.

Humans are responsible for defining problems, designing architecture, and setting standards; AI is responsible for writing code, generating tests, and executing refactoring. This is the working model that a true AI engineer should adopt.

The top engineers of the future will be those who understand both underlying technology and how to achieve efficient human-AI collaboration. They won't be coders replaced by AI, but architects commanding AI armies — knowing when to let AI run free and when to apply strict constraints.

In the AI era, software engineering fundamentals haven't lost their relevance — they've become your most essential moat. Reject thoughtless code generation and harness AI with engineering thinking — that's the right approach to AI programming.