writing

Plugin writing from marketplace claude-skills in nimadorostkar/Claude-Skills-collection. Commands read from the repo's manifest — 4 days ago.

Skills (137)

• agent-instructions

  Use when writing project instructions for a coding agent (CLAUDE.md, AGENTS.md, or equivalent). Covers what belongs in them, what does not, structure, and keeping them accurate as the project changes. Trigger on "write a claude.md for this repo", "set up agents.md", "the agent keeps running the wron

• agent-memory

  Use when an agent needs state that survives a session or a context compaction. Covers what to persist, file-based memory, structuring notes for retrieval, and preventing memory from becoming stale. Trigger on "agent forgets everything between sessions", "agent keeps retrying the same failed approach

• hooks

  Use when automating agent behavior with lifecycle hooks. Covers hook events, deterministic enforcement of rules the model should not be trusted to remember, and avoiding hooks that make an agent unusable. Trigger on "run prettier after every edit", "block rm -rf", "claude keeps forgetting to run tes

• plugin-development

  Use when packaging skills, commands, hooks, and MCP servers into a distributable plugin. Covers manifest structure, bundling, versioning, testing, and distribution through a marketplace. Trigger on "package my skills as a plugin", "publish to a plugin marketplace", "share our commands with the team"

• skill-authoring

  Use when writing a new skill for an AI agent. Covers scoping, description writing for reliable triggering, progressive disclosure, and the difference between a skill and a prompt. Trigger on "write a skill for", "turn this prompt into a skill", "create a skill.md", "how do i write a skill descriptio

• skill-review

  Use when reviewing or improving an existing agent skill. Covers triggering accuracy, content quality, redundancy with the base model, and measuring whether the skill actually changes behavior. Trigger on "my skill never triggers", "review this skill", "these two skills overlap", "audit our skill lib

• slash-commands

  Use when creating reusable slash commands for an agent. Covers when a command beats a skill, argument handling, composing tool calls, and writing commands that are worth typing. Trigger on "make a slash command for", "i keep typing the same prompt", "pass arguments to my command". Do not use for cap

• subagents

  Use when delegating work to a separate agent with its own context. Covers when delegation pays off, designing a subagent's scope and prompt, parallel fan-out, and the cost of a cold start. Trigger on "spin up a subagent for this", "run these searches in parallel", "the search results are flooding my

• agent-design

  Use when building an LLM agent that uses tools over multiple steps. Covers tool design, the agent loop, error recovery, termination, human checkpoints, and knowing when an agent is the wrong architecture. Trigger on "my agent keeps looping", "agent calls the wrong tool", "build an agent that can use

• context-engineering

  Use when managing what an LLM sees. Covers context-window budgeting, retrieval and compaction, memory across turns, tool-result pruning, and the failure modes that come from too much context rather than too little. Trigger on "model gets worse as the conversation gets longer", "context window keeps

• fine-tuning

  Use when considering fine-tuning a model. Covers when fine-tuning beats prompting or RAG, dataset construction, LoRA and full fine-tuning, evaluation, and the failure modes that waste the effort. Trigger on "should we fine-tune or just prompt", "fine-tune a small model to replace the big one", "prep

• llm-cost-optimization

  Use when an LLM feature costs too much. Covers prompt caching, context reduction, model routing, batching, output limits, and finding where the tokens actually go. Trigger on "our openai bill is too high", "llm costs are out of control", "where are all these tokens going", "set up prompt caching". D

• llm-evaluation

  Use when measuring the quality of an LLM feature. Covers building an evaluation set, choosing metrics, LLM-as-judge and its pitfalls, regression testing prompts, and evaluating in production. Trigger on "did my prompt change make it better", "build an eval set", "can i use an llm as a judge", "users

• llm-integration

  Use when integrating an LLM API into an application. Covers streaming, retries and rate limits, timeouts, caching, fallback across providers, and the production concerns that a tutorial integration ignores. Trigger on "add an llm to our app", "getting 429 rate limit errors from the api", "stream the

• mcp-server

  Use when building a Model Context Protocol server. Covers tool, resource, and prompt design, transport choice, authentication, error handling, and testing an MCP server against a real client. Trigger on "build an mcp server", "expose our api to claude", "the model keeps calling my mcp tool wrong". D

• ml-pipeline

  Use when building or operating a machine learning pipeline. Covers feature engineering, training reproducibility, train/serve skew, deployment, monitoring for drift, and retraining. Trigger on "model worked offline but fails in production", "training runs aren't reproducible", "detect data drift", "

