Don’t Let Heavy Process Frameworks Steal Your Control — This Is the Skill Set Real Engineers Should Use

When you write code with AI, have you ever encountered this:

You chatted with AI about requirements for a long time, but the code it generated was completely different from what you had in mind.

After a few revisions, your codebase is full of duplicate classes and methods.

The architecture you painstakingly built turned into a mess before long.

There’s a GitHub repo with 82.9k stars dedicated to solving these exact problems.

Matt Pocock and His Skill Set

GitHub repo: https://github.com/mattpocock/skills

The author is Matt Pocock, former Vercel Developer Advocate, author of Total TypeScript, and now building the AI Hero platform.

He essentially “distilled” decades of software engineering wisdom from his own experience and open-sourced his practical workflow for using Claude Code on a daily basis.

The repo name is straightforward: Skills for Real Engineers.

This skill set has three core design philosophies:

Small — Single-file, readable. Each skill is small enough to understand in minutes.

Composable — Freely combinable. Use them individually or chain them together.

Hackable — Modifiable. Don’t like a step? Change it to your own.

Why not use tools like GSD, BMAD, or Spec-Kit? Matt says:

“These tools try to help you by taking over the entire flow. But in doing so, they take away your control, and bugs in the process become very hard to fix.”

I’ve used similar tools before, and I know exactly what he means.

For example, GSD’s workflow — brainstorming, generating plans, executing plans, testing — looks impressive with each step chained together. But if any step goes wrong, making changes is extremely painful. The flow is too heavy to modify.

Matt’s approach: use small, composable skills instead of one big process framework.

The Four Problems to Solve

Matt’s skill set targets four core problems in AI programming:

1. Misalignment

Misunderstanding between the developer and the agent. You think it understands, but it’s actually off. The final generated code is completely different from what you had in mind.

2. Ubiquitous Language (Lack of Shared Language)

Is the “user” you refer to the same thing as the User in the code? Is the “order” you talk about the same concept as the Order in the database? Without unified terminology, the AI will guess, and if it guesses wrong, you’ll have to redo.

3. Feedback Loops (Missing Feedback)

When the AI spits out hundreds of lines of code at once, how do you verify? Do you know which line has a problem? Without fast feedback, errors pile up.

4. Software Entropy (Accelerated Entropy)

The codebase turns into a mess much faster than before. AI has no global view; it just does its best based on the current context. If you don’t control it, code quality will degrade rapidly.

What Are the Core Skills?

Matt categorizes skills into three types: Engineering, Productivity, and Miscellaneous.

1. Engineering Skills:

grill-with-docs — Most used in programming scenarios.

It keeps asking questions until you have none left. But it makes a key change: it generates a context.md document, called a “shared glossary.”

As you communicate requirements with the AI, terms from the conversation are recorded for later use in programming.

This document is your Ubiquitous Language.

The purpose of terms is to use short words to represent complex concepts. In a business domain, a few words can encapsulate a complete domain.

Besides context.md, it also generates Architecture Decision Records (ADR) as context for subsequent flows.

This directly solves the Misalignment problem.

tdd — Test-driven development.

The flow is: plan, write tests, tests fail, minimal code to pass.

In AI coding, the core role of TDD is to control the granularity of each step. It forces you to break work into small, verifiable pieces.

This directly solves the Feedback Loops problem.

diagnose — Bug diagnosis.

Uses six stages, a complete debug methodology.

improve-codebase-architecture — Architecture improvement.

It searches your entire codebase and checks it against good architecture and interface design principles (like Deep Modules: feature-rich but simple interface).

It finds optimization points, asks if you want to proceed, and then gives improvement suggestions.

This directly solves the Software Entropy problem.

After using AI to code for a while or finishing a module, run this skill to let it find optimization opportunities.

to-prd and to-issues — Tightly integrated with GitHub.

to-prd summarizes your conversation history and generates a PRD document.

to-issues converts the PRD into issues and labels them (bug or feature).

Then you go back to the project codebase to modify, iterate, and update these issues.

This is a small workflow based on GitHub issues.

2. Productivity Skills:

grill-me — Non-programming grill mode.

caveman — Have the AI explain complex concepts in the simplest way.

handoff — Generate context documents when handing off work.

write-a-skill — Helps you write new skills.

How to Install

Two ways:

Method 1: Install via Claude Code (Recommended)

bash

Enter in Claude Code

/install mattpocock/skills

Method 2: Manual Install

bash

Clone the repo into the .claude directory

cd ~/.claude git clone https://github.com/mattpocock/skills.git

After installation, run initialization:

