addyosmani/agent-skills
23 skills94.9k installs1M starsGitHub
Install
npx skills add https://github.com/addyosmani/agent-skillsSkills in this repo
1Code Review And Qualitycode-review-and-quality gives solo builders and small teams a repeatable merge gate instead of rubber-stamping agent output. The skill frames review as five axes—correctness, readability, architecture, security, and performance—with a pragmatic approval ethic: ship improvements that raise codebase health even when they are not exactly how you would have written them. Invoke it before merging any PR, after finishing a feature, when evaluating another model’s code, during refactors, and after bug fixes where the fix and its tests both matter. It pairs naturally with implementation and testing skills upstream but does not replace automated CI. Use it on Ship to keep main branch trustworthy while you move fast with AI coding agents.6.3kinstalls2Spec Driven DevelopmentSpec-driven development is an agent skill that forces a structured specification before any code changes when requirements are unclear, multi-file, architectural, or likely to exceed a short fix. It implements a gated workflow—Specify, Plan, Tasks, and Implement—where the human reviews output at each step so the agent is not guessing intent. Solo and indie builders shipping with Claude Code, Cursor, or Codex use it when starting a new project or feature, when specs do not exist yet, or when a task would take more than thirty minutes to implement. The skill fits early journey work in validate and build but applies whenever significant work lacks a written agreement. It complements ad-hoc chat planning by making assumptions, scope, and done-ness explicit before agents touch the repo.5.2kinstalls3Planning And Task BreakdownPlanning and Task Breakdown is an agent skill that decomposes specs into verifiable units with clear dependencies and acceptance criteria. It targets the gap between a written requirement and code an agent can finish reliably: enter read-only plan mode, read the spec and repo patterns, map a dependency graph, then emit ordered tasks small enough to implement, test, and verify in one session. Use it when you have a spec but the work feels too large, when you need estimates or parallelizable chunks, or when implementation order is unclear. Skip it for trivial single-file edits or when tasks are already spelled out in the spec. For solo builders, the skill is the structured alternative to jumping straight into codegen. Primary placement is Build PM, but the same workflow applies when scoping in Validate or preparing a ship checklist from a frozen spec.5.1kinstalls4Frontend Ui Engineeringfrontend-ui-engineering is a build-phase skill for solo and indie builders who want agent-generated interfaces to look and behave like work from a design-aware product team. It covers when to engage—new pages, component refactors, responsive layouts, stateful interactions, and visual bug fixes—and how to structure code with colocated tests, hooks, and types instead of dumping logic into monolithic files. Guidance favors composable APIs (children and subcomponents over sprawling prop configs), real accessibility and performance expectations, and adherence to an existing design system rather than default gradient-card templates. Pair it with context-engineering when agents need component-local files loaded, and with ship-phase review skills before launch. Prism lists it for builders shipping SaaS dashboards, browser extensions, or mobile web surfaces who care that UI quality is a retention feature, not an afterthought.4.8kinstalls5Incremental ImplementationIncremental Implementation is a journey-wide agent skill that enforces thin vertical slices for any non-trivial code change. Solo builders invoke it when a feature spans multiple files, when refactoring feels open-ended, or when they are about to dump a large patch before running tests. The documented cycle is implement the smallest complete piece, run or add tests, verify behavior, commit, then take the next slice so the repo stays deployable throughout. It is the execution complement to planning skills: approved specs still fail if landed in one monolithic diff. Use during Build for feature work, during Ship when fixing bugs across layers, and during Operate when iterating on production fixes without breaking main. Skip only for truly single-function, single-file edits where scope is already minimal.4.6kinstalls6Documentation And AdrsDocumentation and ADRs is a journey-wide agent skill for solo builders who need durable context in the repo. It steers you away from comment clutter and toward high-leverage artifacts—especially Architecture Decision Records—that explain constraints, alternatives rejected, and consequences of technical choices. The skill applies whenever you pick a major dependency, reshape a schema, settle on auth, or ship behavior strangers (and agents) must understand months later. It also fits onboarding moments when the same explanations keep coming up in chat. You still skip it for obvious one-liners and disposable spikes. For a one-person shop, this is how you prevent your future self and your agent from undoing good decisions because the reasoning was never written down.4.5kinstalls7Browser Testing With Devtoolsbrowser-testing-with-devtools teaches coding agents to test and debug web UIs through the Chrome DevTools MCP server. Solo builders shipping SaaS dashboards, marketing sites, or extensions use it whenever a change renders in the browser and they need confirmation—not speculation—about errors, failed requests, or slow paints. The skill bridges the gap between edited source and what users actually see: open pages, read console output, trace network calls, and capture performance signals. It requires configuring the chrome-devtools MCP entry in .mcp.json or equivalent agent settings. Backend-only refactors and pure CLI tools are out of scope per the skill’s own guidance. After frontend implementation, keep using it during ship perf checks and pre-launch smoke passes so fixes are validated in Chrome before you distribute.4.4kinstalls8Performance Optimizationperformance-optimization is an agent skill that enforces measurement-led performance work for web and app experiences. It opens with a clear rule: optimizing without profiling is guessing and often adds complexity without moving the metrics users feel. The skill applies when requirements include load or response budgets, monitoring surfaces regressions, Core Web Vitals fall below recommended bands, or features face large datasets and high concurrency. It documents concrete targets for LCP, INP, and CLS across good, needs improvement, and poor tiers, then walks a repeatable loop—establish a real baseline, find the actual bottleneck, apply a focused fix, and re-measure. Solo builders use it to avoid vanity refactors and to prioritize changes that improve storefront or dashboard responsiveness. It deliberately warns against use when no problem is demonstrated, aligning agent behavior with disciplined performance engineering rather than default premature optimization.4.3kinstalls9Code Simplificationcode-simplification is a process-driven agent skill for indie builders who have code that works but reads heavier than it should. It instructs the agent to reduce unnecessary complexity—deep nesting, long functions, vague names, duplication—while preserving exact behavior, using a simple bar: would someone new understand this faster than before? The documented triggers fit after a feature ships locally with passing tests, during code review when readability issues surface, or when merge pressure left shortcuts scattered across files. It is not a license to rewrite for fewer lines or to optimize performance without evidence, and it explicitly warns against simplifying code you do not yet understand. For solo founders juggling frontend, APIs, and agent glue, this skill turns “it works but I dread touching it” into a disciplined clarity pass that pairs naturally with review and ship gates, without destabilizing shipping velocity.4.3kinstalls10Context Engineeringcontext-engineering teaches solo and indie builders how to feed coding agents the right information at the right time. Too little context invites wrong patterns and invented APIs; too much dilutes focus. The skill documents a deliberate hierarchy—rules files such as CLAUDE.md at the persistent base, then architecture or spec docs per session, relevant source per task, errors and tests per iteration, and accumulating conversation history—so you can restart sessions, switch subsystems, or onboard a new repo without quality collapse. Use it when output drifts from team conventions, when you stand up agent rules for a greenfield project, or when you move between frontend and backend areas in one codebase. On Prism it sits as journey-wide agent infrastructure: the same discipline helps during build implementation, ship debugging loops, and operate fixes whenever an agent needs a tighter window on truth.4.3kinstalls11Security And Hardeningsecurity-and-hardening is a journey-wide agent skill from Addy Osmani’s collection that treats application security as a continuous constraint, not a late checklist. Solo builders invoke it whenever a feature touches untrusted input, authentication, sensitive storage, or third-party APIs—exactly the surfaces where agent-generated code most often cuts corners. The skill organizes work around a three-tier boundary system and an explicit Always Do list: validate at the edge, never concatenate SQL, rely on framework escaping instead of bypassing it, enforce TLS, hash credentials with modern algorithms, set defensive HTTP headers, and configure cookies for session fixation resistance. It also calls out high-risk feature classes such as uploads, webhooks, and payment flows so you extend the same rules as scope grows. Pair it during implementation reviews and before ship; it is procedural secure-coding guidance, not a replacement for threat modeling tools or automated DAST.4.2kinstalls12Debugging And Error RecoveryDebugging and Error Recovery is an agent skill that forces systematic root-cause work whenever something breaks in your stack. Solo builders often patch symptoms and stack new features on top of red tests or failing CI; this skill implements a stop-the-line discipline—freeze changes, keep error output and repro steps, walk a triage checklist, fix the actual cause, add guards, and only then continue. It is triggered by failing tests after a edit, broken builds, behavior that diverges from expectations, incoming bug reports, or errors in logs and consoles, including “it used to work” regressions. The overview positions the same checklist for test failures, build errors, runtime bugs, and production incidents, so it travels with you from pre-ship verification into operational firefighting. The intent is procedural reliability for agents that otherwise guess fixes and waste context on compounding mistakes.4.2kinstalls13Idea Refineidea-refine is an agent skill package that facilitiates ideation sessions for solo and indie builders who have half-formed opportunities and need disciplined exploration before specs or code. It walks through phased dialogue—clarifying who feels the pain, which part of “compete” or deliver value actually matters, and what shape (software, cooperative model, hybrid) fits constraints—so you do not lock into the wrong problem statement. The bundled examples show full sessions from a vague local-restaurant vs delivery-platform tension through narrowed customer-dependency and margin themes, demonstrating question pacing and expansion without premature solutioning. Install it when you invoke ideation-style commands or want an agent that matches a facilitator rhythm across early discovery. It matters on Prism because it turns fuzzy chat into repeatable journey-wide thinking you can cite before validate and build skills take over.4.2kinstalls14Test Driven DevelopmentTest-Driven Development is a journey-wide agent skill that makes tests the proof of correctness before and after code changes. Solo builders use it whenever they implement logic, fix a reported bug, or modify behavior that could regress existing features. The skill encodes a strict RED-GREEN-REFACTOR loop: write a failing test, write the smallest code to pass, then refactor while keeping tests green. It rejects "seems right" as done and treats a well-tested codebase as leverage for AI-assisted coding. The Prove-It Pattern requires failing tests that reproduce bugs before fixes land. It pairs naturally with browser runtime checks when UI behavior is involved. Skip it only for non-behavioral edits like documentation or configuration that does not change runtime outcomes. The result is incremental, verifiable progress that agents can extend safely.4.1kinstalls15Api And Interface Designapi-and-interface-design is a methodology skill for solo builders and small teams who own both API and client code and cannot afford silent breaking changes. It frames interface work—REST and GraphQL endpoints, TypeScript boundaries, React props, and database shapes that leak into responses—through stability and misuse resistance. Hyrum’s Law anchors the guidance: undocumented behavior still becomes contract once users depend on it. Invoke when sketching a new service boundary, splitting a monolith module, or tightening types between frontend and backend. The skill is prose principles rather than a generator, so the agent applies judgment while drafting OpenAPI, GraphQL SDL, or shared types. It complements ship-phase review when you change versioned surfaces and points readers toward explicit deprecation paths instead of ad-hoc renames.4.1kinstalls16Using Agent SkillsUsing Agent Skills is the meta-skill for the addyosmani/agent-skills collection: it tells your coding agent how to discover and invoke the right procedural SKILL.md for whatever you are doing next. Solo and indie builders install it when their repo ships many phase-specific workflows and they want consistent routing instead of opening random skills from memory. At session start or whenever the task type is unclear, you apply the embedded discovery tree—idea clarification, spec and planning, incremental build with UI/API/context variants, test-driven or browser testing, and debugging—so the agent picks interview-me, spec-driven-development, incremental-implementation, test-driven-development, or another sibling skill deliberately. It does not implement product code itself; it encodes senior-engineer habit of matching process to phase. Pair it with the specialized skills the tree points to once routing is decided.4.1kinstalls17Ci Cd And AutomationCI/CD and Automation is an agent skill for solo builders and small teams who need reliable pipelines without babysitting every merge. It walks through automating quality gates so no change ships without passing lint, formatting, TypeScript checks, tests, and build steps—treating CI as the consistent enforcer that complements human and agent review. The overview emphasizes shift left (move static analysis and tests upstream) and faster-is-safer releases via small batches. Use it when bootstrapping CI on a new repo, tightening gates after incidents, wiring deployment stages, or diagnosing failing jobs. It pairs naturally with testing, security, and code-review skills because the pipeline is where those practices become mandatory on every change.4kinstalls18Git Workflow And Versioninggit-workflow-and-versioning is a journey-wide agent skill from Addy Osmani’s agent-skills collection that structures how you use Git when an AI agent is writing most of the diffs. It treats version control as the safety net: atomic commits, short-lived branches, and history that explains what changed and why. The recommended default is trunk-based development—main stays deployable, feature branches merge within a few days, and long-lived development branches are called out as merge-risk debt. The skill still allows teams on gitflow to borrow the commit hygiene without switching models overnight. For a solo builder juggling Validate prototypes and Operate hotfixes in one repo, that discipline is what keeps rollbacks and code review possible instead of one giant unreviewed paste. Invoke it whenever you commit, branch, rebase, or resolve conflicts, not only at release time.4kinstalls19Shipping And Launchshipping-and-launch is an agent skill that walks solo builders through deploying to production with discipline: every launch should be reversible, observable, and incremental. It applies when you ship a feature for the first time, release a meaningful user-facing change, migrate data or infrastructure, or open beta access—essentially any deployment with real risk. The embedded pre-launch checklist forces pass conditions across code quality (tests, lint, types, review, no stray debug logs), security (secrets hygiene, npm audit severity, validation, auth, headers, rate limits, CORS), and launch operations implied by the overview (monitoring, rollback, success criteria). Use it right before production cutover when chatty “just deploy” energy would skip gates. The skill packages judgment about safe shipping into a repeatable agent workflow rather than replacing your CI provider or hosting dashboard.3.8kinstalls20Deprecation And Migrationdeprecation-and-migration is an agent skill for treating removal and user movement as first-class engineering work, not an afterthought. It argues that code is a liability—every line carries testing, documentation, security, and cognitive overhead—and that organizations excel at building but often fail at retiring. The skill applies when you replace an API or library, sunset an unused feature, merge duplicate implementations, or cut dead code that still has implicit dependents. It also supports upfront lifecycle planning so new systems ship with a credible deprecation story. Solo builders use it to decide whether to keep patching legacy paths or invest in a focused migration, and to sequence communication, dual-running, and cutoff in a way that reduces breakage. It is methodology-heavy rather than a single tool integration, so the agent helps you reason about timelines, consumer impact, and when maintenance no longer earns its keep.3.7kinstalls21Source Driven DevelopmentSource-Driven Development is a journey-wide agent discipline from Addy Osmani's skill set: before you write framework-specific code from memory, you verify behavior against official documentation, cite sources, and implement only what you can point to on the vendor site. Solo and indie builders adopt it when starter templates, auth flows, or data layers will be cloned across a SaaS, CLI, or API service and mistakes are expensive. It fits Claude Code, Cursor, and Codex sessions where the user asked for correct, current best practices—not fastest guesswork. The skill draws a clear line: skip it for version-agnostic refactors, but use it whenever Next.js, React, or similar ecosystems dictate recommended patterns for forms, routing, fetching, or state. Outcomes are trustworthy snippets the user can re-check, reducing surprise breaking changes after ship.3.3kinstalls22Doubt Driven DevelopmentDoubt-Driven Development is a process skill for solo and indie builders who use coding agents on long sessions where confident answers quietly harden into assumed facts. It instructs the agent to treat every non-trivial decision—logic changes, module boundaries, thread-safety or ordering claims, and irreversible deploys or migrations—as something that must survive a fresh-context adversarial review before it ships. Unlike a terminal code-review verdict on a completed diff, this is an in-flight discipline you invoke while branching logic and blast radius are still negotiable. It fits builders shipping SaaS, APIs, or CLIs where correctness matters more than raw speed, especially in unfamiliar repos or security-sensitive paths. Pair it with your normal commit and deploy flow so skepticism lands before irreversible steps, not after customer impact.2kinstalls23Interview Meinterview-me is a journey-wide clarification ritual for solo builders who phrase solutions (“make it faster”, “add a dashboard”) before naming users, constraints, or success metrics. The agent asks a single targeted question per turn—often with a proposed answer—until it can anticipate what you will say next at roughly ninety-five percent confidence. That prevents expensive rework once plans, specs, or repos exist. It complements Define-phase skills: idea-refine explores variations after intent is roughly known; spec-driven-development writes requirements; doubt-driven-development stress-tests an existing plan. Use interview-me whenever you catch the model guessing stakeholders, scope, or non-goals. It produces aligned intent narratives, not code. Anti-pattern is skipping it when a spec is already approved and signed off.1.6kinstalls