• model-selection

  Use when choosing which LLM to use for a task. Covers matching capability to task, cost and latency trade-offs, routing between models, benchmark skepticism, and evaluating on your own data. Trigger on "which model should i use for this", "is the new model worth switching to", "route easy requests t

• prompt-engineering

  Use when writing or improving prompts for a language model. Covers instruction structure, examples, reasoning elicitation, output formatting, and systematically diagnosing why a prompt fails. Trigger on "improve this prompt", "the model ignores my instructions", "prompt works sometimes and fails ran

• rag

  Use when building retrieval-augmented generation. Covers chunking, embedding and hybrid search, reranking, grounding and citation, and diagnosing whether a bad answer is a retrieval failure or a generation failure. Trigger on "our rag keeps hallucinating", "chat with our docs", "retrieval returns th

• structured-output

  Use when an LLM must return machine-readable data. Covers schema design for models, native structured-output modes, validation and repair, and extraction that survives contact with messy input. Trigger on "llm returns invalid json", "extract fields from these emails", "classify tickets into fixed ca

• api-design

  Use when designing or reviewing an HTTP API. Covers resource modeling, status codes, pagination, idempotency, versioning, error formats, and the contract details that break clients when you get them wrong. Trigger on "design the endpoints for this", "what status code should this return", "how should

• background-jobs

  Use when designing asynchronous job processing. Covers queue selection, idempotency, retry and backoff policy, scheduling, poison messages, and observability for work that happens outside the request. Trigger on "move this to a background job", "emails are being sent twice", "the queue is stuck", "r

• caching

  Use when adding or debugging a cache. Covers cache placement, invalidation strategies, stampede protection, TTL selection, and the consistency you are trading away. Trigger on "add redis caching", "users are seeing stale data", "cache stampede after expiry", "should we cache this". Do not use for br

• django

  Use when building Django applications. Covers ORM query performance, model design, migrations, Django REST Framework, security defaults, and testing. Trigger on "django view is slow", "too many queries from the orm", "add a drf endpoint", "migration on a big table". Do not use for API contract decis

• event-driven-architecture

  Use when designing systems around events and message queues. Covers event schema design, delivery guarantees, idempotent consumers, ordering, dead-letter handling, and event sourcing. Trigger on "should we use kafka", "messages are processed twice", "consumer is stuck", "design the event schema". Do

• fastapi

  Use when building APIs with FastAPI. Covers dependency injection, Pydantic v2 validation, async database access, authentication, background tasks, and testing. Trigger on "fastapi endpoint is slow under load", "set up depends for the db session", "pydantic v2 validation error", "test my fastapi app"

• graphql

  Use when designing or operating a GraphQL API. Covers schema design, resolver performance and DataLoader batching, query cost limiting, error handling, and federation. Trigger on "graphql query is slow", "n+1 in my resolvers", "set up dataloader", "limit query depth on our graphql endpoint". Do not

• microservices

  Use when decomposing a system into services, or deciding whether to. Covers service boundaries, inter-service communication, distributed data, saga patterns, and the operational cost of the network. Trigger on "should we split the monolith", "extract this into a service", "our services are too coupl

• nestjs

  Use when building NestJS services. Covers module structure, providers and scopes, validation pipes, guards and interceptors, TypeORM/Prisma integration, and testing. Trigger on "nest can't resolve dependencies", "add a guard for auth", "validation pipe not working", "test my nest module". Do not use

• realtime-websockets

  Use when building realtime features with WebSockets or Server-Sent Events. Covers protocol choice, connection lifecycle, reconnection and backfill, scaling across instances, and backpressure. Trigger on "add live updates", "websocket keeps disconnecting", "websockets or sse", "scale socket.io across

• spring-boot

  Use when building Spring Boot services. Covers dependency injection, transaction boundaries, JPA performance, configuration, validation, and testing slices. Trigger on "LazyInitializationException", "@Transactional not working", "n+1 queries with jpa", "spring tests are slow". Do not use for general

• competitive-analysis

  Use when analyzing competitors. Covers gathering evidence rather than opinion, positioning and pricing analysis, identifying real differentiation, and producing a conclusion that changes a decision. Trigger on "how do we compare to competitors", "analyze competitor pricing", "a competitor just launc

• lead-research

  Use when researching prospects or accounts before outreach. Covers qualification, finding the trigger event, identifying the right contact, and producing a brief that makes outreach specific rather than generic. Trigger on "research this company before my sales call", "qualify these inbound leads",

