addyosmani/agent-skills

API and Interface Design guides the creation of stable, well-documented interfaces including REST APIs, GraphQL schemas, module boundaries, and component props. Use it when designing new endpoints, defining contracts between teams, or changing existing public interfaces.

Agent Skill Discovery discovers and invokes agent skills, helping an agent identify the right engineering workflow for a task. Use it when starting a session or when unsure which skill applies.

Browser Testing runs tests and inspections in a real browser via Chrome DevTools MCP. Use it when building or debugging browser UI to inspect the DOM, capture console errors, analyze network requests, profile performance, or verify visual output.

CI/CD and Automation sets up and modifies build and deployment pipelines, automating quality gates like lint, type check, tests, build, and security audits so no change reaches production without passing checks.

Code Review and Quality conducts multi-axis code review across correctness, readability, architecture, security, and performance before merging changes. Use it to assess code quality before code enters the main branch.

Code Simplification simplifies code by reducing complexity while preserving exact behavior. Use it when refactoring for clarity, improving readability, or reviewing code that has accumulated unnecessary complexity.

Context Engineering optimizes the information an AI agent sees by structuring rules files, specs, source files, error output, and conversation history. Use when starting a session, when agent output degrades, or when setting up project context.

Debugging and Error Recovery guides systematic root-cause debugging when tests fail, builds break, behavior doesn't match expectations, or any unexpected error occurs. Use it to follow a structured triage process to find and fix the root cause rather than guessing.

Deprecation and Migration removes old systems, APIs, or features and migrates users to replacements safely. Use when deciding whether to maintain or sunset existing code.

Documentation and ADRs records architectural decisions and writes documentation explaining why code was built a certain way. Use when making architectural decisions, changing public APIs, shipping features, or recording context for future engineers and agents.

Doubt-Driven Development subjects every non-trivial decision to a fresh-context adversarial review before it stands. Use when correctness matters more than speed, in unfamiliar code, or when stakes are high.

Frontend UI Engineering builds production-quality, accessible, responsive user-facing UIs. Use it when building or modifying interfaces, creating components, implementing layouts, meeting WCAG accessibility requirements, or managing state to achieve a polished, production-grade result.

Git Workflow and Versioning establishes structured git practices for committing, branching, resolving conflicts, organizing parallel work, and releasing software. Use it whenever making a code change or cutting a release.

Idea Refine turns vague ideas into sharp, actionable concepts through structured divergent and convergent thinking. Use it when an idea is still unclear, before committing to a plan, or to stress-test assumptions.

Incremental Implementation breaks multi-file changes into small vertical slices, each implemented, tested, and verified before moving on. Use it when a task feels too large to land in one step or when implementing any feature touching multiple files.

Interview Me asks one question at a time with attached guesses to uncover what a user actually wants instead of what they think they should want. Use it when an ask is underspecified, conventional, or the user explicitly asks to be interviewed before planning or building.

Observability and Instrumentation instruments code so production behavior is visible and diagnosable, adding logging, metrics, tracing, and alerting when shipping production features or diagnosing production issues with limited data.

Performance Optimization measures bottlenecks and optimizes frontend, backend, queries, and databases. Use when performance requirements exist, when you suspect regressions, when Core Web Vitals need improvement, or when profiling reveals bottlenecks.

Planning and Task Breakdown decomposes work into ordered, verifiable tasks with explicit acceptance criteria. Use it when you have a spec or clear requirements, when a task feels too large to start, or when parallel work is possible.

Security and Hardening hardens code against vulnerabilities. Use it when handling user input, authentication, data storage, or external integrations, and when building features that accept untrusted data, manage user sessions, or interact with third-party services.

Shipping and Launch prepares teams for production deployments with pre-launch checklists, monitoring setup, staged rollouts, and rollback strategies. Use it when deploying features, migrating data, or planning canary releases.

Source Driven Development grounds every framework-specific implementation decision in official documentation, so code is verifiable and follows current best practices. Use it when building with any framework or library where correctness matters, or when you want source-cited code free from outdated patterns.

Spec-Driven Development writes a structured specification before coding, defining objective, commands, code style, testing strategy, and boundaries. Use it when starting a new project or feature, when requirements are ambiguous, or when a change touches multiple files.

Test-Driven Development guides writing a failing test before code to make it pass. Use it when implementing logic, fixing bugs, or modifying behavior to prove code works.