Who Skills for Real Engineers is for#
Solo developers building production apps with Claude Code
Skills for Real Engineers gives solo developers the structured workflow a senior engineering team would apply naturally: alignment before coding, a shared domain language, test-driven implementation, and periodic architecture review. The modular install means you can start with /grill-me and /tdd alone and add more skills as the project grows.
Skip if:
You are prototyping a throwaway proof of concept and need maximum iteration speed. The alignment and TDD overhead slows early-stage exploration. Use /prototype for the discovery phase and add the full skill set once the idea is validated.
Engineering teams managing AI-accelerated codebases
Teams using AI agents at scale face architectural entropy at an unprecedented rate. The /improve-codebase-architecture skill periodically refocuses the agent on the whole system rather than the current file, counteracting drift. Combined with /tdd, this keeps the codebase changeable as AI commit velocity increases.
Skip if:
Your team has not aligned on issue tracker tooling. The /triage and /to-issues skills require per-repo setup, and inconsistent configuration across team members reduces their coordination value.
Developers who have tried and abandoned heavier AI frameworks
If GSD, BMAD, or Spec-Kit felt too opinionated or too difficult to debug when the framework itself produced wrong output, Skills for Real Engineers offers the same workflow benefits at a fraction of the overhead. Each skill is a readable, editable prompt file you can inspect and modify without framework knowledge.
Skip if:
You prefer a fully managed AI workflow where the process layer is invisible. These skills keep you in control of every invocation, which requires intentional process adoption rather than passive installation.
TypeScript developers building domain-rich applications
The /grill-with-docs skill's domain language and ADR tooling maps directly to Domain-Driven Design practices. Developers building applications with rich domain models, bounded contexts, or complex business logic get the most value from the CONTEXT.md shared language, because the naming and conceptual consistency compound across a longer development lifecycle.
Skip if:
Your project is a simple CRUD app with minimal domain complexity. The domain language investment has the highest return on projects with 6+ months of development history and non-trivial business rules.
The problem it solves#
AI coding agents like Claude Code and Copilot routinely produce code that misses the intent of the request, skips proper test coverage, names things inconsistently, and accelerates software entropy in the codebase. Heavier workflow frameworks like GSD, BMAD, and Spec-Kit try to fix this by taking over the entire development process, but they introduce their own bugs and strip the developer out of the loop when something goes wrong.
The failure modes compound. An agent that skips clarifying questions will build the wrong thing. An agent with no feedback loop from tests will iterate blindly when something breaks. An agent that has no shared domain language for the codebase will use inconsistent naming and waste tokens re-explaining the same concepts every session. The result is a codebase that accelerates past your ability to maintain it.
How it solves it#
Grilling session for intent alignment
The /grill-me and /grill-with-docs skills run a structured interview before any code is written, prompting the agent to surface every assumption and resolve every decision branch. /grill-with-docs also builds a CONTEXT.md shared domain language document and logs architectural decisions as ADRs, reducing naming inconsistencies and token costs across future sessions.
Test-driven red-green-refactor loop
The /tdd skill enforces a red-green-refactor cycle: the agent writes a failing test first, then writes the minimum implementation to pass it, then refactors. This provides a concrete feedback signal at every step rather than running blind. Works with any test framework and any supported coding agent.
Architecture improvement and context recovery
The /improve-codebase-architecture skill analyzes the codebase against its CONTEXT.md domain language and ADRs to find simplification and consolidation opportunities, counteracting the software entropy that AI agents accelerate. The /zoom-out skill reorients the agent to the whole system when it gets stuck in a specific file or function.
Disciplined debugging loop
The /diagnose skill wraps a structured diagnostic cycle: reproduce, minimise, hypothesise, instrument, fix, regression-test. It prevents the common agent pattern of making random changes until something passes, forcing a methodical path through hard bugs and performance regressions instead.
Issue management and PRD generation
/to-prd converts the current conversation into a Product Requirements Document and submits it as a GitHub or Linear issue. /to-issues breaks any PRD or spec into independently-grabbable issues using vertical slices. /triage runs issues through a configurable state machine of triage roles, with support for GitHub, Linear, or local files.
Strengths and trade-offs#
Strengths
- Composable and model-agnosticEach skill is a single-purpose prompt file installed independently. They work with Claude Code, GitHub Copilot agent mode, OpenAI Codex, and any other coding agent that accepts custom instructions. Unlike GSD or BMAD, you pick the skills you need and leave the rest. The project explicitly encourages forking and modifying individual skills to fit your workflow.
- MIT licensed with no lock-in or subscriptionThe entire collection is MIT licensed and requires no cloud service, API key, or subscription fee. Skills install into your local agent configuration and run indefinitely at no cost. Unlike Copilot at $10-19 per month per seat, there is no recurring cost for the workflow structure these skills provide.
- Grounded in documented software engineering fundamentalsEach skill cites its source: /tdd from Kent Beck's Extreme Programming, the shared domain language from Eric Evans' Domain-Driven Design, small deliberate steps from The Pragmatic Programmer. The reasoning is auditable and the skills are defensible in code review, a notable contrast to AI process frameworks that do not document their design choices.
- Large and active community footprintThe repo has ~78,000 GitHub stars and Matt Pocock's developer newsletter has ~60,000 subscribers who receive updates on new and updated skills. This is one of the largest community footprints of any AI coding workflow tool, with active maintenance and rapid iteration on new skills published regularly.
Trade-offs
- -Requires consistent habit formation to deliver valueThe skills are prompt invocations, not automated enforcement. Developers must remember to run /grill-with-docs before starting features, /tdd before writing implementation, and /improve-codebase-architecture on a regular schedule. Teams without established habits around these invocations will see inconsistent results. There is no enforcement layer that runs skills automatically.
- -Domain language setup requires upfront investmentThe /grill-with-docs skill builds a CONTEXT.md and ADRs that improve naming consistency and reduce token costs across sessions. But this investment is front-loaded and requires maintenance as the codebase evolves. On fast-moving projects or in early exploration phases, keeping CONTEXT.md current adds overhead before the benefits accumulate.
- -Shell-based install scoped to supported agent runtimesThe npx installer writes to agent-specific config directories. Teams using multiple different coding agents across developers need to configure each agent separately. The skills are plain text files, so they do not benefit from API-level integrations that purpose-built tools can provide.
Skills for Real Engineers vs alternatives#
Skills for Real Engineers vs GitHub Copilot
GitHub Copilot is a managed AI coding assistant integrated into IDEs and GitHub workflows. Skills for Real Engineers is a collection of workflow prompt files that structure how you communicate with your coding agent, including Copilot's own agent mode. They address different problems at different layers of the development process.
| Feature | Skills for Real Engineers | GitHub Copilot |
|---|---|---|
| License | MIT (open source) | Proprietary |
| Self-hosting | Yes (local prompt files) | No |
| Pricing | Free | $10/mo individual, $19/mo business |
| Works with | Claude Code, Copilot, Codex, others | GitHub ecosystem |
| Focus | Workflow structure and alignment | Code completion and suggestion |
| Setup | npx install, 30 seconds | IDE extension |
Skills for Real Engineers is the stronger choice when your main problem is alignment, test coverage gaps, or architectural drift in an AI-assisted codebase. The /grill-with-docs, /tdd, and /improve-codebase-architecture skills impose workflow structure that Copilot's suggestion engine does not provide. Developers who already use Copilot can run these skills on top of it without conflict.
GitHub Copilot is the better fit for developers whose primary need is inline code suggestions and tab-completion in the IDE with minimal process overhead. Copilot's chat and agentic features handle task-scoped automation well. Skills for Real Engineers handles the workflow discipline that surrounds those tasks: what to build, how to verify it, and how to keep the codebase from becoming a ball of mud over time.
Install and self-host#
npx skills@latest add mattpocock/skillsWhat it's built on#
- Languages
- Shell
FAQ#
What coding agents does Skills for Real Engineers support?
Skills for Real Engineers works with Claude Code, GitHub Copilot agent mode, and other coding agents that accept custom skills or instructions. The installer (npx skills@latest add mattpocock/skills) lets you choose which agents to install to during setup. Because each skill is a plain text prompt file, it can be manually adapted to any agent that supports custom instructions.
Is the collection free to use?
Yes. The entire collection is MIT licensed and free to install and run on your own machine. There is no cloud service, subscription, or API key required. Matt Pocock publishes new skills and updates through a free developer newsletter; the repo is publicly maintained on GitHub.
How is this different from just writing your own system prompt for Claude Code?
A hand-written system prompt sets broad agent behavior, but it does not give you purpose-built, invocable workflows for specific tasks. Each skill in this collection is a focused protocol for a specific problem: alignment before coding (/grill-with-docs), TDD enforcement (/tdd), architecture review (/improve-codebase-architecture). Maintaining a system prompt equivalent to these skills would require significant ongoing effort per repo.
Do I need to install all the skills, or can I pick just a few?
You can select individual skills during the install flow. The collection is fully modular. Productivity skills like /grill-me and /caveman have no dependencies. Engineering skills like /triage, /to-issues, and /tdd require running /setup-matt-pocock-skills once per repo to configure the issue tracker integration and domain document layout.
Why did Matt Pocock build this instead of using an existing AI framework?
The README explains that existing frameworks like GSD, BMAD, and Spec-Kit take over the entire development process, which makes their internal bugs hard to diagnose and removes the developer from the loop. Skills for Real Engineers deliberately keeps each skill small and single-purpose so that when something goes wrong, you can identify which skill failed and fix or replace it without touching the rest.
Similar open-source tools#
CLI-Anything
Empower AI agents with agent-native CLIs
9Router
Smart AI Router with 3-Tier Fallback
iroh
Connect devices seamlessly without relying on the cloud.
orca
The ultimate IDE for coding agents
oh-my-pi
A coding agent with the IDE wired in
Understand-Anything
Interactive knowledge graphs for codebases