• product-analysis

  Use when analyzing a product's performance or deciding what to build. Covers metric selection, funnel and retention analysis, distinguishing signal from noise, and prioritizing on evidence. Trigger on "why did signups drop last week", "did this feature work", "what should we build next", "set up pro

• resume

  Use when writing or tailoring a CV or resume. Covers evidence over adjectives, tailoring to a specific role without lying, structure, and the specific patterns that get a resume discarded. Trigger on "rewrite my resume", "tailor my cv to this job posting", "my resume gets no responses".

• user-research

  Use when planning, running, or synthesizing user research. Covers interview questions that produce evidence rather than opinions, usability testing, and turning transcripts into findings. Trigger on "write an interview guide", "plan a usability test", "synthesize these interview transcripts". Do not

• data-modeling

  Use when designing a schema. Covers normalization and when to break it, choosing keys, modeling time and history, soft deletes, multi-tenancy, and schema decisions that are expensive to reverse. Trigger on "design the schema for this", "model multi-tenancy", "soft delete or hard delete", "keep histo

• data-quality

  Use when validating a dataset or building quality checks into a pipeline. Covers profiling, schema and constraint validation, freshness and completeness checks, anomaly detection, and failing a pipeline correctly. Trigger on "this metric looks wrong", "add checks to the pipeline", "data is missing f

• database-performance

  Use when a database is the bottleneck. Covers finding the expensive queries, index strategy, lock contention, connection saturation, and the schema decisions that make queries fast or impossible. Trigger on "this query is slow", "the page is slow and i think it's the database", "deadlocks in product

• pandas

  Use when analyzing or transforming tabular data in Python. Covers vectorized operations, memory-efficient dtypes, correct joins, groupby patterns, and avoiding the silent errors pandas makes easy. Trigger on "pandas is slow", "dataframe runs out of memory", "merge duplicated my rows", "SettingWithCo

• postgres

  Use when working with PostgreSQL specifically. Covers indexing, MVCC and vacuum, connection pooling, partitioning, JSONB, replication, and the operational realities that separate Postgres from generic SQL. Trigger on "postgres table is bloated", "autovacuum isn't keeping up", "set up pgbouncer", "ad

• spark

  Use when building distributed data pipelines with Apache Spark. Covers partitioning, shuffles, skew, joins, caching, and reading the Spark UI to find why a job is slow. Trigger on "spark job is slow", "one task takes forever", "executor out of memory", "too many small files". Do not use for data tha

• brand-guidelines

  Use when applying or documenting a brand identity. Covers extracting a system from existing assets, documenting colour, type, and voice, and applying a brand consistently across new work. Trigger on "make this on-brand", "write up our brand guidelines", "pull a style guide out of these assets", "doe

• generative-art

  Use when creating algorithmic or generative visual art. Covers composition through code, controlled randomness, colour systems, and building work that is varied without being arbitrary. Trigger on "make some generative art", "draw a procedural pattern in code", "creative coding sketch", "turn this d

• theming

  Use when building a theme or theming system for an interface. Covers token architecture, dark mode, contrast preservation across themes, and generating a coherent palette from a seed colour. Trigger on "add dark mode", "contrast breaks in dark mode", "white-label this app", "generate a palette from

• ui-review

  Use when critiquing an interface design. Covers hierarchy, affordance, consistency, states, and delivering feedback that changes the design rather than describing taste. Trigger on "critique this design", "what's wrong with this mockup", "this screen feels off", "review this ui before handoff". Do n

• visual-design

  Use when creating posters, covers, social graphics, or other static visual designs. Covers composition, typographic hierarchy, colour, and producing original work rather than pastiche. Trigger on "design a poster for", "make a cover image", "social graphic for our launch", "this layout feels unbalan

• architecture-decisions

  Use when a significant technical decision needs to be recorded. Produces Architecture Decision Records that capture context, options, the decision, and its consequences — so the reasoning survives the people who made it. Trigger on "write an adr for this", "document why we chose postgres", "record t

• bug-fix-protocol

  Use when fixing a reported bug end to end. Enforces a disciplined sequence — reproduce, write a failing test, fix minimally, verify, prevent recurrence — and blocks the common failure mode of patching symptoms. Trigger on "fix this bug", "users are reporting that", "this regressed in the last releas

• cli-development

  Use when building command-line tools. Covers argument design, exit codes, streams and piping, progress output, configuration precedence, and behavior that respects the shell. Trigger on "build a cli for", "what exit code should this return", "make this tool work in a pipe", "design the flags for thi