bash

Run in the project root

/setup

It will:

• Scan your project to check if it’s already configured
• Modify your CLAUDE.md file to add global context
• Create context.md (glossary)
• Create the docs/adr/ directory (architecture decision records)
• Ask you to choose an issue tracker (GitHub recommended)
• Ask you to choose a domain documentation mode (root directory for single project, subdirectories for multi-project)

After initialization, you’ll see these files:

your-project/ ├── CLAUDE.md # Updated ├── context.md # New ├── docs/ │ ├── adr/ # New │ ├── agents.md # New │ └── issues.md # New

Recommended Usage Order

Matt’s recommended complete workflow:

Step 1: Align Requirements (grill-with-docs)

When you have new requirements, start with grill-with-docs for brainstorming.

bash /grill-with-docs

It will ask you 15–20 questions until you have none left.

Afterward, it generates context.md (glossary) and ADR (architecture decisions).

Step 2: Generate PRD (to-prd)

After alignment, generate a PRD document.

bash /to-prd

It summarizes your conversation history and produces a structured PRD, published to GitHub.

The PRD includes:

• User stories
• Module breakdown
• Test plan
• Out-of-scope items

Step 3: Break Down into Tasks (to-issues)

Split the PRD into executable small tasks.

bash /to-issues

It breaks the large PRD into 3–5 small tasks, each becoming a GitHub issue.

Then each issue gets labeled:

• bug — fix a problem
• feature — new feature
• ready-for-agent — can be handed to AI

Step 4: Implement Features (tdd)

Pick an issue and implement it with TDD.

bash /tdd #123

It will:

• Pull the issue description
• Plan the implementation approach
• Write tests (that fail first)
• Write minimal code to pass the tests
• Refactor and optimize

Step 5: Diagnose Bugs (diagnose)

When you encounter a bug, use diagnose.

bash /diagnose

It systematically finds the problem in six stages:

• Reproduce the issue
• Collect information
• Form hypotheses
• Verify hypotheses
• Identify root cause
• Fix and verify

Step 6: Architecture Optimization (improve-codebase-architecture)

Run architecture optimization every few days or after finishing a module.

bash /improve-codebase-architecture

It will:

• Scan the entire codebase
• Give 3–5 optimization directions
• Let you set priorities
• Provide specific solutions for your chosen direction

Real-World Use Case

I used grill-with-docs to test a requirement: add a top-up feature where points are awarded after top-up.

It asked 20 questions:

• What is the top-up amount range?
• Which payment methods are supported?
• What is the point-to-money ratio?
• How do you handle failed top-ups?
• How are points deducted during refunds?
• What should the page layout look like?
• Do you need to send notifications?

Afterward, it generated context.md:

markdown## Glossary

Points Virtual currency on the platform that users can use to exchange for goods or services.

Top-up (Recharge) The process by which users pay real currency to obtain points.

Key Rules

1. Top-up range: 10–10000 CNY
2. Point ratio: 1 CNY = 10 points
3. Bonus rule: top-ups ≥ 100 CNY get an extra 10%
4. Refund rule: deduct used points on refund; remaining points are returned proportionally.

Then I used to-prd to generate the PRD, and to-issues to split into 4 tasks:

• Top-up page UI
• Payment API integration
• Points calculation logic
• Refund handling logic

Each task was labeled ready-for-agent, ready for the AI.

When implementing the first task with tdd, it first wrote tests, then code, ensuring quality.

After completion, I ran improve-codebase-architecture, which found two optimization points:

• The payment interface could be abstracted into a unified PaymentGateway
• The points calculation logic could be extracted into a standalone PointsCalculator

After following its suggestions, the code’s maintainability improved noticeably.

It’s More Than Just Writing Code

Matt Pocock’s skill set boils down to one word: control.

You aren’t being pushed around by a tool — you decide when to use which skill. Each skill is small, usable alone or in combination. When something goes wrong, you know exactly which step is broken and can fix it quickly.

AI makes writing code faster, but code has never gotten cheaper.

Code rots, accumulates technical debt, and needs maintenance. AI just helps you produce code faster, but it won’t think about how to organize the code for you.

This skill set teaches you not just how to write code with AI, but how to maintain control over your work in the age of AI. Writing articles, designing, analyzing — any work that requires AI collaboration — you still need to think clearly first, build consensus, control the pace, and optimize regularly.

Give it a try. You’ll find that not only does the rhythm of coding change.

About me: Gyro, an engineering mind grown from gaming. Sharing AI tool practices, systems thinking, and cognitive upgrades.

👉 Follow my X account @gyro