Software fundamentals are more important than ever: Matt Pocock’s Claude Code skill set

A person who is overwhelmed by the specs-to-code wave but still calm

2026 is the highlight year of the "specs-to-code" narrative of AI programming - write the specification, run the compiler, do not read the code, then write the specification, and then run the compiler. The slogan that has emerged in the community is "code is cheap" (code is cheap), which means: Anyway, AI can generate another 10,000 lines per second, why should you care about it.

Matt Pocock is one of the few people to publicly speak out against this. He does not deny that AI coding is very powerful, but he actually tested specs-to-code in his class "Claude Code for Real Engineers", and the conclusion is very heart-wrenching: Every time I run it, the code gets worse and worse. This is exactly the "software entropy" that has been talked about in Pragmatic Programmer - software entropy increase.

So he did two things:

1. Package this observation into an 18-minute talk: Software Fundamentals Matter More Than Ever.
2. Package the corresponding antidote into a GitHub repository: mattpocock/skills - "Skills for Real Engineers. Straight from my .claude directory."

The warehouse was launched on February 3, 2026, and within 4 months it reached 61.1k stars and 5.3k forks. It was one of the fastest growing AI programming warehouses during the same period.

Who is Matt Pocock?

If you have written TypeScript, you have probably come across it. He is one of the most prolific TypeScript educators in the Chinese and English circles in recent years:

• Founder of TotalTypeScript.com, a series of paid courses that are very popular in the English circle
• aihero.dev Newsletter 60,000+ subscriptions, topic changed from TS to AI Coding
• There are a lot of short video tutorials on Twitter @mattpocockuk and YouTube @mattpocockuk
• Not an OpenAI/Anthropic person, purely an independent developer + educator background

His personality is very clear: AI Coding from the perspective of a senior engineer. We don’t shout “AGI is coming”, nor do we shout “Programmers are going to lose their jobs”. What he shouted was, "The tricks of the older generation of software engineers are still very useful, they just need to be translated into a form that LLM can execute."

Core argument: Code is not cheap

There is only one argument in the entire speech, and each skill is a footnote to it:

If your code base structure is bad, AI will only write bad code in a bad code base. So a good code base is more important than ever, and basic software skills are more important than ever.

Matt used a military analogy to explain the roles of humans and AI very straightforwardly:

What does the strategic layer do? Design concepts, unified language, module boundaries - these three things are "defining problems" rather than "writing code", and they happen to be what LLM is least good at doing for you.

Five Failure Patterns → Five Old Books → Five Skills

Matt compressed the entire methodology into a mapping table in his speech. Every time you encounter a failure mode, he will point you back to the classic theory that was solved 20 years ago, and then give you a Skill file in Markdown format:

Item 5 There is no separate skill in the repo (there used to be design-an-interface but it is deprecated), its spirit has been absorbed into /to-prd and /improve-codebase-architecture - both of which force you to think about module interfaces before writing code.

5 Skills that you really use every day

The speech was a philosophical skeleton. Matt later posted an article "5 Agent Skills I Use Every Day" on aihero.dev to translate the skeleton into daily workflow. These 5 are the objects that will be dismantled one by one in the future of this series:

/grill-me                       ← 先和 AI 谈清楚要做什么
        ↓
/to-prd                         ← 把对话凝固成 PRD
        ↓
/to-issues                      ← 把 PRD 切成可独立领取的 vertical slice
        ↓
/tdd                            ← 每个 slice 用红绿重构跑通
        ↓
/improve-codebase-architecture  ← 周期性检查，把 shallow 模块改成 deep

These 5 skills are strung together to form Matt’s complete research and development process. The failure modes corresponding to each step are shown in the table in the previous section.

Detailed dismantling of each article (subsequent pages in this series):

• Grill Me: Let AI torture you about your needs
• Grill With Docs: Maintaining project language and ADR
• to-PRD + to-Issues: from conversation to executable ticket
• TDD: Force AI to take small steps with red-green reconstruction
• Improve Codebase Architecture: Restructure shallow into deep modules

How to install

The warehouse README gives a one-line command to install:

npx skills@latest add mattpocock/skills

This command will:

1. Let you check which skills you want to install
2. Allows you to select which agents to install (Claude Code, Codex, Cursor, etc. are all supported)
3. Put the corresponding SKILL.md file into .claude/skills/ (or the directory corresponding to the agent)

It is strongly recommended to check /setup-matt-pocock-skills at the same time - this is a one-time configuration skill that will ask you three questions:

• What is Issue tracker used for? (GitHub / GitLab / local markdown / other)
• What word is used for Triage label? (needs-triage or other)
• Where to put Domain doc? (CONTEXT.md/ADR path)

Run /setup-matt-pocock-skills once and it will write to AGENTS.md or CLAUDE.md in the root directory of your project. After that, all engineering skills (to-prd, to-issues, triage, tdd, etc.) will automatically read this configuration. This step is omitted, and every subsequent skill will ask you the same question again and again.

If you just want to try /grill-me (the most lightweight, pure productivity class), you can skip setup as it does not rely on the issue tracker.

The difference between this set of skills and BMAD / Spec-Kit / GSD

If you are already using spec-driven frameworks such as BMAD, Spec-Kit, and GSD, you may ask: "Why do you still need Matt's set?"

Matt writes very directly in the README:

Core Differences:

• BMAD/Spec-Kit/GSD is a framework that specifies a complete pipeline from spec to code. You have to follow its process.
• Matt This set is component. Each skill has a markdown file, ranging from a few lines to dozens of lines. You can disassemble and modify it at any time.

Example: The actual full text of grill-me is only this short——

Interview me relentlessly about every aspect of this plan until we reach
a shared understanding. Walk down each branch of the design tree,
resolving dependencies between decisions one-by-one. For each question,
provide your recommended answer.

Ask the questions one at a time.

If a question can be answered by exploring the codebase, explore the
codebase instead.

The entire skill is 7 lines. But it’s those seven lines that make Claude ask you 20, 50, or even 100 questions before making a decision. This design philosophy of using very little text to leverage big behavioral changes is the fundamental reason for the popularity of this set of skills.

How to read this series

If you haven’t come across Matt’s set before, it is recommended to read it in the order in meta.json:

1. Overview (the article you are currently on) - Get the full picture
2. Grill Me - Install one individually and try it first, the threshold is the lowest
3. Grill With Docs - an advanced version of grill-me, starting to introduce CONTEXT.md
4. to-PRD + to-Issues - Turn the conversation into an executable ticket
5. TDD - Matt himself said "the most stable method I have ever used to improve the quality of agent output"
6. Improve Codebase Architecture - Periodic maintenance to make AI available for the long term

If you are already using Claude Code to write real projects, jump directly to /grill-me + /tdd. These two articles are the most intuitive.

If you are teaching or writing, just reading /grill-me is enough - it is a general "design conversation" tool, not limited to code.

My usage suggestions

After I installed this set of skills myself, the biggest physical changes were:

First: Stop rushing to start writing code. In the past, when AI received "Add me a login", it would start laying out 500 lines. Now /grill-me will ask you 20 questions first - "Do you want to remember the device?" "How long does it take for the session to expire?" "How many times have you failed to lock your account?" Let it be written after 30 minutes. What you will save is the subsequent two hours of rework.

Second: CLAUDE.md is no longer bloated. In the past, there were a lot of prohibitions written in CLAUDE.md such as "Please understand the requirements before writing code" and "Don't be overly abstract", but Claude still committed it. After switching to Matt's set, CLAUDE.md only puts domain knowledge (design system, component specifications, deployment), and general methodologies are handed over to skills. The responsibilities of both parties are clear.

Third: Deep module thinking is more valuable than the skill itself. Even if you don't install /improve-codebase-architecture, just reading the "deletion test" in its SKILL.md (if the complexity disappears after deleting this module, it means it is pass-through) will already make you take a second look during PR review.

Note the cost:

• After installing 5 skills, the AI will ask more questions. People who are used to "generating 500 lines in one sentence" will find it annoying
• After /tdd is strictly implemented, simple scripts will also be required to write tests first, which is not friendly to exploratory code - you can tell it "skip TDD this time"
• /grill-with-docs will take the initiative to modify your CONTEXT.md. It is best to dry-run it before running it for the first time.

Reference resources

5 books cited in the speech (in order of appearance):

• A Philosophy of Software Design — John Ousterhout (complexity definition, deep modules)
• The Pragmatic Programmer — David Thomas & Andrew Hunt（software entropy、outrunning headlights）
• The Design of Design — Frederick P. Brooks（design concept、design tree）
• Domain-Driven Design — Eric Evans（ubiquitous language）
• Test-Driven Development — Kent Beck（invest in design every day）

Each one is over 20 years old. Matt repeated a sentence many times in his speech: "Go on Amazon, get it." - this sentence itself is the Easter egg of this speech.