• code-review

  Use when reviewing a pull request, diff, or branch. Produces severity-ranked findings covering correctness, security, performance, and maintainability, with concrete fixes rather than opinions. Trigger on "review this pr", "look over my diff before i push", "is this branch ready to merge", "anything

• debugging

  Use when a bug's cause is unknown. Applies a hypothesis-driven method — reproduce, isolate, instrument, prove — instead of speculative edits, and covers profiler, debugger, and log-based investigation. Trigger on "no idea why this is failing", "works locally but not in prod", "this test fails interm

• design-patterns

  Use when choosing how to structure code for a recurring problem. Covers the patterns that earn their keep, the ones that usually do not, and how to recognize when a pattern is being applied for its own sake. Trigger on "should i use a strategy pattern here", "inheritance or composition", "this is ov

• domain-modeling

  Use when the code's vocabulary does not match the business's. Establishes a ubiquitous language, models domain concepts as explicit types, and identifies bounded contexts. Trigger on "we call it a customer here and an account there", "this model is used by everything", "what are our bounded contexts

• git-workflow

  Use for branching, committing, history repair, and release hygiene. Covers atomic commits, rebase versus merge, bisect, reflog recovery, and undoing mistakes safely. Trigger on "undo my last commit", "i messed up a rebase", "squash these commits", "find which commit broke this". Do not use for pipel

• legacy-modernization

  Use when incrementally modernizing a legacy system without a rewrite. Covers characterization tests, seams, the strangler pattern, and sequencing migrations so the system stays shippable throughout. Trigger on "we should just rewrite it", "migrate off this old framework", "extract a service from the

• refactoring

  Use when improving the structure of code without changing its behavior. Covers safe refactoring sequences, characterization tests, and knowing when to stop. Trigger on "clean this up without changing behavior", "refactor this before i add the feature", "this module is impossible to test", "extract t

• repository-exploration

  Use when orienting in an unfamiliar codebase. Produces a map of the architecture, entry points, data flow, conventions, and the parts most likely to surprise you — before any code is changed. Trigger on "help me understand this codebase", "where do i start in this repo", "how is this project structu

• simple-design

  Use when code has grown hard to hold in your head. Applies complexity limits, dependency reduction, and encapsulation to bring functions and modules back under a readable ceiling. Trigger on "this function is too complex", "i can't follow this file anymore", "every change here breaks something else"

• system-design

  Use when designing a system or service before implementation. Produces a design covering data model, API surface, failure modes, scaling limits, and the trade-offs that were actually decided. Trigger on "design a system for", "will this hold at 10x traffic", "monolith or microservices". Do not use f

• aws-cdk

  Use when defining AWS infrastructure with the CDK. Covers construct design, stack organization, environment configuration, testing infrastructure code, and safe deployment. Trigger on "cdk deploy wants to replace my database", "how should i split these cdk stacks", "write tests for my cdk construct"

• aws-cost-optimization

  Use when reducing cloud spend. Covers finding the actual cost drivers, right-sizing, commitment discounts, storage lifecycle, the hidden costs of data transfer and logging, and avoiding false savings. Trigger on "our aws bill doubled", "should we buy savings plans", "nat gateway costs are insane", "

• aws-serverless

  Use when building serverless systems on AWS. Covers Lambda design, cold starts, event-driven patterns with EventBridge and SQS, idempotency, step functions, and the limits that shape the architecture. Trigger on "lambda cold starts are killing latency", "sqs messages processed twice". Do not use for

• chaos-engineering

  Use when verifying a system's resilience by injecting controlled failure. Covers hypothesis-driven experiments, blast-radius control, failure injection techniques, and running game days safely. Trigger on "does our failover actually work", "plan a game day", "kill a node in staging and see what brea

• ci-cd

  Use when building or fixing a delivery pipeline. Covers pipeline structure, caching, test parallelization, deployment strategies, secrets, and making the pipeline fast enough that people do not route around it. Trigger on "our ci takes 40 minutes", "flaky pipeline keeps failing", "set up github acti

• cloud-architecture

  Use when designing cloud infrastructure. Covers network topology, identity and least privilege, multi-AZ and multi-region trade-offs, managed versus self-hosted decisions, and designing for cost. Trigger on "design the aws setup for our new service", "do we need multi-region", "managed rds or run po

• containers

  Use when building or debugging container images. Covers multi-stage builds, layer caching, image size, non-root users, signal handling, and the security defaults most Dockerfiles get wrong. Trigger on "my docker image is 2gb", "container exits immediately", "container ignores sigterm". Do not use fo

