Skills For Real Engineers

Skills For Real Engineers: A Practical Playbook for AI-Augmented Development

In the modern software landscape, AI agents are increasingly part of the developer toolkit. They can accelerate coding, triage, and experimentation—but only when they’re guided by solid practices. This post distills decades of hands-on engineering wisdom into a compact, composable set of skills you can adopt today. These aren’t abstract vibes or one-off tricks; they’re repeatable patterns designed to keep you in control, reduce friction, and ship reliable software. They work with any model, integrate with your workflow, and can be tailored to your project as you gain confidence. If you want to stay in the loop with updates to these skills and future additions, you can join the ~60,000 developers who subscribe to the Skills newsletter.

Quickstart: 30-Second Setup

Getting started with these skills is intentionally lightweight. Here’s the fastest path to first use:

• Install the skills harness on your machine:
• Run the skills.sh installer:
  • bash
  • npx skills@latest add mattpocock/skills
• Pick the skills you want and decide which coding agents will use them. Be sure to select /setup-matt-pocock-skills.
• In your agent, run /setup-matt-pocock-skills. It will guide you through:
• Choosing your issue tracker (GitHub, Linear, or local files)
• Selecting labels for triaged tickets (the /triage flow uses labels)
• Choosing where to save any docs we generate
• Bam — you’re ready to go.

Why These Skills Exist: Fixing Common AI-Driven Failure Modes

These skills were born from the most persistent failure modes I’ve seen when working with Claude Code, Codex, and other coding agents. They’re designed to be small, easy to adapt, and composable, so you can mix and match as needed. Four core problems motivated their creation, each with a practical fix.

1) The Agent Didn’t Do What I Want The problem is timeless in software development: misalignment. You think you’ve communicated your intent clearly, but the result looks nothing like what you expected. In the AI age, that same misalignment manifests as an agent misunderstanding your goals, pushing toward the wrong architecture, or delivering a feature that doesn’t meet your real needs.

The Fix: A grilling session to flush out requirements

• Use /grill-me for non-code tasks to surface intent, constraints, and success criteria.
• Use /grill-with-docs for engineering work. It’s the same grilling concept but adds domain documentation, context, and hard-to-articulate decisions. You’ll refine your shared language and capture decisions in ADRs and a living CONTEXT document.
• The practice pays off: you end up with a clearly defined, searchable shared language that anchors decisions, reduces ambiguity, and shortens the feedback loop.

In practice, you’ll see a dramatic improvement in alignment because the agent now speaks the same language you do. The grills force you to translate vague ideas into precise requirements, acceptance criteria, and traceable decisions. It’s not about interrogating the agent for hours; it’s about creating common ground so the agent can operate with clarity.

2) The Agent Is Way Too Verbose Developers and domain experts often speak different languages at the start of a project. The agent, lacking a shared vocabulary, introduces verbosity and extraneous wording as it tries to “guess” what you mean. This dilutes important details and makes it harder to extract useful guidance from the conversation.

The Fix: Build a shared language and lean on it

• Create a shared language document (think CONTEXT.md) that codifies domain terms, processes, and conventions. This acts as a decoder ring for the AI.
• Use /grill-with-docs to steady the conversation around the project’s terminology, update the CONTEXT.md, and keep ADRs current. This is a grilling session that aligns the model with your domain.
• The benefits extend beyond verbosity: consistent naming of variables, functions, and files makes the codebase easier to navigate for the agent, and the agent spends fewer tokens on trying to interpret ambiguous terms.

An example of a shared language change: translating “a problem with a lesson inside a section of a course” into “a problem with the materialization cascade.” The latter is tighter, more concise, and easier for both humans and agents to read and reason about. This simplification speeds up comprehension and reduces misinterpretation.

3) The Code Doesn’t Work Even when you’re aligned on goals, the agent may still produce buggy or incomplete code. This is where robust feedback loops become essential. Without fast, reliable feedback, the agent is flying blind and your iteration loop becomes painfully slow.

The Fix: Enforce fast feedback with tests, static checks, and targeted debugging

• Embrace a red-green-refactor loop as a core discipline. Have the agent write a failing test first, then implement the minimal code to pass it. This creates a predictable, measurable feedback signal that guides the agent toward correct behavior.
• Integrate static types and real browser access to prevent subtle defects from slipping through.
• Use a dedicated debugging loop: static analysis, targeted instrumentation, and automated regression tests. You’ll catch regressions early and keep the codebase healthier.

To operationalize this, I’ve built a /tdd skill that you can slot into any project. It codifies red-green-refactor, and the agent learns to build features and fix bugs one vertical slice at a time. I’ve also built a /diagnose skill that packages best debugging practices into a straightforward loop, letting you quickly diagnose performance regressions and hard bugs.

