Core Idea
The author's design philosophy, what sets this apart from peer projects, and quick notes on the key workflows. Skill names mentioned in the text auto-link to their detail pages.
The core idea of this skillset is: encode senior engineer engineering judgment into structured workflows that AI agents can execute. Unlike Superpowers, Matt Pocock's skills, and similar projects, its differentiation lies in:
Skills are organized by SDLC phase:
The meta-skill /using-agent-skills routes tasks to the correct workflow.
Typical workflow: In Claude Code or compatible agents, users issue slash commands (e.g., /spec) to start a phase, and the agent automatically loads the corresponding skill chain. /build auto mode allows full auto-execution after a one-time plan approval. For team scenarios, the skillset provides a shared engineering vocabulary and gate standards; for solo developers, individual skills can be cherry-picked as needed.
Skill Composition
Each skill is designed for a specific kind of caller — some only fire when you name them, others load automatically when the model judges them relevant. The split below summarises both modes at a glance.
These skills only fire when you call them by name. The agent will not load them on its own — they stay inert until invoked.
These skills are loaded automatically by the agent when it judges the context relevant. You usually don't need to call them yourself.
Skill List
Guides agents to design stable, hard-to-misuse public interfaces using contract-first principles. Covers REST, GraphQL, module boundaries, component props, emphasizing Hyrum's Law, One-Version Rule, error semantics, and boundary validation. Produces consistent, maintainable, well-documented interface specifications.
Browser testing skill that gives agents live browser runtime visibility via Chrome DevTools MCP. Supports DOM inspection, console log capture, network request analysis, performance profiling, and visual output verification. Bridges the gap between static code analysis and live browser execution.
CI/CD automation skill that guides agents to set up and maintain automated build and deployment pipelines. Emphasizes shifting quality gates left, integrating tests, lint, type checking, and build verification into every change. Follows the "smaller is faster is safer" principle with frequent small releases.
Code review and quality skill that guides agents to conduct multi-axis code reviews covering correctness, design, maintainability, security, and performance. Emphasizes change sizing (~100 lines), severity labels (Nit/Optional/FYI), and splitting strategies to ensure code quality before every merge.
Code simplification skill that guides agents to simplify complex code without changing behavior. Applies Chesterton's Fence (understand before removing), Rule of 500 (split large files), and refactoring techniques like reducing nesting and eliminating duplication. Produces clearer, more maintainable code.
Context engineering skill that guides agents to optimize AI coding assistant context setup. Covers rule file configuration, multi-file context packing, MCP integration, and session management. Improves agent understanding of project context when starting sessions, output quality drops, or switching tasks.
Debugging and error recovery skill that guides agents through systematic root-cause debugging. Follows a five-step triage: reproduce → localize → reduce → fix → guard. Enforces a "stop-the-line" rule against guesswork. Produces root cause analysis, fix plans, and guard measures to prevent recurrence.
Deprecation and migration management skill that guides agents to safely remove old systems, APIs, or features. Emphasizes "code as liability" thinking, distinguishes compulsory vs advisory deprecation. Provides migration patterns, zombie code removal strategies, and compatibility management for smooth deprecation.
Documentation and ADR skill that guides agents to record the context, constraints, and trade-offs behind key decisions. Emphasizes documenting the "why" not the "what", using Architecture Decision Records to capture technical choice reasoning. Produces human-and-agent-friendly codebase documentation.
Doubt-driven development skill that introduces a fresh-context adversarial review before non-trivial decisions stand. Through a CLAIM → EXTRACT → DOUBT → RECONCILE → STOP five-step process, an independent reviewer examines decisions with a "disprove" rather than "approve" mindset. For high-stakes, unfamiliar code, or irreversible operations.
Frontend UI engineering skill that guides agents to build production-quality, accessible, responsive user interfaces. Covers component architecture, design systems, state management, responsive design, and WCAG 2.1 AA accessibility. Emphasizes composition over configuration and separation of concerns.
Git workflow and versioning skill that guides agents to follow trunk-based development, atomic commits, descriptive messages, and semantic versioning best practices. Treats commits as save points, branches as sandboxes, and history as documentation. Keeps AI-generated code changes manageable, reviewable, and reversible.
Idea refinement skill that transforms vague concepts into actionable proposals through structured divergent and convergent thinking. Three-phase process: diverge (generate variations) → evaluate/converge (stress-test) → sharpen/ship (one-pager). Outputs include problem statement, recommended direction, key assumptions, and MVP scope.
Incremental implementation skill that guides agents to build features progressively through thin vertical slices. Each slice delivers a complete end-to-end path, tested, verified, and committed before the next. Supports vertical slicing, contract-first slicing, and risk-first slicing strategies, keeping the system working at all times.
Requirements interview skill that extracts what users actually want (not what they think they want) through one-question-at-a-time dialogue. Reaches ~95% confidence about underlying intent before any plan, spec, or code exists. For underspecified requests like "build me X" without context.
Observability and instrumentation skill that guides agents to write telemetry alongside feature code. Covers structured logging, RED metrics (Rate/Error/Duration), OpenTelemetry tracing, and symptom-based alerting. Emphasizes "define working before instrumenting", ensuring every telemetry signal answers an operations question.
Performance optimization skill that guides agents to "measure before optimizing". Covers frontend Core Web Vitals (LCP/INP/CLS), backend response time analysis, database query optimization, N+1 detection, and bundle size analysis. Uses a measure→identify→fix→verify→guard workflow to avoid premature optimization.
Planning and task breakdown skill that decomposes specifications into ordered, verifiable small tasks. Each task includes description, acceptance criteria, verification method, dependencies, and scope estimate. Uses dependency graphs to identify build order and vertical slicing for independent task implementation.
Security hardening skill that guides agents to develop web applications security-first. Covers threat modeling (STRIDE), three-tier boundary system (always do/ask first/never do), OWASP Top 10 prevention, auth patterns, secrets management, and dependency auditing. Treats every external input as hostile and every secret as sacred.
Shipping and launch skill that guides agents to prepare production releases. Includes pre-launch checklists (code quality, security, performance, accessibility, infrastructure, documentation), feature flag strategy, staged rollout plans, rollback procedures, and monitoring setup. Ensures every release is reversible, observable, and incremental.
Source-driven development skill that requires every framework-specific code decision to be backed by official documentation. The agent detects the stack and versions, fetches official docs, implements patterns from docs, and cites sources. Prevents stale training data or deprecated APIs from producing incorrect code.
Spec-driven development skill that writes a structured specification before any code. The spec covers six core areas: objective, commands, project structure, code style, testing strategy, and boundaries. Uses a gated workflow: spec → plan → tasks → implement, with human approval required at each phase.
Test-driven development skill that forces agents to write a failing test before implementation. Follows the Red-Green-Refactor cycle: write a failing test (RED) → write minimal code to pass (GREEN) → refactor (REFACTOR). For bug fixes, write a test reproducing the bug first. Tests are proof — "seems right" is not done.
Meta-skill for using agent skills, guiding agents to discover and invoke the right skill for the current task. Provides a skill discovery decision tree mapping development phases (define/plan/build/verify/review/ship) to corresponding skills. Also defines core operating behaviors: surface assumptions, manage confusion, push back when warranted.
Installation
Copy and run in your terminal to add addyosmani/agent-skills to your Agent environment.
npx skills add addyosmani/agent-skillsSkill Relationships
Skill → Skill usage relationships, with cross-layer references. Same color blocks indicate the same skill form.