• incident-response

  Use during and after a production incident. Covers triage, mitigation before diagnosis, communication, and blameless postmortems that produce action items someone actually does. Trigger on "prod is down", "we're in the middle of an outage", "write the postmortem for yesterday's incident", "set up an

• kubernetes

  Use when deploying to or debugging Kubernetes. Covers workload configuration, resource requests and limits, probes, rollout strategy, networking, and the failure modes that produce CrashLoopBackOff and OOMKilled. Trigger on "pod keeps restarting", "pod stuck in crashloopbackoff", "container got oomk

• network-troubleshooting

  Use when diagnosing network failures — connection refused, timeouts, TLS errors, DNS problems, and intermittent failures. Covers layer-by-layer isolation and the tools that answer each question. Trigger on "connection refused", "curl times out from the server but works locally", "ssl certificate ver

• observability

  Use when instrumenting a system or when an incident cannot be diagnosed from existing telemetry. Covers structured logging, metrics, distributed tracing, SLOs, and alerts that are worth waking someone for. Trigger on "we couldn't tell what happened from the logs", "add tracing to our services", "too

• site-reliability

  Use when establishing reliability practice. Covers SLOs and error budgets, capacity planning, graceful degradation, load shedding, retry and timeout policy, and the arithmetic of availability. Trigger on "what slo should we set", "how many nines can we promise", "retries are causing a retry storm".

• terraform

  Use when managing infrastructure as code with Terraform or OpenTofu. Covers module design, state management, drift, plan review, secrets, and applying changes without destroying production. Trigger on "terraform plan wants to destroy my database", "state lock is stuck", "how to structure terraform m

• diagrams

  Use when creating technical diagrams as code. Covers Mermaid for architecture, sequence, and flow diagrams, choosing the right diagram type, and keeping diagrams accurate as the system changes. Trigger on "draw an architecture diagram", "make a mermaid sequence diagram", "diagram this request flow".

• document-conversion

  Use when converting between document formats. Covers HTML to Markdown, document to Markdown, PDF generation from HTML, and preserving structure through a conversion rather than losing it. Trigger on "convert this html to markdown", "turn this docx into markdown", "make a pdf from this html". Do not

• pdf

  Use when working with PDF files. Covers text and table extraction, merging and splitting, form filling, watermarking, OCR for scanned documents, and generating PDFs. Trigger on "extract the tables from this pdf", "merge these pdfs", "fill out this pdf form", "ocr this scanned document". Do not use f

• presentations

  Use when creating or editing slide decks (.pptx). Covers slide structure, using layouts and templates correctly, charts and images, speaker notes, and building a deck that communicates rather than decorates. Trigger on "make a slide deck from this", "edit this pptx", "turn this report into slides".

• spreadsheets

  Use when creating, reading, or fixing spreadsheets (.xlsx, .csv). Covers formulas, formatting, charts, data cleaning, and handling the messy real-world files that are not actually tabular. Trigger on "clean up this messy excel file", "add formulas to this spreadsheet", "read this xlsx", "this csv wo

• word-documents

  Use when creating, reading, or editing Word documents (.docx). Covers document generation with styles and structure, extracting content, find-and-replace, tracked changes, and templates. Trigger on "generate a word document", "find and replace in this docx", "fill this word template", "accept the tr

• backtesting

  Use when testing a trading strategy on historical data. Covers the biases that make a backtest lie, realistic costs, walk-forward validation, and the statistics that distinguish an edge from a coincidence. Trigger on "backtest this strategy", "my backtest looks too good to be true", "why does live t

• earnings-analysis
• market-breadth
• market-regime
• options-strategy
• portfolio-review
• position-sizing
• quantitative-analysis
• risk-management
• stock-screening
• technical-analysis
• trade-journal
• accessibility
• angular
• design-systems
• frontend-architecture
• nextjs
• react
• visual-qa
• vue
• web-performance
• cpp
• csharp-dotnet
• go
• java-kotlin
• php
• python
• ruby
• rust
• shell
• sql
• swift
• typescript
• flutter
• ios
• mobile-release
• react-native
• deep-research
• fact-checking
• file-organization
• meeting-notes
• web-data-extraction
• secrets-management
• secure-coding
• security-review
• supply-chain
• threat-modeling
• e2e-playwright
• performance-testing
• qa-review
• test-driven-development
• test-strategy
• web-app-testing
• changelog
• editing
• internal-comms
• long-form-content
• technical-documentation

Similar plugins