
delete-comment
Purge comments from a codebase: classify each as tautology, stale, excuse, or decision record; delete them, file issues for excuses, and move decisions into ADRs or tests; then measure the lines removed. Keeps tool directives and license notices, and deletes only behind a code-token check. Use when asked to delete or audit every comment in a codebase or directory, move comment rationale into ADRs, or estimate the lines saved.
- version
- 1.0.0
- GitHub stars
- 27
Add marketplace
/plugin marketplace add dashed/claude-marketplaceRun it inside Claude Code once, then install the plugin below.
Install
/plugin install delete-comment@alberto-marketplaceRun it inside Claude Code after adding the marketplace.
Files
Discovered from sourceDelete Comment
This skill removes the comments a codebase does not need and keeps the facts that some comments carry. It runs in four phases:
- Inventory every comment with a lexer and measure the lines a purge would remove.
- Classify each comment as a tautology, stale, an excuse, or a decision record.
- Act: delete tautologies and stale comments, file an issue for each excuse, move each decision record into code, a test, or an ADR, then delete those comments too.
- Report the measured result.
The scanner, scripts/comments.py, does the mechanical work: it finds comments with a real lexer, keeps the comments that tools read, deletes only what the verdicts allow, and checks that no code token changed. You do the judgment: what each comment is, and where its fact goes.
The policy
| Category | The comment… | Action |
|---|---|---|
| Tautology | says what the code already says: a name, a type, the next line, a section divider | Delete |
| Stale | is false now: it names code that moved, describes old behavior, or is commented-out code | Delete |
| Excuse | admits or excuses a defect: TODO, FIXME, HACK, "workaround", "for now", "not ideal", "legacy" | File an issue, then delete |
| Decision record | states a non-obvious decision or an outside fact that a change must respect | Encode it in code or a test if you can; otherwise write an ADR. Then delete |
Apply the tests in this order, and take the first that fits:
- Stale? A false comment carries nothing worth keeping, even if it reads like a decision or an excuse. Check the claim against the code before you trust it.
- Excuse? The comment says the code should change. The issue must exist before the comment goes, because the comment is the only record of the defect.
- Decision record? The comment says the code must not change, although it looks wrong: a guard, an ordering, a retry count, a format an outside system requires. Its fact must land in code, a test, or an ADR before the comment goes.
- Otherwise it is a tautology.
The test between the two hard categories: an excuse says this should be different; a decision record says this must stay as it is. "Sleep 2 s because the ready event is not wired up yet" is an excuse. "Sleep 2 s: the vendor rate-limits bursts and returns 429 without a Retry-After" is a decision record.
What the scanner keeps without a verdict
Some comments are read by tools, so deleting them changes behavior. The scanner gives them the kind directive or license and never deletes them:
- shebangs, encoding cookies, editor modelines, PEP 723
# /// scriptblocks - lint, type-check, format, and coverage directives:
noqa,type: ignore,pyright:,eslint-disable,@ts-expect-error,prettier-ignore,fmt: off,pragma: no cover,istanbul ignore,NOLINT,nolint,shellcheck disable=,rubocop:disable, and more - compiler and build directives:
//go:build,//go:generate,{-# LANGUAGE … #-},/// <reference …>,/* @__PURE__ */,// fallthrough, Fortran!$omp - secret-scanner allowances (
gitleaks:allow,pragma: allowlist secret,nosec), Makefile##help text, Dockerfile parser directives - copyright and license notices; the MIT and Apache licenses require that they stay with copied code
The list errs toward keeping. A false directive keeps one comment; a missed directive deletes something a tool needs. Pass a repository's own directives with --allow REGEX.
Two other things stay out of scope by default:
- Docstrings are string literals, not comments.
help(), Sphinx, doctests, and CLI frameworks read them at run time. - Doc comments (
/** */,///,//!, Go comments on declarations,@paramblocks) feed IDE hovers and generated API docs. The scanner reports them as kinddoc. Include them only when the user asks; then classify them like plain comments.
Phase 0: Settle the run
Detect what you can and propose defaults. Ask the user only about the rest, in one message:
| Setting | How to detect it | Default |
|---|---|---|
| Scope | the user's words | the whole repository |
| Doc comments | the user's words | keep them |
| Issue tracker | gh repo view, Linear tools, the tracker named in CONTRIBUTING | ask |
| ADR directory | docs/adr, doc/adr, docs/decisions, docs/architecture/decisions, adr | docs/adr/ |
Filing issues publishes text outside the repository, so confirm before you file. Commit only when the user asks.
Phase 1: Inventory and estimate
Define a shell function once, so the command works in bash and zsh. --no-config keeps the target repository's uv settings out of the script's own dependency install:
comments() { uv run --no-config --script "<this skill's directory>/scripts/comments.py" "$@"; }
work=$(mktemp -d) # inventory, verdicts, and issue drafts live here
comments estimate src tests # the numbers, before any edit
comments inventory src tests > "$work/comments.jsonl"
comments inventory src --format tsv | less # a skimmable view
Keep the working files outside the repository, so they do not land in the change. Run the commands from the repository root, and note the paths you scan: Phase 4 measures the same paths. --exclude GLOB skips paths, and --language NAME limits the scan to one pygments language; both repeat.
Without uv, python3 scripts/comments.py works when pygments is installed.
Give the user the estimate first: it answers "how many lines will this remove" before any work. Report the numbers as the scanner states them:
- Comment-only lines are the lines a purge removes. A trailing comment (
x = 1 # why) shortens a line but removes none. - Code lines do not change. Line counters that skip comments (cloc, tokei, most SLOC metrics) report the same code size after the purge. Do not present comment lines as code shed.
- Check the "skipped as generated" list. A hand-written file with "DO NOT EDIT" near the top is skipped too; exclude it on purpose or fix the marker.
- Check the language list. Configuration files (YAML, TOML) are in scope by default; leave them out with
--excludeor--languageif the user wants code only.
Phase 2: Classify
Classify every plain item in $work/comments.jsonl (and every doc item if doc comments are in scope). For each item:
- Read the code it sits on: the enclosing function's signature and body, about 15 lines on each side. A comment that looks redundant in a list often guards a real constraint three lines down. Never classify from the comment text alone.
- Verify every claim it makes: search for the names it mentions, read the behavior it describes. A false claim makes it stale.
- Use the
hintsas leads, not verdicts:todoandexcusesuggest an excuse,codesuggests commented-out code,dividersuggests a tautology. - Review directive prose. An item with
"prose": trueis a directive with an explanation attached (# noqa: E501 # the URL cannot wrap). The directive stays; treat the explanation like a plain comment and edit it by hand if it must go. The scanner keeps every directive, even one that no longer suppresses anything; Ruff'sRUF100and ESLint's--report-unused-disable-directivesfind those.
Write one JSON line per verdict. Copy the inventory record and add category, plus ref and note where they apply:
{"id": "3f9c0a1b2c4d", "path": "src/billing.py", "category": "excuse", "ref": "", "note": "sleep stands in for the ready event"}
category is one of tautology, stale, excuse, decision, or keep. Use keep only when the comment must stay and the scanner missed why, such as a directive it does not know. Then pass a matching --allow pattern on later runs, so the scanner agrees.
Large scopes. Split the inventory by directory and give each part to a subagent with this brief: the policy table, the order of tests, the four steps above, and the verdict format. Then audit a sample of each part yourself. Check every tautology that sits on a guard, a lock, a retry, a sleep, a magic number, or an ordering, because those are usually decision records. Also check the evidence behind every stale verdict.
Then run comments estimate --verdicts "$work/verdicts.jsonl" and show the user the lines per category before you change anything.
Phase 3: Act
Excuses: file issues
- Draft every issue in one file before you file any. One issue covers one defect: merge the excuses that point at the same hack.
- Search the tracker for an existing issue first, and reuse it.
- Show the drafts to the user and file them after approval.
- Put the issue in the verdict's
ref: a URL,owner/repo#N,#N, a tracker key such asENG-341, or a file that holds the draft. Thedeletecommand refuses to delete an excuse without one.
Each issue states:
- what the code does now, and where: path, symbol, and a permalink at the commit before the purge (push it first, or the link breaks; without a remote, give the commit hash and the path)
- the comment, quoted word for word, because the purge removes it from the code
- the fix the comment implies, and what blocks it, if the comment or the history says
- the labels the tracker uses for tech debt
Decision records: encode or write an ADR
First try to move the fact into the code, where it cannot drift from what it describes:
- A name:
timeout_msinstead oftimeout # milliseconds;MAX_UPSTREAM_RETRIES = 2instead of2 # the vendor allows two. - A type: a
Centstype instead of# amounts are in cents. - An assertion that fails loudly when the assumption breaks.
- A test named for the decision, which fails if someone "simplifies" the guard away:
test_retries_stop_after_two_attempts_because_vendor_bans_the_third. This is the strongest home for a guard, a lock, or an ordering, because the test protects the behavior, not only its explanation.
Do not move prose into a string, an unused variable, or a log message. That is a comment in disguise.
When no name, type, or test can carry the fact, write an ADR. references/adr.md has the template, numbering, how to recover the decision's history with git, and how to keep ADRs findable once the code cannot point to them. Merge comments that record the same decision into one ADR. Once the comment is gone, nothing in the code points to the ADR, so add one line to the repository's AGENTS.md or CLAUDE.md (whichever exists; if neither does, create AGENTS.md): before changing a file, search the ADR directory for its path.
Put the ADR path, the path of the test or code that now carries the fact, or a URL in the verdict's ref. The delete command refuses to delete a decision record without a ref that exists.
Delete
comments delete --verdicts "$work/verdicts.jsonl" --dry-run
comments delete --verdicts "$work/verdicts.jsonl"
delete removes tautologies and stale comments, and excuses and decision records that have a ref. It removes a full-line comment with its line, and a trailing comment with the spaces before it. It never removes a directive or license item. Before it writes a file, it lexes the result again and requires the same code tokens; for Python it also requires the same AST. It leaves a file unchanged when either check fails, and it reports ids that no longer match because the file changed since the inventory.
Then run the repository's formatter, linter, type checker, and tests. When one fails because of a deletion, restore that file with git checkout -- <path>, find the comment the failure depends on, change its verdict to keep with a note that names the failure (or fix the code it was propping up), and run delete again. Watch for:
- Linters that read comments. ESLint's
no-emptyacceptscatch (e) { /* ignore */ }but rejects the empty block once the comment is gone. Fix the code (handle or log the error), not the linter. - Blank lines left behind. Removing a comment between two blank lines leaves two blank lines; the formatter collapses them.
- Languages pygments lexes imperfectly. The token check trusts the lexer. For languages other than Python, the build and the tests are the real proof.
Commits
Split the work so that each commit is easy to review:
- Comment deletions only. The diff touches nothing but comments; the token check guarantees it.
- Encodings: renames, new types, assertions, and tests. These change code, so review them as code.
- ADRs.
Phase 4: Report
Measure; do not repeat the estimate. Run comments estimate again on the Phase 1 paths and compare. Report:
- comment-only lines before and after, and the difference
- items per category: deleted, encoded, moved to an ADR, filed as an issue, kept
- the issues filed (links) and the ADRs written (paths)
- the comments left, by file, and why they are left (not yet classified, decision records waiting for an ADR, and so on)
- the checks run after the deletion (formatter, linter, tests) and their results
Later runs
This skill is the repeatable process. Run it again on the paths you scanned: the plain comments that remain are the worklist. To pin the repository's settings for the next run (the scope, the exclusions, the tracker, the ADR directory), add a short section to the repository's AGENTS.md or CLAUDE.md. If the team does not install this skill, write a repository-local skill instead, at .claude/skills/delete-comment/SKILL.md (or .agents/skills/ for other agents): the settings, the policy table, the order of tests, and the commands, run against a copy of scripts/comments.py in the repository (for example tools/comments.py), so it works without this skill.
Scanner reference
| Command | What it does |
|---|---|
inventory [PATH …] [--kinds plain,doc|all] [--format jsonl|tsv] | One record per comment item |
estimate [PATH …] [--verdicts FILE] [--json] | Lines per kind, the lines a purge removes, and lines per verdict category |
delete --verdicts FILE [--dry-run] | Delete what the verdicts allow, behind the token check |
Every command also takes --exclude GLOB, --allow REGEX, --language NAME (each repeatable), and --jobs N. Pass the same ones to every command in a run: --allow changes how comments group, and so their ids.
An inventory record has id, path, line, end_line, column, language, kind (plain, doc, directive, license), placement (full-line, trailing, inline), lines (the lines a delete frees), text, reason (why it is a directive, license, or doc comment), prose, and hints. Consecutive full-line comments at one indentation form one item. The id depends on the path, the text, and the order of identical comments in the file; edit a file and its ids can change, so run inventory again before delete.
The scanner skips binary, minified, and generated files, files over 2 MB, vendored directories (node_modules, vendor, third_party, virtual environments), files with no pygments lexer, and prose or data formats (Markdown, reStructuredText, text, JSON, XML, diffs). estimate reports what it skipped and why.
Related skills
- comment-slop judges comments one at a time in a diff or a pull request, and keeps the ones that carry a real why. Use it for review; use this skill for a repository-wide purge.
- doc-quality reviews the ADRs you write.
- linear, or
gh issue create, files the excuse issues. - test-audit checks that a test you write to carry a decision protects real behavior.
From the dashed/claude-marketplace README
Alberto's Claude Marketplace
A local marketplace for personal Claude Code skills and Codex repo-local skills.
A curated collection of Agent Skills for extending Claude Code and Codex capabilities. This marketplace is configured for local use and makes it easy to install and manage custom skills.
[!WARNING] This is Alberto Leal's personal Claude Code plugin marketplace. It is built solely for my own workflow, and I am the only intended and supported user. The skills and MCP servers here encode my personal conventions and assumptions, and may change, break, or disappear at any time without notice or migration path.
You are welcome to read, fork, or borrow from it — but if you are not me, use it entirely at your own risk. There are no support, stability, or backward-compatibility guarantees for anyone else.
Claude Code Quick Start
# 1. Add the marketplace
/plugin marketplace add /path/to/claude-marketplace
# 2. Install skills
/plugin # Browse and install plugins → alberto-marketplace
# 3. Restart Claude Code to load new skills
/exit
Codex Quick Start
Codex can read this repo as a local plugin marketplace. Generate Codex-native plugin manifests and the Codex marketplace file from the Claude marketplace metadata:
./scripts/sync_codex_plugins.py
# or
make sync-codex-plugins
Then restart Codex or start a new Codex thread from this repo root. Re-run the sync after editing .claude-plugin/marketplace.json, plugin skills, or MCP configs:
./scripts/sync_codex_plugins.py --check
# or
make check-codex-plugins
The sync writes .agents/plugins/marketplace.json, each plugin's .codex-plugin/plugin.json, and Codex-specific MCP configs when needed. Generated plugin versions include a content hash so Codex can see a new installable version after plugin files change.
The older direct skill symlink flow is still available when you want repo-local .agents/skills entries instead of installing plugins:
./scripts/install_codex_skills.py
For day-to-day toggling, use the interactive manager:
./scripts/manage_codex_skills.py
# or
make manage-codex-skills
Useful options:
# Preview changes without creating links
./scripts/install_codex_skills.py --dry-run
# Replace existing symlinks that point somewhere else
./scripts/install_codex_skills.py --force
# Install links into a personal Codex skills directory
./scripts/install_codex_skills.py --dest "$HOME/.agents/skills"
# List current Codex skill state
./scripts/manage_codex_skills.py --list
# Enable, disable, or uninstall individual skills
./scripts/manage_codex_skills.py --enable tmux
./scripts/manage_codex_skills.py --disable tmux
./scripts/manage_codex_skills.py --uninstall tmux
By default, the scripts manage .agents/skills/<skill> symlinks back to plugins/<skill>. disable removes only a managed repo symlink, and uninstall removes symlinked entries from the Codex skills directory. Real files and directories are reported as conflicts instead of being deleted.
To check and test the Codex scripts:
make test-codex-skills
opencode Quick Start
opencode has no marketplace concept — it discovers skills by recursively scanning configured paths for **/SKILL.md, and MCP servers from explicit mcp: entries in its config. There is no install script to run; you just point opencode at this repo.
Add an opencode block to your global config at ~/.config/opencode/opencode.json (or .jsonc):
{
"$schema": "https://opencode.ai/config.json",
// 1. Skills — recursive **/SKILL.md scan picks up every plugin under plugins/.
// 48 skill plugins are auto-discovered this way. The 4 MCP-only plugins
// (no SKILL.md) are skipped here and wired explicitly under "mcp" below.
"skills": {
"paths": ["/absolute/path/to/claude-marketplace/plugins"]
},
// 2. MCP servers — opencode does not auto-discover; one entry per server.
// ${CLAUDE_PLUGIN_ROOT} from each plugin's .mcp.json is NOT interpolated
// by opencode, so substitute an absolute script path. "command" is a
// single array of strings, not a separate program + args.
"mcp": {
"sequential-thinking": {
"type": "local",
"command": [
"uv", "run", "--no-config", "--script",
"/absolute/path/to/claude-marketplace/plugins/sequential-thinking/scripts/mcp_sequential_thinking.py"
]
},
"file-search": {
"type": "local",
"command": [
"uv", "run", "--no-config", "--script",
"/absolute/path/to/claude-marketplace/plugins/file-search/scripts/mcp_fd_server.py"
]
},
"fuzzy-search": {
"type": "local",
"command": [
"uv", "run", "--no-config", "--script",
"/absolute/path/to/claude-marketplace/plugins/fuzzy-search/scripts/mcp_fuzzy_search.py"
]
},
"sqlite": {
"type": "local",
"command": [
"uv", "run", "--no-config", "--script",
"/absolute/path/to/claude-marketplace/plugins/sqlite/scripts/mcp_sqlite_server.py"
]
}
}
}
Then quit and restart opencode — config is loaded once at startup and is not hot-reloaded.
opencode MCP dependencies
The 4 MCP servers share uv and otherwise split their deps:
| Server | Requires | Optional |
|---|---|---|
sequential-thinking | uv | DISABLE_THOUGHT_LOGGING=true env |
file-search | uv, fd, fzf | — |
fuzzy-search | uv, rg, fzf | rga (for fuzzy_search_documents), pandoc (for HTML→Markdown in extract_pdf_pages) |
sqlite | uv | MCP_SQLITE_ALLOW_WRITES=true env, --db-path <path> arg |
brew install uv fd fzf ripgrep ripgrep-all
uv fetches each server's Python deps (mcp, PyMuPDF) on first run via PEP 723 inline metadata — do not pip install them globally.
Notes
- Skill plugins (the other 48 directories under
plugins/) are picked up automatically by the recursive**/SKILL.mdscan; they need no per-plugin wiring. If a skill appears missing on next session, check that itsSKILL.mdhas a non-emptydescriptionin frontmatter — opencode filters out skills without one. - If you move this checkout, update the four absolute script paths under
mcpin lockstep. Theskills.pathsentry only needs the single parent directory. - For a curated subset of skills instead of all 48, symlink individual plugin dirs into
~/.config/opencode/skill/<name>/(opencode auto-loads~/.config/opencode/skill/*/SKILL.mdand~/.agents/skills/*/SKILL.md). - Per-project opencode config (
.opencode/opencode.jsonin a workspace) deep-merges over the global config, so you can override or extendskills.paths/mcpper project. - Full opencode config schema: https://opencode.ai/config.json.
Available Skills
| Skill | Description | Source |
|---|---|---|
| ai-friendly-cli | Build and refactor CLIs for AI agent compatibility. Use when making CLI tools machine-readable with structured JSON output, input hardening, schema introspection, dry-run safety, and MCP surfaces. | dashed |
| skill-creator | Create new skills, modify and improve existing skills, and measure skill performance. Use when creating, updating, evaluating, or optimizing skills. | Anthropic |
| skill-reviewer | Review and ensure skills maintain high quality standards. Use when creating new skills, updating existing skills, or auditing skill quality. Checks for progressive disclosure, mental model shift, appropriate scope, and documentation clarity. | dashed |
| agent-skill-init | Create a repo-local Agent Skill following the open agentskills.io specification. Use when the user wants to create, scaffold, or initialize a new skill in the current repo, mentions a 'repo-local skill' or the agentskills.io spec, or needs a spec-compliant SKILL.md placed under .agents/skills/ (or .claude/skills/). Scaffolds the directory, writes valid name/description frontmatter, and validates with skills-ref. | dashed |
| git-absorb | Automatically fold uncommitted changes into appropriate commits. Use for applying review feedback and maintaining atomic commit history. Tool: git-absorb | dashed |
| tmux | Remote control tmux sessions for interactive CLIs (python, gdb, etc.) by sending keystrokes and scraping pane output. Use when debugging applications, running interactive REPLs (Python, gdb, ipdb, psql, mysql, node), or automating terminal workflows. Works with stock tmux on Linux/macOS. | dashed |
| ultrathink | Invoke deep sequential thinking for complex problem-solving. Use when tackling problems that require careful step-by-step reasoning, planning, hypothesis generation, or multi-step analysis. Trigger with "use ultrathink". | dashed |
| conventional-commits | Format git commit messages following the Conventional Commits 1.0.0 specification. Use when creating git commits for consistent, semantic commit messages that support automated changelog generation and semantic versioning. | dashed |
| git-chain | Manage and rebase chains of dependent Git branches (stacked branches). Use when working with multiple dependent PRs, feature branches that build on each other, or maintaining clean branch hierarchies. Automates rebasing or merging entire branch chains. Tool: git-chain | dashed |
| jj | Jujutsu (jj) version control system - a Git-compatible VCS with automatic rebasing, first-class conflicts, and operation log. Use when working with jj repositories, stacked commits, revsets, or enhanced Git workflows. Tool: jj | dashed |
| fzf | Command-line fuzzy finder for interactive filtering. Use when searching files, command history (CTRL-R), creating interactive menus, or integrating with ripgrep, fd, and git. Shell keybindings: CTRL-T, CTRL-R, ALT-C, ** completion. Tool: fzf | dashed |
| playwright | Browser automation with Playwright for Python. Use when testing websites, taking screenshots, filling forms, scraping web content, or automating browser interactions. Uses uv with PEP 723 inline scripts for self-contained automation. Requires one-time browser setup (see below). Tool: Playwright | dashed |
| zellij | Terminal workspace and multiplexer for interactive CLI sessions. Use when managing terminal sessions, running interactive REPLs, debugging, or automating terminal workflows. Simpler alternative to tmux with native session management. Tool: Zellij | dashed |
| design-principles | Guide AI-assisted UI generation toward enterprise-grade, intentional design. Use when building UIs, creating dashboards, designing SaaS applications, or generating styled frontend code. Enforces 4px grids, typography hierarchies, and consistent depth strategies. | Dammyjay93 |
| mermaid-cli | Generate, validate, and fix diagrams from Mermaid markup using mmdc. Use when creating flowcharts, sequence diagrams, class diagrams, or converting .mmd files to images/SVG/PDF. Also validates and fixes Mermaid syntax. Tool: mermaid-cli | dashed |
| walkthrough-to-obsidian | Convert game walkthroughs and guides from plain text into structured, interlinked Obsidian markdown pages. Use when converting walkthroughs, FAQs, or reference documents into Obsidian vault pages. Supports agent team parallelization for large documents. | dashed |
| long-form-math | Write mathematics in a long-form, understanding-focused style with detailed proofs and rich exposition. Three-phase proof workflow, motivation-first exposition, and rigorous writing conventions. Inspired by Cummings' Real Analysis and Chartrand's Mathematical Proofs. | dashed |
| chrome-cdp | Interact with live Chrome browser sessions via Chrome DevTools Protocol. Use when inspecting, debugging, or interacting with pages open in Chrome — screenshots, accessibility trees, JS evaluation, clicking, navigating. Persistent per-tab daemon, works with 100+ tabs. Based on pasky/chrome-cdp-skill. Requires Chrome remote debugging (see below). | dashed |
| react-best-practices | React and Next.js performance optimization guidelines from Vercel Engineering. 62 rules across 8 categories covering waterfalls, bundle size, server-side, re-renders, and rendering. Use when writing, reviewing, or refactoring React/Next.js code. Source: vercel-labs/agent-skills | Vercel Engineering |
| linear | Managing Linear issues, projects, and teams. Use when working with Linear tasks, creating issues, updating status, querying projects, or managing team workflows. Tool: Linear SDK + MCP | wrsmith108 |
| gogcli | Drive Google Workspace from the terminal: Gmail, Calendar, Drive, Docs, Sheets, Slides, Chat, Tasks, Contacts, Admin, Keep, Forms, Classroom, Groups, Apps Script. JSON-first, multi-account, script-friendly. Use when sending mail, managing events, moving files, editing spreadsheets, or automating Workspace tasks. Tool: gogcli | steipete |
| pup | Datadog CLI (pup) for observability, monitoring, logs, APM, security, and infrastructure. Use when querying Datadog metrics, searching logs, managing monitors, investigating incidents, or performing Datadog API operations. 49 command groups, 300+ subcommands. Tool: pup | Datadog |
| style-extractor | Extract and document writing styles from source texts into reusable style guides. Four-phase workflow analyzing 17 style dimensions, producing a full style guide, voice card, do/don't checklist, and scoring rubric. Works with PDFs, documents, and any readable text. | dashed |
| style-writer | Write content using stored writing styles from the writing-styles/ collection. Discovers available styles, loads the right guide into context, applies it during writing, and self-evaluates against the style rubric. Companion to style-extractor. | dashed |
| anki-flashcards | Create and manage Anki flashcards via the AnkiConnect API. Use when creating flashcards, managing decks, reviewing statistics, or interacting with Anki. Comprehensive API reference covering 100+ actions, flashcard design best practices. Requires Anki with AnkiConnect add-on. Tool: AnkiConnect | dashed |
| statusline | Configure the Claude Code status line with VCS-aware scripts showing git branch, jj change ID, bookmarks, context usage, and costs. Use when setting up a statusline, customizing the status bar, or adding VCS info to the status line. | dashed |
| hledger | Plain-text double-entry accounting with hledger. Use when recording transactions, checking balances, generating financial reports, importing CSV bank statements, budgeting, tracking time, managing multiple currencies, or doing year-end closing. Tool: hledger | dashed |
| git | Advanced Git CLI mastery, recovery, and troubleshooting (git 2.54+). Use when recovering lost commits/branches/stashes (reflog, fsck), undoing a bad reset/merge/rebase, rewriting history (interactive rebase, filter-repo), resolving conflicts (rerere), or working with worktrees, bisect, cherry-pick, stash, refspecs, --force-with-lease, .gitattributes/hooks, git internals, or confusing git errors. Defers to conventional-commits, git-chain, git-absorb, and jj for their niches. | dashed |
| sequential-thinking | MCP server exposing a single sequentialthinking tool for dynamic, reflective, step-by-step problem-solving. Use when a task needs structured reasoning, planning, hypothesis generation, branching to explore alternatives, or revising earlier steps while keeping a running chain of thoughts. The marketplace's first MCP-server plugin. Requires uv. | dashed |
| file-search | MCP server exposing search_files (fd regex/glob) and filter_files (fzf fuzzy matching) tools for fast file-NAME discovery. Use when locating files by name or partial path — not for searching file contents. Requires uv, fd, and fzf. | dashed |
| fuzzy-search | MCP server exposing fuzzy content/file/document search tools (fuzzy_search_files, fuzzy_search_content, fuzzy_search_documents) built on ripgrep + fzf, plus PyMuPDF-backed PDF tools (extract_pdf_pages, get_pdf_outline, get_pdf_page_count, get_pdf_page_labels). Use when fuzzy-searching code/files/documents or inspecting/extracting PDF pages. Requires uv; rg+fzf (and rga for documents). | dashed |
| sqlite | MCP server exposing SQLite database tools (query, execute, list_tables, describe_table, create_table). Read-only by default; writes are opt-in via --allow-writes or MCP_SQLITE_ALLOW_WRITES=true. Use when inspecting, querying, or (when enabled) modifying SQLite databases. Requires uv. | dashed |
| fd | Fast, user-friendly command-line file/directory search with the fd tool (a simpler, faster find replacement). Use when searching for files/directories by name or regex/glob, filtering by type/extension/size/modified-time, respecting .gitignore, or running a command per result with -x/-X. Includes (fd X.Y+) version annotations + a version-features lookup. Tool: fd | dashed |
| ripgrep | Fast, gitignore-aware recursive content search with the ripgrep (rg) tool — a smarter, faster grep. Use when searching code/text for a regex across a tree, filtering by file type/glob, listing/counting matches, search-and-replace previews, or gitignore-aware code search. Includes (rg X.Y+) version annotations + a version-features lookup. Tool: ripgrep | dashed |
| fuzzy-filter | The non-interactive rg/fd/rga → fzf --filter pipeline — scan with a regex tool, then fuzzy-rank lines with no TUI (the CLI technique behind the fuzzy-search MCP). Use when fuzzy-matching paths, code lines, or PDF/document text from a script, or piping ranked results to xargs/an editor. Distinct from the fzf skill (interactive) and the fuzzy-search MCP (tool calls). Tools: ripgrep + fzf (+ rga for documents). | dashed |
| k3s | The k3s lightweight CNCF-certified Kubernetes distribution as a single binary (bundles containerd, flannel, CoreDNS, Traefik, ServiceLB, local-path-provisioner, metrics-server). Use when installing/running a lightweight cluster, bootstrapping single-node or HA control planes, joining agent nodes, choosing embedded etcd vs an external datastore, managing tokens, rotating certs, taking/restoring etcd snapshots, secrets encryption, airgap/private-registry installs, disabling bundled components, or upgrading. Includes (k3s vX.Y+) version annotations + a version-features lookup. Tool: k3s | dashed |
| teach | Run a Socratic teaching loop that quizzes you on a coding session until you've confirmed mastery of every concept. Use when you want to learn or lock in a Claude Code session, understand a transcript/PR/design decision, be quizzed on recent work, or prepare to teach someone else — or when the user runs /teach or asks to be taught or quizzed on a topic. Sources sessions from ~/.claude/projects/ and tracks a per-concept checklist until every item is confirmed. | alexknowshtml |
| ansible | ansible-core — the agentless, push-based SSH automation engine that runs idempotent tasks from declarative YAML playbooks. Use when writing/running playbooks, issuing ad-hoc commands, managing inventory, authoring roles, installing collections with ansible-galaxy, encrypting secrets with Ansible Vault, tuning ansible.cfg, or looking up docs with ansible-doc. Covers the ten ansible* CLIs, FQCN, become, variable precedence, and check/diff mode. Includes (ansible-core X.Y+) version annotations + a version-features lookup. Tool: ansible-core | dashed |
| obsidian-markdown | Create and edit Obsidian Flavored Markdown — the Obsidian-specific extensions on top of CommonMark/GFM: wikilinks ([[Note]]), block IDs, embeds (![[...]]), callouts (> [!type]), frontmatter properties, tags, comments, highlights, LaTeX math, Mermaid, and footnotes. Use when working with .md files in an Obsidian vault, or when the user mentions wikilinks, callouts, frontmatter, tags, embeds, or Obsidian notes. Ported from kepano's obsidian-skills (with minor local accuracy fixes). | |
| obsidian-bases | Create and edit Obsidian Bases (.base files) — the YAML format that turns notes into database-like table/cards/list/map views with filters, computed formulas, and summary aggregations. Use when working with .base files, building database-like views of notes, or when the user mentions Bases, table/card views, filters, or formulas in Obsidian. Ported from kepano's obsidian-skills (with minor local additions from the official docs); includes a complete per-type functions reference. | kepano |
| duckdb | DuckDB — the in-process, columnar OLAP SQL engine in a single zero-dependency binary ("SQLite for analytics"). Use when querying Parquet/CSV/JSON files directly with SQL, using the duckdb CLI shell (REPL or -c/-json one-shots for scripts/agents), writing friendly SQL (FROM-first, SELECT * EXCLUDE, GROUP BY ALL, SUMMARIZE, PIVOT), converting CSV↔Parquet↔JSON via COPY, reading HTTP/S3 data via httpfs, or ATTACH-ing a live Postgres/MySQL/SQLite database. Includes (duckdb vX.Y+) version annotations + a version-features lookup. Tool: duckdb | dashed |
| jq | jq — the command-line JSON processor and its filter language for filtering, transforming, and reshaping JSON. Use when extracting fields/nested paths on the CLI, select-ing arrays of objects, building new JSON, emitting CSV/TSV with @csv/@tsv, getting raw strings with jq -r, slurping (-s) and aggregating (add, group_by), NDJSON pipelines (-c), or injecting shell values with --arg/--argjson. Includes (jq 1.X+) version annotations + a version-features lookup. Tool: jq | dashed |
| psql | psql — PostgreSQL's interactive terminal client and SQL script runner. Use when connecting to or inspecting a Postgres database from a terminal, running SQL scripts or one-off queries in shells/CI/agents (-c/-f/-qAtX/--csv), using meta-commands (\d family, \copy, \watch, \gexec, \if scripting, \pset/\x, variables), .psqlrc, or fixing connection/auth problems. Includes (pgNN+) version annotations + a version-features lookup. Tool: PostgreSQL | dashed |
| postgres-sql | The PostgreSQL SQL dialect & data types that set Postgres apart from generic SQL. Use when writing or debugging Postgres-specific SQL — upsert (ON CONFLICT), RETURNING (incl. OLD/NEW), MERGE, CTEs, window frames, GROUPING SETS, LATERAL, generated/identity columns, declarative partitioning, jsonb/jsonpath/SQL-JSON (JSON_TABLE/IS JSON), arrays, ranges & multiranges, composite/enum/domain types, uuidv7()/gen_random_uuid(). Includes (pgNN+) version annotations + a version-features lookup. Tool: PostgreSQL | dashed |
| postgres-performance | PostgreSQL query & performance tuning — reading EXPLAIN/EXPLAIN ANALYZE plans, choosing & designing indexes, fixing planner row-estimate errors with statistics, and diagnosing MVCC bloat/VACUUM. Use when a query is slow, choosing an index type (btree/GIN/GiST/SP-GiST/BRIN/hash) or strategy (partial/expression/covering), autovacuum lags, or tuning planner GUCs (random_page_cost, work_mem, effective_cache_size). Includes (pgNN+) version annotations + a version-features lookup. Tool: PostgreSQL | dashed |
| postgres-admin | PostgreSQL server administration & operations (DBA work on a running cluster). Use when configuring a server (postgresql.conf, ALTER SYSTEM, GUCs), managing roles/privileges, authentication (pg_hba.conf, scram-sha-256), backup/restore (pg_dump, pg_basebackup, incremental, PITR), replication & HA (streaming, logical pub/sub, slots, failover), pg_upgrade, or monitoring (pg_stat_activity, pg_stat_io, pg_stat_progress_*). Includes (pgNN+) version annotations + a version-features lookup. Tool: PostgreSQL | dashed |
| postgres-extensions | PostgreSQL extension management and the bundled contrib catalog. Use when running CREATE EXTENSION/ALTER EXTENSION ... UPDATE/DROP EXTENSION, listing extensions (\dx), or choosing which contrib module enables a feature — FDWs (postgres_fdw, dblink), trigram/fuzzy search (pg_trgm, fuzzystrmatch), crypto/UUIDs (pgcrypto), hstore/ltree/citext/cube, query stats (pg_stat_statements, auto_explain), storage forensics (pageinspect, amcheck, pg_surgery). Covers trusted extensions & shared_preload_libraries. Includes (pgNN+) version annotations + a version-features lookup. Tool: PostgreSQL | dashed |
| kubernetes | Author and operate Kubernetes workloads with kubectl and YAML manifests — the kubectl CLI plus core resource authoring (Deployments, StatefulSets, Jobs/CronJobs, Services, Ingress, ConfigMaps/Secrets, PV/PVC, RBAC). Use when writing/debugging manifests, running kubectl (apply/diff/rollout/logs/exec/debug), fixing CrashLoopBackOff/Pending pods, managing contexts/namespaces, generating manifests with --dry-run=client, or checking RBAC with auth can-i. Includes (k8s 1.X+) version annotations + a version-features lookup. For installing/running a lightweight cluster see the k3s skill. Tool: kubernetes | dashed |
| uv | uv — Astral's fast Python package & project manager, one binary replacing pip/pipx/pyenv/poetry/virtualenv. Use when managing Python projects with pyproject.toml + uv.lock (uv init/add/sync/lock/run), running PEP 723 inline-dependency scripts, running one-off tools with uvx, installing/pinning Python versions (uv python), migrating from pip (uv pip), building/publishing packages, or configuring indexes/resolution/cache. Includes (uv 0.X+) version annotations + a version-features lookup. Tool: uv | dashed |
| handoff | Compact the current conversation into a handoff document for another agent to pick up. Use when ending a session with unfinished work, transferring context to a fresh agent or a new session, or approaching context limits. Saves timestamped docs to the OS temp dir, the workspace root with --workspace (auto-ignored via .git/info/exclude), or git-visible with --tracked (staged, commit+push offered for cross-machine transfer); follows a section template (decisions & rationale, dead ends tried, verify-state commands), suggests skills for the next agent, references artifacts instead of duplicating them, redacts secrets, and announces the path with a next-session starter. | mattpocock |
| pytest | pytest — the Python testing framework and the idioms that set it apart from unittest. Use when writing, running, debugging, or configuring pytest tests — plain assert (rewritten for rich introspection), dependency-injected @pytest.fixture (scopes/autouse/yield/conftest), @pytest.mark.parametrize, skip/skipif/xfail + custom markers, pytest.raises/warns/approx, builtin fixtures (tmp_path/monkeypatch/capsys/caplog), the CLI (-k/-m/-x/--lf/--pdb/node ids), config (pyproject.toml/pytest.ini, addopts, testpaths, --import-mode), and plugins/hooks (conftest.py, xdist/cov/asyncio/mock). Includes (pytest N.M+) version annotations + a version-features lookup. Tool: pytest | dashed |
| model-routing | Install and maintain a "model routing" section in a project's CLAUDE.md that teaches Claude Code which model to use for which work — a per-model cost/intelligence/taste rankings table with defaults-not-limits escalation rules, plus mechanics for reaching each model (Agent/Workflow model parameter for Claude models; codex exec for GPT models, including the thin-wrapper pattern for using Codex inside workflows and subagents). Use when setting up Codex/GPT as a delegation target or routing subagent work across models. Ships a customizable CLAUDE.md template and a verified codex exec flag reference. | dashed |
| code-walkthrough | Create a self-contained interactive HTML document that teaches a code change (branch, PR, diff, or subsystem) to a reviewer with no prior knowledge — before/after code toggles, mermaid diagrams, step-through code walkers, and playground widgets that mirror the logic under study. Use when the user wants to learn or review a code change interactively, asks for a walkthrough/teaching document of a branch or PR, or wants before/after explanations with visuals. Ships a generic HTML shell template (sidebar scrollspy, light/dark theme that also re-themes diagrams, syntax highlighting that keeps per-line diff colours, component library) and a 6-phase pipeline: extract (read-only agent fan-out) → verify claims → spiral structure → author fragments → browser-verify → deliver. | dashed |
| comment-slop | Find and remove AI-slop comments — ones that restate the code, describe another layer's behavior, or narrate planning that never shipped — while protecting the comments that carry real reasoning. Use when a reviewer calls a comment useless, unclear, or AI-written, when auditing comments and docstrings on a branch or PR, or before sending a change for review. Encodes a three-clause test (true at this layer, not already visible in the code, not stated better nearby), an eight-mode taxonomy with real examples and reviewer reactions (the eighth: comments that excuse a defect), a "what to keep" table with the asymmetry that a deleted rationale costs more than a bland comment, and a diff-scoped keep/rewrite/delete workflow. Includes why mechanically shortening comments makes slop worse. Repository-wide purges hand off to delete-comment. | dashed |
| delete-comment | Purge comments from a codebase or directory. Classifies every comment as a tautology, stale, an excuse, or a decision record; deletes it, files an issue for it, or moves its fact into a name, a type, a test, or an ADR; then reports the measured lines removed. Use when asked to delete or audit every comment in a codebase, move comment rationale into ADRs, or estimate the lines saved. Ships a pygments-based scanner that keeps tool directives and license notices and deletes only behind a code-token check, plus a reference for ADRs recovered from comments. | dashed |
| doc-quality | Review engineering Markdown designs, analyses, plans, and ADRs by section; static readability, preservation-inventory, and local link/anchor checks while the agent makes targeted, meaning-preserving edits | dashed |
| jj-hunk | Programmatic hunk selection for the jj (Jujutsu) VCS. Select individual diff hunks with a query language instead of an interactive TUI, then split, commit, squash, diffedit, restore, or absorb them. Use when splitting a jj commit, committing or squashing part of the working copy, undoing single hunks, or selecting changes by file/content/function/class. Documents the traps an agent hits silently: restore reads its ids from a reversed listing, absorb exits 0 when it refuses, and content-level predicates never reach binaries, symlinks, mode flips, pure renames or empty adds. Tool: jj-hunk | dashed |
| ruff | Astral's one fast (Rust) binary that is both a Python linter (ruff check) and a Black-compatible formatter (ruff format). Use when linting/formatting Python, configuring [tool.ruff]/ruff.toml, choosing rules with select/extend-select/ignore, looking up codes (F401/E501/B008), applying fixes (--fix, --unsafe-fixes), or suppressing (# noqa, # ruff: ignore[...]). Verified against ruff 0.16.3, incl. the 0.16 default-rule-set expansion (59 → 413) and preview gating. Tool: ruff | dashed |
| ty | Astral's extremely fast Python type checker and language server (beta). Use when running/configuring ty check, reading diagnostics, setting rule levels in [tool.ty]/ty.toml, writing # ty: ignore[rule] suppressions, debugging environment/module resolution, wiring ty into CI, or migrating from mypy/pyright. Pinned to ty 0.0.72. Tool: ty | dashed |
| oxlint | The extremely fast Rust JavaScript/TypeScript linter from the oxc project — an ESLint alternative needing no config to start. Use when linting JS/TS/JSX/Vue, writing .oxlintrc.json, selecting rules via plugins + categories, running --fix/--fix-suggestions/--fix-dangerously, or migrating from ESLint. Verified against oxlint 1.79.0. Tool: oxlint | dashed |
| oxfmt | The fast Rust formatter from the oxc project — a Prettier-compatible alternative for JS/TS/JSX plus JSON, CSS, YAML, TOML, GraphQL, Markdown and Vue. Use when formatting or checking with oxfmt, configuring .oxfmtrc.json, or migrating off Prettier/Biome. Pinned to oxfmt 0.64.0; note bare oxfmt rewrites files in place. Tool: oxfmt | dashed |
| jev | Consult Jev for typed second opinions on plans, evidence, and priorities; configurable providers, optional without a key | dashed |
| python-complexity | Two censuses of Python complexity, no project install: per function (ruff check --select C901 cyclomatic + complexipy cognitive, read as a pair) and per call path (hops, pass-through layers, selector parameters) for code where every function scores low but the path is hard to follow. Use when asking which functions to refactor first, whether a function or call path is too complex or over-layered, when triaging a legacy codebase, or when verifying a refactor reduced rather than relocated complexity. | dashed |
| test-sloc-cut | Shrink a test suite without losing an asserted fact or a covered branch: a fact matrix of what each test pins plus per-test branch coverage and a verified covering set, deleting only on the intersection, with a mutant check for every relocated fact. Use when asked to trim, dedupe, consolidate, or reduce tests or test SLOC, when a suite grew by accretion, when deciding whether to delete, fold, or parametrize tests, or before cutting a test on 'coverage is unchanged' alone. Python/pytest. | dashed |
| test-audit | Decide whether a test earns its place: an authoring gate for new and changed tests (what it protects, which regression fails it, why coverage misses it, no test-only production seams, regression tests proven red before the fix), low-value patterns (assertion-free tests, expected values from the code under test, duplicate bodies that hide a missing test, mocks that answer their own assertions, negative controls that pass for the wrong reason), a retention bar, and an evidence ledger before deletes. Use when writing or reviewing tests, when asked for a regression test, or when auditing a suite for junk tests or test-only production code. Ships a pytest smell scanner and a test-only-symbol finder; consolidation hands off to test-sloc-cut. Adapted from OpenClaw. | dashed |
| show-me | Explain the current topic visually with the smallest view that makes the point: pseudocode, a call tree, a component or file tree, a Mermaid diagram, a diff of the shape that changes, or one focused HTML page. Use when you ask to see the topic instead of reading about it ("show me", "diagram this", /show-me), not for ordinary explanations. | HumanLayer |
Chrome CDP Setup
The chrome-cdp skill requires Chrome with remote debugging enabled and Python 3.10+ with the websockets library:
# 1. Enable remote debugging in Chrome
# Navigate to chrome://inspect/#remote-debugging and toggle the switch
# 2. Install the websockets dependency
uv pip install websockets
Linear Setup
The linear skill requires Node.js dependencies and a Linear API key:
# 1. Install dependencies in the plugin cache directory
cd ~/.claude/plugins/cache/alberto-marketplace/linear/2.3.1
npm install
# 2. Create a Linear API key at https://linear.app/settings/api
# 3. Add to your shell profile (~/.zshrc or ~/.bashrc)
export LINEAR_API_KEY="lin_api_..."
Restart Claude Code after setup.
Playwright Setup
The playwright skill requires a one-time browser installation (~200MB). Claude will suggest these commands but will not run them directly—run them manually:
# Install Chromium (recommended, ~200MB)
uv run --with playwright playwright install chromium
# Or install all browsers
uv run --with playwright playwright install
Usage
Add this marketplace locally
/plugin marketplace add /path/to/claude-marketplace
Update the marketplace
/plugin marketplace update alberto-marketplace
Install skills
- Select
/pluginand thenBrowse and install plugins - Select
alberto-marketplace - Choose the skills to install
- Restart Claude Code
Install skills for Codex
./scripts/sync_codex_plugins.py
Codex can then discover the local plugin marketplace from .agents/plugins/marketplace.json when launched from this repository or one of its subdirectories.
For legacy direct skill links:
./scripts/install_codex_skills.py
To enable, disable, or uninstall skills interactively:
./scripts/manage_codex_skills.py
# or
make manage-codex-skills
Adding Skills to This Marketplace
Method 1: Add to Marketplace (Recommended)
- Add your skill directory to
plugins/ - Edit
.claude-plugin/marketplace.jsonand add a new entry:
{
"name": "your-skill-name",
"source": "./plugins/your-skill-name",
"description": "Brief description of what the skill does",
"strict": false,
"skills": ["./skills"]
}
Important: The skills field is required to load skills from the marketplace. It tells Claude Code which directories contain SKILL.md files.
- Update the CHANGELOG.md
- Commit your changes
- Re-run
./scripts/sync_codex_plugins.pyif you use Codex with this repo.
Method 2: Direct Installation
Skills can also be installed directly without using the Claude Code marketplace:
# Claude Code personal (available everywhere)
cp -r plugins/your-skill ~/.claude/skills/
# Claude Code project (shared with team)
cp -r plugins/your-skill .claude/skills/
# Codex repo-local links
./scripts/install_codex_skills.py
# Codex plugin marketplace metadata
./scripts/sync_codex_plugins.py
# Codex personal links
./scripts/install_codex_skills.py --dest "$HOME/.agents/skills"
# Codex interactive manager
./scripts/manage_codex_skills.py
Structure
claude-marketplace/
├── .agents/
│ ├── plugins/
│ │ └── marketplace.json # Generated Codex plugin marketplace
│ └── skills/ # Optional generated Codex symlinks
├── .claude-plugin/
│ └── marketplace.json # Marketplace manifest
├── plugins/
│ └── skill-creator/ # Plugin directory
│ ├── .codex-plugin/
│ │ └── plugin.json # Generated Codex plugin manifest
│ └── skills/
│ └── skill-creator/
│ ├── SKILL.md # Skill definition
│ ├── scripts/ # Optional scripts
│ └── references/ # Optional documentation
├── scripts/
│ ├── install_codex_skills.py # Codex symlink installer
│ ├── manage_codex_skills.py # Codex interactive manager
│ └── sync_codex_plugins.py # Codex plugin metadata sync
├── CHANGELOG.md # Version history
└── README.md # This file
Resources
- Claude Code Skills Documentation
- Plugin Marketplaces Guide
- Anthropic Skills Repository
- OpenAI Codex Skills Documentation
- OpenAI Codex Plugins Documentation
- OpenAI Skills Catalog
Version
Current version: 0.61.0
See CHANGELOG.md for version history.
Details
- Marketplace
- dashed/claude-marketplace
- Source
- plugins/delete-comment
- Author
- Alberto Leal
- Category
- Community
- License
- MIT
- Keywords
- comments, cleanup, adr, technical-debt, refactoring
More from dashed/claude-marketplace
All 66- design-principlesv1.0.0
- doc-qualityv1.2.0
- duckdbv1.0.0
- fdv1.0.0
- file-searchv1.0.2
- fuzzy-filterv1.0.2
- fuzzy-searchv1.3.2
- fzfv1.1.1
- gitv1.1.0
- git-absorbv1.1.0
- git-chainv1.0.0
- gogcliv1.0.0
- handoffv1.3.0
- hledgerv1.0.0
- jevv1.0.0
- jjv1.9.0
- jj-hunkv1.0.0
- jqv1.0.0
- k3sv1.0.1
- kubernetesv1.0.0
- linearv2.5.0
- long-form-mathv1.0.0
- mermaid-cliv1.0.0
- model-routingv1.1.0
Similar to delete-comment
More Development Tools
reamorluto/rea466.8K starsReverse engineer anything with agents, from app behavior down to native binaries.
superpowersobra/superpowers319.5K starsCore skills library for Claude Code: TDD, debugging, collaboration patterns, and proven techniques
claude-apianthropics/skills196.9K starsClaude API and SDK documentation skill for building LLM-powered applications
prompts.chatf/prompts.chat178.2K starsAccess thousands of AI prompts and skills directly in your AI coding assistant. Search prompts, discover skills, save your own, and improve prompts with AI.
agent-sdk-devanthropics/claude-code156.1K starsDevelopment kit for working with the Claude Agent SDK
ui-ux-pro-maxnextlevelbuilder/ui-ux-pro-max-skill152.6K starsProfessional UI/UX design intelligence for AI coding assistants. Includes searchable databases of styles, colors, typography, charts, and UX guidelines for Reac