pproenca/dot-skills
21 skills19.2k installs3.3k starsGitHub
Install
npx skills add https://github.com/pproenca/dot-skillsSkills in this repo
1ZodZod is a community agent skill that packages a comprehensive TypeScript schema-validation reference tuned for LLM-driven maintenance and generation. Solo builders shipping APIs, SaaS backends, or CLI tools that touch user input install it when they want consistent Zod patterns instead of one-off snippets. The guide orders 43 rules across eight impact tiers—from critical schema definition and parsing through incremental performance and bundle optimization—each with explicit wrong vs right examples and stated impact so agents can refactor safely. It stresses validating strings at the schema layer, coercing stringly form and query data, and resisting schemas that accept anything via optional overload. Use it during Build when defining DTOs and env parsing, and again in Ship when hardening tests and review against the same checklist. It does not run Zod for you; it proceduralizes how your agent should write and evolve schemas.3.3kinstalls2Clean Architectureclean-architecture is a procedural knowledge skill that encodes Clean Architecture guidance for solo builders and small teams who want maintainable, testable systems without rereading the book on every feature. Invoke it when you are sketching a new service boundary, choosing where frameworks live, or reviewing a PR that leaks infrastructure into domain logic. The skill organizes forty-two rules into eight categories—from critical dependency direction and entity design through boundary definition, interface adapters, framework isolation, and testing architecture—so your agent proposes fixes that respect inward-pointing dependencies and isolated use cases. It is equally useful during initial Build structuring and during Ship code review when architectural drift appears. Expect checklist-style recommendations rather than automatic refactors; you still apply judgments about scope and incremental migration.1.6kinstalls3React Hook FormReact Hook Form is a versioned agent skill (v1.2.0) that encodes a performance-first rulebook for maintaining, generating, and refactoring forms in React Hook Form v7 codebases. It is written for LLM workflows: abstract explains priority ordering from form configuration and field subscriptions through async submit handling. Solo builders shipping SaaS dashboards or signup flows can invoke it when forms feel slow, re-render excessively, or mishandle server validation. The skill points to sectional references (form configuration, subscriptions, validation, etc.) so agents apply changes consistently rather than one-off tweaks. It complements ship-phase review by catching structural RHF mistakes early, but its canonical home is active frontend build work.1.3kinstalls4Emilkowal Animationsemilkowal-animations is an agent skill that encodes Emil Kowalski’s web motion philosophy into 58 actionable rules spanning eight categories, ordered by user-perceived impact from critical easing and timing through polish techniques like blur bridging and stagger. Solo builders shipping SaaS dashboards, marketing sites, or component libraries install it when an AI agent might default to linear transitions, mismatched durations, or layout-breaking transforms. Each rule follows a consistent template: why the choice matters for feel, a realistic incorrect snippet, a minimal-diff correct fix, optional alternatives, explicit anti-patterns, and curated references to Emil’s writing and open-source work. A Tailwind v4 section bridges principles to day-to-day utility configuration. Use it during UI build-out, before launch polish, or when debugging janky interactions—not as a substitute for accessibility or reduced-motion requirements, but as a structured checklist so motion stays cohesive across pages.1.3kinstalls5VitestVitest is a community dot-skills package that turns Vitest best practices into a machine-readable rulebook for agents and solo builders maintaining JavaScript and TypeScript projects. Version 1.0.0 organizes forty-four rules into eight categories, with the highest priority on async patterns and test isolation—where false positives and flaky suites usually hide. Each rule explains why it matters, shows wrong versus right patterns, and cites impact so an LLM can generate new tests, refactor legacy suites, or review PRs without reinventing Jest-era habits that break under Vite’s runner. Use it when you adopt Vitest on a Vite app, when flaky CI starts failing intermittently, or when you want consistent test structure across frontend and lightweight backend modules. It complements your test runner config; it does not replace e2e tooling or production monitoring.1.1kinstalls6Nuqsnuqs is a community best-practices skill for type-safe URL query state in Next.js, React Router, TanStack Router, Remix, and plain React. Solo builders reach for it when filters, tabs, or table state must live in the address bar without breaking Server Components, hydration, or performance. The guide orders 46 rules into eight impact tiers—from parser correctness and adapter setup through server integration and debounced URL updates—so agents generate and refactor nuqs code consistently instead of inventing ad-hoc searchParam plumbing. Use it while implementing new features in the build phase, and again during ship when reviewing PRs that touch useQueryState or shared parsers. It does not replace nuqs docs entirely but compresses recurring mistakes (wrong parsers, missing adapters, noisy history updates) into a review checklist your agent can enforce across the stack.995installs7TypescriptThis TypeScript skill is a curated performance and quality guide for solo builders who rely on agents to write or refactor large TS codebases. It packages forty-five rules across eight impact tiers—from critical type-system and compiler-configuration choices down to advanced patterns—each with a short rationale, wrong versus right examples, and measurable impact framing so automated edits do not silently regress build times or bundle size. Topics include async patterns, type-definition hygiene, module organization, and handling modern compiler flags introduced in TypeScript 5.5 and 5.8. Install it when Copilot-style generation produces verbose types, circular imports, or slow incremental builds, and you want a checklist the agent can follow instead of generic lint advice. It complements ESLint but focuses on performance implications agents often miss. Intermediate familiarity with tsconfig and bundlers helps; beginners can still use it rule-by-rule during code review passes in Ship.979installs8Code SimplifierCode Simplifier is a procedural agent skill that turns cleanup and refactoring requests into disciplined, behavior-preserving changes. It encodes community best practices as 47 rules across eight categories, from critical context discovery and behavior preservation through incremental language idioms. Solo and indie builders install it when an agent is asked to simplify code, improve readability, reduce complexity, or polish recent edits without changing what the program does. The skill stresses reading project conventions first, limiting scope to touched areas, and preferring explicit structure over terse cleverness. It pairs well with post-feature edits and pre-merge polish on SaaS backends, CLIs, and app codebases where agents otherwise over-refactor or silently change semantics. Triggers align with simplification, refactoring patterns, readability improvements, and cleanup of recent changes.916installs9Expo React Native PerformanceExpo React Native Performance is a dense agent skill that encodes forty-two optimization rules across eight categories for Expo-based mobile apps, ordered from critical startup and list virtualization fixes to incremental platform tuning. Each rule pairs incorrect and correct implementations with stated impact so a solo builder—or their agent—can prioritize Hermes, splash-screen preloading, production console stripping, async route splitting, and memoized list items without guessing tradeoffs. The document targets February 2026 Expo workflows and assumes automation-first refactors rather than casual reading. Invoke it when shipping feels slow, scroll jank appears, or bundle size balloons after feature growth. It complements feature skills by giving a measurable checklist rather than one-off tips, making perf work repeatable across releases.783installs10Wxt Browser Extensionswxt-browser-extensions is a performance rule pack for solo and indie builders shipping Chrome and Firefox extensions with the WXT framework. It organizes forty-nine guidance cards across eight categories—from service worker lifecycle and content script injection through TypeScript and incremental optimizations—each with impact tiers, anti-pattern code, corrected implementations, and exception notes. Install it when your agent is scaffolding or refactoring an MV3 extension and you want consistent, citeable decisions instead of ad-hoc Stack Overflow fixes. The guide is tuned for WXT 0.20+ APIs, so agents avoid outdated polyfill and import patterns. It fits naturally while you are still in Build on popup, options, and injection surfaces, and it remains valuable in Ship when you are chasing cold-start time, memory, and store-review readiness before listing.654installs11ShadcnShadcn is an agent skill encoding shadcn/ui community best practices—formerly shadcn-ui—for installing, composing, and reviewing React components built on Radix and Tailwind. Solo builders shipping SaaS dashboards or marketing sites with Claude Code, Cursor, or Codex use it when writing new primitives, wiring forms with React Hook Form and Zod, building data tables, or auditing accessibility and theme tokens. The guide orders 58 rules across ten categories from critical setup and architecture through styling, forms, layout, and data display so automated refactors prioritize impact. Reference it during code review or generation whenever tasks mention component composition, dark mode, or performance-sensitive lists. It reduces rework from broken a11y behaviors, inconsistent tokens, and ad-hoc form validation. This is procedural frontend knowledge packaged as a skill, not a hosted UI kit replacement—you still run the shadcn CLI in your repo.603installs12Framer MotionFramer Motion is a community performance playbook packaged as an agent skill for solo builders shipping React interfaces with motion. It should be invoked whenever you write, review, or refactor animations built with Framer Motion—motion components, gestures, shared-element layout, scroll-linked effects, and SVG motion—not for choosing animation libraries from scratch. The guide ranks forty-two rules across nine categories from critical bundle and re-render issues down to exit and SVG nuances, so agents fix the highest-impact problems first instead of tuning springs prematurely. Indie teams benefit because animation-heavy marketing sites and SaaS dashboards are common failure points for jank and bundle bloat; applying the checklist during implementation and before release reviews keeps interactions crisp without a dedicated performance engineer. Pair it with your normal React workflow: load the skill when a task mentions Framer Motion, layout animation, or scroll/gesture performance, and let the agent align code with the prefixed rule families.598installs13Terminal UiTerminal-ui is a procedural agent skill for solo and indie builders shipping TypeScript command-line and developer tools. It encodes DevEx-oriented Terminal User Interface guidance for Ink—React rendered in the terminal—and @clack/prompts interactive flows. The skill organizes forty-two rules into eight impact-ordered categories, starting with rendering and output and input and keyboard as critical priorities, then component patterns, state and lifecycle, prompt design, UX feedback, configuration, and robustness. You reach for it when tasks mention TUI components, CLI prompts, terminal rendering, keyboard input, or developer tooling quality, not when you only need a one-off print statement. Reference it while designing refactors or generating new prompt wizards, setup flows, and agent-adjacent CLIs so output stays stable, interactions stay predictable, and users get clear feedback. It complements generic TypeScript linting by focusing on terminal-specific failure modes like flicker, focus order, and prompt ergonomics that break trust in local tools.593installs14Chrome ExtensionChrome Extensions is an agent skill aimed at solo builders shipping browser tools on Manifest V3. It packages a Chrome Developer Relations–style performance playbook: more than forty rules grouped into eight categories, ordered from critical service worker lifecycle mistakes to incremental API habits. Each rule contrasts wrong and right implementations and calls out realistic impact, such as memory wasted on artificial keep-alive or state lost when globals disappear on worker termination. Use it when an agent is scaffolding a new extension, auditing an existing repo, or refactoring content scripts and message passing for production. It fits the build phase heavily but also supports ship when you are hardening performance before release. The skill does not replace Chrome Web Store policy reading or security review; it keeps engineering choices aligned with how MV3 actually runs in users’ browsers so your extension stays responsive and recoverable after sleep.591installs15Clean CodeClean Code is a journey-wide agent skill packaging Robert C. Martin's craftsmanship handbook as machine-reviewable rules for solo builders who lean on Claude, Codex, or Cursor for most implementation. It encodes 48 concrete rules spanning naming clarity, small functions, meaningful comments, consistent formatting, error handling, object boundaries, class cohesion, test discipline, and simple design heuristics. Every rule contrasts anti-patterns with corrected samples and lists when the pattern should be skipped, which keeps agents from over-applying dogma. Examples skew Java but the intent is technology-agnostic software design. Reach for it whenever you are reviewing a PR, refactoring a module that grew messy, or coaching an agent to stop generating 200-line functions. It compounds maintainability for one-person codebases that will be re-read in six months without context.584installs16Ui DesignUI Design is an agent-oriented UI/UX best-practices skill versioned for January 2026 automation. It packages forty-two rules in eight categories, ranked from critical accessibility and Core Web Vitals concerns down to incremental polish like animation performance. Each rule links to reference material with explicit wrong versus right implementations and stated impact, so Claude Code, Cursor, or Codex can audit or generate components without drifting from WCAG-minded patterns. Solo builders shipping SaaS dashboards, marketing sites, or extensions use it when refactoring legacy markup, scaffolding new flows, or answering review comments about focus order and touch targets. The skill is prescriptive checklist knowledge, not a Figma handoff or brand workshop. Expect agents to cite category priority when tradeoffs appear—accessibility and measurable performance before decorative motion. Keep your stack constraints in the user prompt; the skill encodes cross-framework UX law more than a single CSS framework API.563installs17React RefactorReact Refactor is an agent skill that packages an architectural refactoring guide for React applications at version 1.1.0. Solo and indie builders shipping SaaS or content sites with Claude Code, Cursor, or Codex invoke it when the codebase shows classic smells: props explosion, type-based folder sprawl, deep render-prop nesting, or client components placed too high in the tree. The skill walks through seven rule categories—component architecture, state, hooks, decomposition, coupling, data and side effects, and refactoring safety—with concrete indicators and transforms. It is meant as structured procedural knowledge during active development or pre-merge cleanup, not as a greenfield scaffold generator. Using it before large feature work or during ship-phase review helps turn ad-hoc JSX edits into repeatable, safer structural improvements aligned with modern React patterns.562installs18Chrome Extension UiChrome-extension-ui is a community design guide (v0.1.0, January 2026) packaged as an agent skill so Claude Code, Cursor, and similar tools follow the same Manifest V3 UX standards when building or refactoring browser extensions. It spans eight categories—component selection, accessibility, layout, and more—with forty-two prioritized rules, each illustrated with wrong vs right implementations and impact notes (for example side panel for persistent tasks, minimal permissions for install conversion, single purpose for store approval). Solo builders shipping extensions invoke it during UI generation, code review, or refactors rather than improvising popup patterns, permission prompts, and action tooltips from general web dev habits. The document explicitly targets automation: agents should treat it as the source of truth for extension-specific HCI. It complements generic frontend skills by anchoring Chrome platform constraints, Web Store policy undertones, and extension-native surfaces.547installs19Shellshell is a community best-practices skill that gives AI agents a structured checklist for safe, portable bash and sh scripts. Solo builders lean on it whenever shell is the glue: local dev scripts, Docker image builds, GitHub Actions steps, cron maintenance, or systemd services. The guide spans forty-nine rules in nine categories, weighted from critical safety and portability through quoting, variables, performance, and style. Each rule pairs wrong and right patterns so reviews are actionable rather than vague “use quotes” advice. Reference it while authoring new scripts, auditing PRs for injection and silent failure risks, debugging inconsistent behavior across macOS and Linux, or tightening CI recipes that only fail deep in the pipeline. It does not replace running ShellCheck in CI, but it steers agents toward the same class of defects before merge.533installs20Typescript Refactortypescript-refactor packages principal-level TypeScript and TSX guidance for AI agents refactoring real codebases. Solo builders maintaining React 19 frontends or shared TS libraries get a structured rulebook—nine categories, forty-seven rules—so refactors improve type safety and check speed instead of introducing subtle breaks. Critical rules push interface extension over heavy intersections, readonly-by-default data shapes, and disciplined narrowing; high-impact sections cover builder patterns without Partial abuse and modern syntax aligned with TypeScript 6.0 erasable and declaration emit constraints. Use it during active feature work, pre-release review, or when iterating on legacy components that need React 19 typing upgrades. It is not a substitute for greenfield framework tutorials or non-TypeScript stacks.531installs21MswMSW is a comprehensive Mock Service Worker v2 guide packaged as an agent skill for solo and indie builders who mock HTTP APIs during local development and automated tests. It targets Claude Code, Cursor, Codex, and similar agents that need consistent, repo-wide rules instead of one-off mock snippets. Use it when you are adding MSW to a new app, upgrading to v2, or refactoring handlers and test setup so mocks behave like production traffic without standing up a full backend. The skill emphasizes critical setup steps—version-controlled worker scripts, isolated test lifecycles, strict TypeScript configuration, and explicit handling of unhandled requests—because those choices prevent the most common CI failures and flaky suites. It also spans handler design and debugging with impact-prioritized rules so agents can generate or refactor codebases with measurable quality gates. The document is written for automation-first workflows while remaining readable for humans who want a structured MSW playbook.518installs