mattpocock/skills: Engineering Skill Packs for Your AI Coding Assistants

The "Cowboy Coding" Problem with AI

As AI coding tools become ubiquitous, more and more developers rely on Cursor, Claude Code, Codex, and similar tools to generate code. But a widespread pain point has emerged: the code AI produces is often "cowboy code" — no requirements analysis, no test coverage, no code review. It might run, but it's riddled with hidden issues.

The root cause lies in how large language models work. They're fundamentally "predicting the next token" — great at quickly producing plausible-looking code, but lacking the internalized engineering discipline of a senior developer. Specifically, the core mechanism of LLMs is autoregressive generation: given an input text, the model computes a probability distribution over its vocabulary for the next token, selects the highest-probability token, and repeats until a complete response is generated. This means the model is essentially doing statistical pattern matching — it learned from massive training data "what code snippets typically follow what context," rather than truly understanding the causal logic and quality constraints of software engineering. Ask it to implement a feature, and it'll hand you code directly, instead of asking like a real engineer would: What are the requirement boundaries? How should edge cases be handled? What test cases should be written?

Addressing exactly this pain point, developer mattpocock launched the open-source project skills, which quickly went viral — rocketing to 243K GitHub stars with thousands of new stars daily, making it a phenomenon in the AI coding community.

What skills Actually Is: An Engineering Skill Pack for AI Coding

In simple terms, skills breaks down the expertise of top-tier engineers into executable "skill packs" for AI. It's not yet another AI coding tool — it's a collection of engineering capabilities that can be "loaded" onto your existing AI assistants.

The Core Idea: Don't Tweak Prompts — Just Buff Your AI

The most clever aspect of this project is how it's used. Traditionally, if you want AI to write more disciplined code, you'd repeatedly fine-tune your prompts, reminding it in every conversation to "remember to write tests," "watch for edge cases," or "do a code review." While prompt engineering has produced sophisticated techniques like few-shot prompting and chain-of-thought in academic research, it faces fundamental challenges in real-world development: context windows are limited, so complex engineering specs can consume a huge number of tokens; consistency is hard to guarantee, as the same prompt may produce wildly different results across conversations; and as teams scale, each member maintaining their own prompt templates leads to fragmented standards.

skills takes an entirely different approach — you don't need to modify any prompts; just install the skill pack, and engineering thinking kicks in automatically. It's essentially an "engineering buff" for your AI assistant, making it automatically follow professional development workflows when handling tasks.

From a technical implementation standpoint, skills leverages the rules file mechanisms provided by various AI coding tools. For example, Cursor uses rule files in the .cursor/rules directory, Claude Code uses CLAUDE.md files, and Codex has its own corresponding configuration approach. These rule files are automatically injected into the system prompt during every AI interaction, serving as constraints the model must follow when generating code. Unlike user-entered prompts, rule files are persistent (they don't disappear when conversations refresh), structured (they can be organized modularly by responsibility), and team-shareable (they can be synced across teams via version control systems). What skills provides is a validated, high-quality collection of these rule files that take effect automatically with a single install.

25 Built-in Engineering Skills

skills comes with approximately 25 engineering skills covering critical phases of the software development lifecycle. In traditional software engineering, the complete SDLC spans requirements analysis, system design, coding, testing, deployment, operations monitoring, and more — each phase backed by mature methodologies. The requirements phase has user story mapping and acceptance criteria definition; the testing phase has the "test pyramid" strategy of unit tests, integration tests, and end-to-end tests; and the code review phase has peer reviews and static analysis tools. However, when AI steps into the coding process, it typically executes only the "coding" phase, skipping the quality assurance steps before and after. These skills force the AI to perform a series of professional actions while writing code, bringing back the skipped phases:

• Requirements Analysis: Clarify requirement boundaries before writing code, instead of blindly jumping in
• Test Writing: Add test cases to ensure code is verifiable
• Code Review: Self-review like a senior engineer, preventing bad code at the source

In other words, skills decomposes "how to be a professional engineer" into rules that AI can understand and execute, elevating AI output quality from "it runs, so it's fine" to "engineering-grade standards."

Compatible with Cursor, Claude Code, and Other Major AI Coding Tools

Another major advantage of skills is its broad tool compatibility. It's not tied to any specific platform — it works with Claude Code, Cursor, Codex, and virtually every major AI coding tool.

This means no matter which AI coding assistant you use daily, you can plug this skill pack in, and it takes effect immediately. For development teams, this also offers a low-cost way to unify code quality standards — without switching toolchains, you can ensure everyone's AI assistant follows the same engineering conventions.

Why the "Skill Pack" Model Represents the Future of AI Coding

From a broader perspective, the popularity of skills reflects how AI coding is evolving from "being able to generate code" to "generating high-quality code." Early on, people marveled that AI could write code at all. Now the focus has shifted: Can the code AI writes go into production? Is it maintainable? Is test coverage sufficient?

This "skill pack" or "capability plugin" model is essentially about making human expert tacit knowledge explicit, structuring it, and injecting it into general-purpose LLMs. Tacit knowledge, a concept introduced by philosopher Michael Polanyi, refers to knowledge that's difficult to articulate in words and is typically acquired through experience. In software engineering, many of a senior engineer's judgments fall into this category: when to split a function, which edge cases are most easily overlooked, what to focus on during code review. This knowledge has traditionally been passed down only through mentorship, code review culture, and team collaboration — an approach that's inefficient and highly dependent on individual experience. The core innovation of skills is transforming this tacit knowledge into structured, machine-executable rules, enabling the scalable replication of engineering expertise. In the field of knowledge management, this is known as "Knowledge Codification" — it allows even junior developers to achieve code quality control approaching senior engineer standards, with AI's help.

It doesn't require retraining models. Instead, it guides model behavior through a layer of "engineering specification constraints." This lightweight, pluggable, cross-tool approach is very likely to become a mainstream paradigm for AI-assisted development in the future.

Final Thoughts

mattpocock's skills project offers a pragmatic answer: instead of complaining that AI writes unprofessional code, just equip it with an engineer's expertise. For developers who want AI to produce standardized, engineering-grade code, this is undoubtedly an efficiency tool worth trying.

That said, it's important to stay realistic. While 243K stars is impressive, whether the skill pack truly delivers in practice — and how it performs in complex projects — still needs validation in your own context. Engineering thinking is valuable, but no tool can fully replace the judgment of human engineers. The real value of skills lies more in providing an efficient starting point for "helping AI make fewer rookie mistakes."