dot-skills
Over 200 skills by stack and practice: React, Next.js, Rails, Rust, Python, debugging, TDD and UI review
- 221 ★ on the repository
- Last commit
- MIT
Minimal access
Why this level
- Most skills are reference instructions; a few, such as `nuqs-codemod-runner`, rewrite project code, and the result is reviewed in the diff
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/dot-skillsDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewMinimal accessThe tool runs nothing and makes no network calls.
- Most skills are reference instructions; a few, such as `nuqs-codemod-runner`, rewrite project code, and the result is reviewed in the diff
This is third-party code. Review the repository files before installing.
What it does
dot-skills is a collection of skills in the open Agent Skills format. The `skills/.curated/` folder holds more than forty vetted ones: React 19, Next.js 16, Tailwind v4, TanStack Query v5, Zod, shadcn/ui, Playwright and Vitest, Rails and Ruby, Python 3.11+, Rust (implementation, refactoring, tests), Expo and SwiftUI, plus debugging, TDD, refactoring after the Fowler catalog and UI design review. The library skills are written as rule lists ranked by impact; for example, `debug` holds 54 rules in 10 categories. `skills/.experimental/` holds more than 160 work-in-progress skills, from the Twelve-Factor App and 37signals Rails principles to Uncle Bob acceptance test pipeline. You can install every skill at once, browse the list with `--list` or pick one with the `--skill` flag.
Who it is for. Developers on React, Next.js, Rails, Rust and Python who want to hand an agent narrow references on libraries and practices as separate skills.
Good fit when
- A Next.js 16 project with TanStack Query where the agent writes queries and caching with outdated habits
- A bug has no explanation, and you need methodical debugging with rules ranked by impact: the `debug` skill
- Rust code is due to be split into modules or covered with tests using the what-could-break scheme
- A React or Tailwind interface needs a structured design review
- A migration to nuqs v2.5 and newer: `nuqs-codemod-runner` exists for it
Not a fit when
- You need one ready process from idea to release: the collection skills are independent and not chained
- The technology you need is in neither the curated nor the experimental skills
- The agent context is already crowded with descriptions: installing without `--skill` puts every skill into the project
Example request
Debug this error with the debug skill: reproduce it first, then find the root cause and show which rules you appliedLimitations
The collection has no single release: skills live in `skills/.curated/` and `skills/.experimental/`, and the set changes between commits. The `.experimental` folder holds work in progress rather than polished material. The descriptions and rules are in English. The `add-skill` installer from Vercel runs through `npx`, so Node.js is needed. Some skills, for example `nuqs-codemod-runner`, rewrite project code by script, and their result is worth reading in the diff before committing.
How to disable. Delete the folder of the skill from the agent skills directory: `.claude/skills/<name>/`, `.cursor/skills/<name>/`, `.codex/skills/<name>/` or `.opencode/skill/<name>/`. For a global install the same applies in the home directory.
FAQ
How do I install a single dot-skills skill?
Run `npx add-skill pproenca/dot-skills --skill debug`, substituting the name of the skill you need. `npx add-skill pproenca/dot-skills --list` prints the names, and the `--global` flag installs the skill for all projects.
Which directories do the skills go into?
For Claude Code it is `.claude/skills/<name>/`, for Cursor `.cursor/skills/<name>/`, for Codex `.codex/skills/<name>/`, for OpenCode `.opencode/skill/<name>/` and for Antigravity `.agent/skills/<name>/`.
How do curated skills differ from experimental ones?
The curated ones in `.curated/` are called vetted and production-ready, the experimental ones in `.experimental/` are work in progress. The README opens with tables of both groups with short descriptions.
What is inside a typical skill?
A required `SKILL.md` with the description and rules and, where needed, a `scripts/` folder with executables, `references/` with documentation and `assets/` with static resources. The Agent Skills format defines the structure.
How do I add my own skill to the collection?
Copy the template with `cp -r skills/.template skills/my-skill`, rename `SKILL.md.template` to `SKILL.md`, fill in the description and instructions, then test with `npx add-skill . --list`. Contribution rules are in `CONTRIBUTING.md`.
Discussion
No questions or reviews yet.
Related
SkillsA code review skill across many languages and frameworks: architecture, performance, security, anti-patterns and common bugs
A skills collection filtered and verified by JetBrains: Kotlin, Spring, Vue, deployment, documents and Google Workspace.
Mindrally skills collection
Claude Code Skills Collection
Over two hundred coding-guideline skills for frameworks and languages, converted from Cursor rules to SKILL.md
A set of independent skills against drift in large codebases: hard-cut, root-cause tracing, lean testing and CI right-sizing.
Catalog of 46 versioned skills for code review, releases, CI and landing pages, installed as the lstack plugin or through npx.
88 skills in three folders: the author's own for Go, React and code review, hand-picked third-party ones and 13 on marketing and pitching
README in short
The README opens with two tables of skills with short descriptions: curated and experimental. It then covers installing through `add-skill` with examples for all skills, a single skill and global mode, a table of directories per agent, the steps to create a new skill and the folder structure.
README badge
Original SKILL.md
--- name: debug description: Comprehensive debugging methodology for finding and fixing bugs (formerly debugging). This skill should be used when debugging code, investigating errors, troubleshooting issues, performing root cause analysis, or responding to incidents. Covers systematic reproduction, hypothesis-driven investigation, and root cause analysis techniques. Use when encountering exceptions, stack traces, crashes, segfaults, undefined behavior, or when bug reports need investigation. --- # dot-skills Debugging Best Practices Comprehensive debugging methodology guide for software engineers, containing 54 rules across 10 categories prioritized by impact. Based on research from Andreas Zeller's "Why Programs Fail" and academic debugging curricula. ## When to Apply Reference these guidelines when: - Investigating a bug or unexpected behavior - Debugging code during development - Code produces wrong results or crashes - Performance issues need root cause analysis - Triaging incoming bug reports and prioritizing fixes - Conducting root cause analysis for incidents - Reviewing debugging approaches or code for common bug patterns ## Rule Categories by Priority | Priority | Category | Impact | Prefix | |----------|----------|--------|--------| | 1 | Problem Definition | CRITICAL | `prob-` | | 2 | Hypothesis-Driven Search | CRITICAL | `hypo-` | | 3 | Observation Techniques | HIGH | `obs-` | | 4 | Root Cause Analysis | HIGH | `rca-` | | 5 | Tool Mastery | MEDIUM-HIGH | `tool-` | | 6 | Bug Triage and Classification | MEDIUM | `triage-` | | 7 | Common Bug Patterns | MEDIUM | `pattern-` | | 8 | Fix Verification | MEDIUM | `verify-` | | 9 | Anti-Patterns | MEDIUM | `anti-` | | 10 | Prevention & Learning | LOW-MEDIUM | `prev-` | ## Quick Reference ### 1. Problem Definition (CRITICAL) - `prob-reproduce-before-debug` - Reproduce the bug before investigating - `prob-minimal-reproduction` - Create minimal reproduction cases - `prob-document-symptoms` - Document symptoms precisely - `prob-separate-symptoms-causes` - Separate symptoms from causes - `prob-state-expected-actual` - State expected vs actual behavior - `prob-recent-changes` - Check recent changes first