4) We Built A Ball Of Mud When AI-assisted development accelerates, it’s tempting to churn out features rapidly without worrying about design. Yet the fastest way to slow down in the long run is a software system that is hard to change. A “ball of mud” erodes maintainability and makes future changes expensive.

The Fix: Prioritize design and system-wide perspective

• Commit to design-first thinking at every step. Well-structured modules with simple interfaces reduce coupling and increase the system’s overall resilience.
• Use /to-prd to quiz yourself about module choices before drafting a PRD. This helps you articulate product decisions in terms of user needs and technical constraints.
• Use /zoom-out to step back and view the code in the context of the entire system. It’s easy to get lost in the weeds; zooming out keeps you aligned with the big picture.
• When the codebase starts deteriorating, run /improve-codebase-architecture to rescue it. This tool helps you identify where to apply refactors, extract core abstractions, and reduce entropy.
• Revisit architecture every few days and resist the urge to rebuild on a whim. A steady, disciplined approach to architecture buys time and makes the system far more adaptable to change.

Summary: The Core Message

Software engineering fundamentals matter now more than ever. The skills described here condense essential practices into repeatable, composable patterns that help you harness AI agents without surrendering control. They’re designed to be small, easy to adopt, and effective across diverse models and project domains. By embracing deliberate conversation, a shared language, strong feedback loops, and a design-first mindset, you can ship robust apps while still leveraging the speed of AI-assisted development.

Reference: Engineering Skills I Use Daily for Code Work

The following skills form the backbone of daily practice. Each item is a compact, focused tool you can drop into any project and adapt to your team’s needs.

Engineering Skills

• diagnose — A disciplined diagnosis loop for hard bugs and performance regressions: reproduce → minimize → hypothesize → instrument → fix → regression-test.
• grill-with-docs — A grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates CONTEXT.md and ADRs inline.
• triage — A triage workflow that processes issues through a state machine of triage roles, helping you decide what to fix first and how to communicate it.
• improve-codebase-architecture — A guided approach to finding deepening opportunities in a codebase, informed by the domain language in CONTEXT.md and the decisions in docs/adr/.
• setup-matt-pocock-skills — Scaffold the per-repo config (issue tracker, triage vocabulary, and domain doc layout) that the other skills consume. Run once per repository before using to-issues, to-prd, triage, diagnose, tdd, improve-codebase-architecture, or zoom-out.
• tdd — Test-driven development with a red-green-refactor loop. Builds features or fixes bugs one vertical slice at a time.
• to-issues — Break any plan, spec, or PRD into independently-grabbable GitHub issues using vertical slices.
• to-prd — Turn the current conversation context into a PRD and submit it as a GitHub issue. No interview—just synthesizes what you’ve already discussed.
• zoom-out — Tell the agent to zoom out and give broader context or a higher-level perspective on an unfamiliar section of code.
• prototype — Build a throwaway prototype to flesh out a design—either a runnable terminal app for state/business-logic questions, or several radically different UI variations toggleable from one route.

Productivity Tools (General Workflow Tools)

• caveman — Ultra-compressed communication mode. Cuts token usage by roughly 75% by dropping filler while preserving technical accuracy.
• grill-me — Get relentlessly interviewed about a plan or design until every branch of the decision tree is resolved.
• handoff — Compact the current conversation into a handoff document so another agent can continue the work.
• write-a-skill — Create new skills with proper structure, progressive disclosure, and bundled resources.

Misc Tools

• git-guardrails-claude-code — Set up Claude Code hooks to block dangerous git commands (push, reset --hard, clean, etc.) before they execute.
• migrate-to-shoehorn — Migrate test files from as type assertions to @total-typescript/shoehorn.
• scaffold-exercises — Create exercise directory structures with sections, problems, solutions, and explainers.
• setup-pre-commit — Set up Husky pre-commit hooks with lint-staged, Prettier, type checking, and tests.

Putting It All Together

The vision behind these skills is simple: empower you to work with AI agents as productive teammates rather than as unpredictable inputs. By focusing on alignment through grilling sessions, reducing verbosity with a shared language, enforcing a strong feedback loop with tests and debugging practices, and maintaining design discipline to avoid a creeping mudball of code, you build robust software faster and with greater confidence.

If you’re ready to take the next step, start with the Quickstart, then experiment with the grills and the shared CONTEXT approach. Build your own ADRs, expand your CONTEXT.md as the project evolves, and let ADRs serve as a living record of decisions that extensions and agents can respect. Over time, these practices become second nature, and your team will experience smoother collaborations with AI tools and higher-quality software.

A Final Note on Community and Growth

The ideas here aren’t meant to be dogma; they’re starting points you can tailor to your environment. If you want ongoing updates and new skills, consider joining the Skills newsletter. It’s a space where dozens of thousands of developers share what’s working, what’s evolving, and how to adapt these patterns to new tools and challenges. The ecosystem will continue to evolve, and the best way to stay ahead is to participate, experiment, and refine these methods in your own context.