Skills MCP Server

Skill Me — the open skill catalog

The canonical public home of every skill authored and hosted by Skill Me — 482 portable SKILL.md files, MIT-licensed.

Every skill is plain-text instructions in the open SKILL.md format that runs in Claude (via the Skill Me MCP), Claude Code, Cursor, Gemini CLI, and Codex. Read exactly what a skill does before you install it.

Install

• Claude, ChatGPT, Codex, Cursor (connector): connect Skill Me once, then ask for any skill by name.
• One skill as files for Codex, Cursor, or Claude Code: npx @skillme/cli add <slug> --target all
• With the skills CLI: npx skills add SkillMedev/skills (or a per-pack repo — see the org).
• Manually: copy any skills/<slug>/SKILL.md into .agents/skills/, .cursor/skills/, or .claude/skills/.

Browse all 2,500+ skills and packs at skillme.dev.

Skills by category

Coding

• Accessibility Audit — Runs a full WCAG 2.2 accessibility audit of an interface - keyboard, screen reader, contrast and zoom, forms, and media, in a fixed pass order - and delivers a severity-triaged findings table with concrete fixes.
• Agent Orchestration — Designs reliable multi-agent LLM systems - choosing a topology, writing handoff contracts between agents, deciding what runs in parallel vs series, and setting context, retry, and cost budgets that stop runaway loops.
• Alert Tuning — Reduces alert noise by making alerts actionable, symptom-based, and tied to SLOs.
• API Client Generator — Generates a typed API client from an OpenAPI/Swagger spec, with a hand-controlled transport wrapper for timeouts, auth, and typed errors.
• REST API Design — Designs REST API surfaces - resource naming, HTTP method and status-code semantics, error shapes, pagination, and filtering - and delivers an endpoint spec a consumer can build against without asking questions.
• API Versioning Strategist — Produces an API version scheme (date-pinned header or URI), a breaking-vs-additive change policy, and a published deprecation/sunset timeline with translation shims.
• App Store Release Prep — Produce a reproducible signing, versioning, and store-declaration pipeline so an iOS or Android build passes App Store Connect / Play Console submission.
• Build on Agent-Native — Build an application on Builder.io's open-source Agent-Native framework (@agent-native/core) - the model where the agent acts inside the app as a first-class peer to the UI, sharing one set of actions and one database with the interface.
• Business Rule Extractor — Produces a documented inventory of the implicit business rules, edge cases, and bug-as-feature behaviors that tangled code encodes, with real input-to-output examples, so a rewrite preserves behavior.
• Caching Strategy — Designs multi-layer caching - CDN, application, and database - choosing the pattern, TTL, and invalidation plan per data type, and produces a cache-decision table plus stampede protection.
• Changelog Generator — Generate or update a repository CHANGELOG.md in Keep a Changelog format from git history - grouping commits since the last tag into Added/Changed/Deprecated/Removed/Fixed/Security, rewriting them as user-facing entries, and recommending the semantic version bump.
• Characterization Test Writer — Writes pinning and characterization tests that lock in the current behavior of untested legacy code - bugs included - before a refactor, so any later behavior change trips an alarm.
• Circuit Breaker Builder — Wraps flaky upstream dependencies in circuit breakers, aggressive timeouts, and per-dependency bulkheads so a slow or failing service degrades gracefully instead of cascading into a full outage.
• Code Review Checklist — Run a systematic multi-pass code review - correctness, design, security, performance, tests - and report findings ordered by severity with concrete, respectful suggestions.
• Contract Test Writer — Writes consumer-driven contract tests at service and API boundaries - Pact consumer tests, provider verification, broker publishing, and can-i-deploy gates - so an incompatible change fails a build instead of breaking integrations in production.
• Coverage Gap Finder — Produces a risk-ranked list of untested critical paths and branches from a real branch-coverage report crossed with git churn, naming the specific missing cases and the smallest test that buys the most safety.
• Database Schema Designer — Designs normalized, constrained, migration-friendly relational schemas - entity modeling, key and type selection, indexes derived from real query patterns, and safe forward/rollback migrations.
• Dead Code Eliminator — Proves code is unreachable with converging evidence, then removes it and its tests, fixtures, and flags in reversible slices without breaking dynamic callers.
• Dependency Risk Audit — Audits third-party dependencies for exploitable CVEs, abandonment, license exposure, and supply-chain hygiene, and delivers a ranked findings report with a remediation order.
• Docker Compose Wizard — Produces production-minded docker-compose configurations - pinned images, healthchecks with real intervals, health-gated startup ordering, named volumes, explicit networks, and env-file secrets - plus the matching .env.example.
• E2E Scenario Author — Converts an acceptance criterion or user story into one maintainable Playwright or Cypress end-to-end test that reads like the journey it covers.
• Environment Doctor — Diagnose and fix a broken local development environment methodically - reproduce the failure, fingerprint runtime, package manager, OS and arch, check version files and PATH shadowing, lockfile drift, missing env vars (without printing secrets), port conflicts, stale caches, native-module and Apple Silicon arch mismatches, and Docker context - then apply the smallest fix and leave a reproducible setup note.
• Error Budget Policy — Defines and applies an SLO error-budget policy that gates feature work versus reliability work based on remaining budget.
• Error Handling — Designs typed, observable, recoverable error handling - an explicit taxonomy of retryable vs terminal failures, Result types at boundaries, single-point logging, and retry policies with real backoff numbers.
• Feature Flags — Designs feature-flag systems and lifecycle policy - flag taxonomy (release, ops/kill-switch, experiment, permission), percentage rollouts with stable bucketing, safe defaults, and mandatory removal deadlines so flags don't rot into dead code.
• Flaky Test Detangler — Root-causes intermittently failing tests and eliminates the hidden dependency at its source instead of retrying around it.
• Flutter Widget Architect — Architects Flutter widget trees and Riverpod or Bloc state so rebuilds are scoped, build() stays pure, and const widgets skip recomposition.
• Framework Upgrader — Drives a major-version framework bump as a sequence of small, reversible, CI-gated PRs using official codemods and changelog diffing while keeping the app green.
• Git Commit Writer — Write commit messages from a staged diff in Conventional Commits 1.0.0 format - correct type and scope, ! and BREAKING CHANGE footers, GitHub closing keywords, and a body that explains why - and split mixed changes into separately revertable commits.
• GitHub Actions — Designs and hardens GitHub Actions CI/CD - pipelines that hit a sub-10-minute PR feedback budget through caching and parallelism, with least-privilege security and safe deploy gates.
• GraphQL Schema — Designs GraphQL schemas and resolvers that scale - domain-modeled types, Relay pagination, DataLoader batching to kill N+1, mutation payloads with typed user errors, and depth/complexity limits that stop abusive queries.
• Idempotency Enforcer — Designs client-supplied idempotency keys, deduplication storage, and replay semantics so at-least-once delivery and client retries return the first result instead of double-charging or double-shipping.
• Jetpack Compose Builder — Builds Android Jetpack Compose UI with hoisted state, unidirectional data flow, and recomposition-safe patterns backed by measured stability rules.
• Kubernetes Basics — Writes production-ready Kubernetes manifests - Deployments with correct resource requests/limits, readiness/liveness/startup probes, PodDisruptionBudgets, safe rollouts, and graceful shutdown.
• Language Version Migrator — Ports a codebase across a breaking language or runtime version with compatibility shims, batched automated transforms, dual-runtime CI, and old-vs-new output diffing, ending in a flag-flip cutover with a rollback rule.
• LLM Evaluation — Builds evaluation harnesses for LLM products - golden datasets, deterministic checks, calibrated LLM-as-judge rubrics, and CI regression gates that turn "seems good" into a tracked number.
• Load Testing — Designs and interprets load tests - smoke, load, stress, soak, and spike - with realistic ramp profiles, percentile-based pass/fail thresholds, and a bottleneck-reading procedure, producing a runnable test plan.
• MCP Server Builder — Design and build Model Context Protocol servers that models use correctly - choosing stdio vs stateless Streamable HTTP while still serving 2025-era clients, shaping a few task-level tools with clear descriptions, JSON Schema inputs and honest annotations, bounding and paginating output, returning recoverable errors as isError results, securing remote servers with OAuth 2.1, and testing with the MCP Inspector.
• Microservices Design — Designs microservice architectures - service boundaries from business capabilities and team ownership, sync vs async communication choices, saga and outbox patterns for consistency, and resilience defaults - producing a boundary map with an extraction verdict per candidate service.
• Mobile Offline Sync — Builds local-first mobile storage with an optimistic local store, durable mutation outbox, per-entity conflict-resolution rules, incremental pull, and idempotent background retry.
• Mobile Perf Profiler — Diagnoses and fixes mobile jank, dropped frames, slow startup, and growing memory by capturing a trace or heap snapshot on a real device, isolating the single worst cost, fixing it, and re-measuring against the 16ms frame and cold-start budgets.
• Mock Stub Designer — Designs the minimal set of test doubles for a unit or integration test and decides, per dependency, whether to stub, fake, spy, mock, or exercise the real thing.
• Monolith Decomposer — Finds and validates one bounded-context seam to extract from a monolith - gated on coupling-graph, co-change, data-ownership, and transaction-boundary evidence - and sequences an incremental strangler-fig extraction plan.
• Monorepo Expert — Structures and scales JavaScript/TypeScript monorepos with Turborepo, Nx, and pnpm workspaces - layout rules, task pipelines, remote caching, and affected-only CI so build times stay flat as the repo grows.
• Mutation Test Runner — Runs mutation testing on already-covered code and turns each surviving mutant into a specific missing assertion, exposing tests that execute code but verify nothing.
• Next on Vercel Performance — Diagnose and fix Core Web Vitals and page performance of a Next.js app on Vercel - measurement-first.
• Next.js App Router — Builds and reviews Next.js App Router code - server/client component boundaries, data fetching, caching and revalidation choices, streaming with Suspense, and Server Action mutations - and delivers routes where every dynamic-vs-cached decision is explicit.
• OAuth & OIDC Flow — Implements OAuth 2.0 and OpenID Connect correctly - authorization code with PKCE, client credentials for machine-to-machine, state and nonce, exact redirect URI matching, safe token storage, refresh rotation with reuse detection, scopes, ID token validation via JWKS, and logout - aligned with RFC 9700 (OAuth Security BCP) and RFC 7636 (PKCE).
• Observability Stack — Instruments systems with the three pillars - structured logs, RED/USE metrics, and distributed traces - correlated by one trace ID, with cardinality budgets and symptom-based alerts.
• Pagination and Sync Engineer — Designs correct cursor pagination and incremental delta sync against a mutating dataset - cursor contracts, updated_at watermarks, delete propagation, checkpointing, and idempotent reprocessing.
• PII Scrubber — Detects and redacts personally identifiable information from text, logs, datasets, and LLM prompts using layered pattern, checksum, and NER detection, then picks the right redaction mode for each downstream use.
• Playwright Testing — Writes and reviews end-to-end Playwright tests that survive UI refactors and never fail on timing - resilient locators, web-first assertions, isolated state, and a flake policy with quarantine rules.
• PR Description Writer — Write pull request titles and descriptions from a branch diff - problem and evidence, approach, risk and blast radius, real test evidence, rollout and rollback, a reviewer guide, before/after screenshots for UI, and correct closing keywords - inside the repo's PR template when one exists.
• Prompt Engineer — Turns a vague request into a structured, reliable prompt - role, context, task, format, failure handling, and few-shot examples - that produces consistent output across real inputs.
• Prompt to Skill — Converts a prompt a user runs repeatedly into a reusable, paid-quality SKILL.md.
• Push Notification Wirer — Wires native mobile push end to end on APNs and FCM - device-token lifecycle, permission priming and prompt timing, alert and silent payloads, the server send path, and tap routing in all app states.
• Python Async — Writes and reviews correct asyncio code - structured concurrency with TaskGroup, gather vs create_task decisions, cancellation and timeout handling, bridging blocking code with to_thread, and bounded parallelism - with good/bad pairs for the pitfalls that silently freeze the event loop.
• Rate Limit Handler — Adds retry-with-backoff, Retry-After handling, and client-side throttling so a caller stays under an upstream API's rate limits instead of hammering it.
• React Native Pro — Builds and ships production React Native apps - architecture, navigation, list and startup performance against explicit budgets, native modules, and EAS release flow.
• README Generator — Write or overhaul a project README from the repository itself - audience-first structure, a quickstart where every command is verified by running it or tracing it to CI, a configuration table built from the env vars the code reads, real troubleshooting, and contributing and license sections.
• Regex Master — Authors, debugs, and hardens regular expressions - test-cases-first workflow, flavor-aware construction (JS, PCRE, Python re, RE2), catastrophic-backtracking detection and rewrites, and annotated verbose patterns with a verification table.
• Remotion Compose — Turns a natural-language video brief into a complete, ready-to-preview Remotion composition - extracts duration, scenes, brand colors, aspect ratio, and real copy; plans the frame budget; and writes data-driven React/TypeScript using useCurrentFrame, interpolate, spring, AbsoluteFill, and Sequence, registered in Root.tsx.
• Remotion Render — Renders a Remotion composition to MP4 and runs the edit-and-re-render loop - CLI render commands, 1080p/4K/9:16 presets, concurrency tuning, codec selection, batch variants from a JSON data file, and Lambda for cloud rendering.
• Remotion Setup — Scaffolds a new Remotion video project wired for Claude Code Agent Skills - Node check, create-video scaffold, skills install, folder conventions, Google Fonts, and a smoke-test render.
• Runbook Writer — Writes an operational runbook for a service covering symptoms, diagnostic checks, mitigations, and escalation paths.
• Rust Patterns — Writes and reviews idiomatic Rust - ownership and borrowing decision rules for API signatures, lifetime avoidance strategies, thiserror vs anyhow error design, iterator-first style, and when Rc/RefCell/Arc/Mutex are actually justified - with good/bad code pairs.
• Secrets Hygiene — Guides detection, emergency rotation, and prevention of leaked secrets and credentials across source code, git history, CI pipelines, logs, and infrastructure config.
• Secure Code Review — Reviews code for the security flaw classes that cause the most breaches - broken authorization and IDOR, injection, SSRF, mass assignment, and unsafe deserialization - and returns a short, focused findings list with concrete fixes.
• Security Audit — Runs a whole-application security audit - threat-model-lite scoping, dependencies and supply chain, secrets, authentication and authorization, input handling, transport and headers, logging, and infrastructure config - and delivers a severity-ranked findings report with reproduction steps and concrete fixes.
• SEO Optimizer — Audits and rewrites a page for organic search - title and meta lengths, heading hierarchy, intent match, internal links, schema markup, and Core Web Vitals - and returns a prioritized fix list.
• SEV Triage — Classifies incident severity (SEV1-4) using impact, scope, and urgency signals and decides who to page.
• Skill Auditor — Use when reviewing, grading, auditing, or improving a whole existing skill or pack - judging whether a skill is good, fixing one that misfires or won’t activate, or driving one or many skills to a quality bar.
• Skill Author — The section-by-section anatomy standard every paid-quality SKILL.md must meet.
• Skill Creator — Use when authoring a brand-new skill from scratch - turning a capability idea or a "make me a skill that…" request into a complete SKILL.md with a trigger-precise description and the full paid-quality anatomy: procedure, elicitation, thresholds, worked artifact, deliverable, Do NOT, quality bar.
• Skill Description Writer — Writes the description field that makes a skill fire reliably - WHAT it does, WHEN to invoke it with quoted user phrasing, and what it is NOT for.
• Skill Pack Curator — Designs the membership and structure of a skill pack - persona, member selection, install sequence, cross-links, and what to add or cut.
• Skill Tester — Empirically tests a skill with subagent scenarios to verify it fires on the right prompts, stays silent on the wrong ones, and performs its job when loaded.
• SOC 2 Evidence Helper — Maps engineering controls to SOC 2 Trust Service Criteria, builds a continuous evidence-collection plan with cadences per control family, and produces the control-to-evidence table auditors work from.
• SQL Query Optimizer — Diagnoses slow SQL from the execution plan, names the cost driver, and delivers the rewritten query plus index DDL with the expected plan change and write-side cost stated.
• Stock Photo APIs — Integrates the Unsplash, Pexels, and Pixabay APIs in code - auth, search endpoints, rate limits, attribution, hotlinking versus caching rules, and the compliance obligations that get apps deactivated when skipped.
• Strangler Fig Planner — Produces an incremental migration plan that runs a legacy and a new system side by side behind a routing seam, slicing and sequencing whole capabilities so the old system stays live until its last route is cut.
• Stripe Expert — Implements Stripe payments, subscriptions, and webhooks so billing state stays correct - Checkout Sessions, signature-verified idempotent webhook handlers, dunning, and SCA handling.
• Supabase Expert — Builds secure Supabase apps - Row Level Security policies as the authorization layer, schema design against auth.users, Edge Functions for service-role work, realtime subscriptions, and versioned migrations.
• SwiftUI Expert — Builds clean, performant, accessible SwiftUI views with correct state ownership, scoped invalidation, and smooth list scrolling, and reviews existing SwiftUI code against a concrete frame-time and re-render budget.
• TDD Expert — Drive development with strict Red-Green-Refactor discipline - write one failing test, write the minimum code to pass it, refactor on green - including test-list planning and a worked kata cycle.
• Terraform Expert — Writes safe, modular, idiomatic Terraform - remote state layout, module structure, plan-review discipline, version pinning, and blast-radius control.
• Test Data Builder — Builds realistic domain fixtures, factories, and edge-case datasets with the builder pattern and valid defaults, so each test owns exactly the data it asserts on.
• Test & Placeholder Data APIs — Use when building a demo, prototype, or tutorial that needs realistic remote data - "fake products/users/todos for this app", "an API I can hit while wiring up fetch", "placeholder images", "seed this UI with something that looks real", or teaching HTTP/CRUD against a live endpoint.
• Threat Model STRIDE — Applies STRIDE threat modeling to a feature or system design and produces a prioritized threat table with concrete mitigations ranked by exploitability and impact.
• TypeScript Strict Mode — Write and review TypeScript as if strict mode plus the hardening flags (noUncheckedIndexedAccess, exactOptionalPropertyTypes) are enforced, and migrate loose codebases to full strictness flag by flag without breaking the build.
• Vercel AI Gateway — Route every LLM call through one unified API on Vercel - plain "provider/model" strings via the AI SDK, automatic provider routing and model fallbacks, observability and per-key cost tracking, and zero data retention.
• Vercel Deploy Pipeline — Ship a Next.js app to Vercel the production way: promote a tested preview to production, instant-rollback a bad release, build once with --prebuilt, run a staged/canary rollout with Rolling Releases (GA), and wire the deploy into CI.
• Vercel Rendering and Caching — Choose a rendering, runtime, and caching strategy on Vercel - Fluid Compute as the default runtime (Edge Functions are deprecated), ISR/PPR, Next.js 16 Cache Components ('use cache', cacheLife, cacheTag, updateTag, revalidateTag), and the Vercel Runtime Cache API (getCache, expireTag, invalidateByTag) with tag-based invalidation.
• Vercel Env Management — Manage environment variables across Vercel environments and keep local .env in sync - vercel env pull/add/rm/ls, per-environment values (development/preview/production + custom), sensitive secrets, OIDC tokens for keyless cloud access, and the NEXT_PUBLIC build-time inlining gotcha.
• Vercel Firewall and BotID — Harden a Vercel app at the platform edge - the Vercel WAF (custom rules, IP blocking, managed rulesets like OWASP CRS + bot_protection + ai_bots, rate limiting), Attack Challenge Mode, system bypass rules, automatic DDoS mitigation, and BotID bot verification on sensitive routes.
• Vulnerability Triage — Prioritizes vulnerability findings from scanners, pentest reports, and bug bounty submissions by real-world exploitability rather than raw CVSS, assigning internal severity tiers with fix SLAs.
• Web Performance — Diagnoses and fixes Core Web Vitals - LCP, INP, and CLS - through an ordered audit procedure with concrete code-level changes for images, fonts, JavaScript, and third-party scripts.
• Webhook Receiver Hardener — Hardens an inbound webhook endpoint so it verifies the sender signature on the raw body, resists replays, and acknowledges fast by persisting-then-enqueueing before any processing.
• WebSocket Expert — Builds resilient WebSocket systems - heartbeat and dead-connection detection, reconnect with exponential backoff and jitter, message queuing with sequence numbers and backpressure limits, auth on connect, and pub/sub backplanes for horizontal scale.

Writing

• Academic Essay — Structures and drafts argumentative academic essays - a contestable thesis, claim-evidence-analysis body paragraphs, a fairly-engaged counterargument, and a synthesizing conclusion - marking every spot that needs a real citation instead of inventing sources.
• App Store Copy — Writes App Store and Play Store listing copy to platform-specific rules - iOS name, subtitle, and hidden keyword field; Android title, short description, and keyword-woven full description - delivering every field with character counts, a ranked keyword list, and title options to A/B test.
• Book Proposal — Writes non-fiction book proposals that sell to agents and acquiring editors - an overview hook answering why this book and why now, author platform with real numbers, target market, honest recent comps, a marketing plan, and a chapter outline that proves a full book exists.
• Brand Guidelines Doc — Writes a brand guidelines document - personality traits with is/is-not definitions, voice principles, a tone-by-context matrix, writing mechanics, a say-this-not-that word list, and visual usage rules - all made concrete with do/don't examples.
• Carousel Scripter — Scripts a multi-slide Instagram or LinkedIn carousel as a hook slide, one-idea-per-slide value frames, and a single-CTA closing slide, with per-slide copy and design direction.
• Case Study Builder — Turn a customer win into a credible case study - interview-driven raw material, a challenge-solution-results arc, and a quantified results section with real customer quotes.
• User-Facing Changelog — Translates raw engineering release notes - commits, tickets, PR titles - into a user-facing changelog grouped as New, Improved, and Fixed, with a highlights section on top, benefit-first phrasing in the user's vocabulary, bugs described by their symptoms, and internal-only churn cut and flagged.
• Cold Email Craft — Write short, personalized B2B cold emails and follow-up copy - under 90 words, one ask, personalization in the first line - with good/bad contrast pairs to calibrate.
• Content Brief — Builds an SEO content brief a writer can execute without guesswork - primary and semantic keywords, search intent, recommended format matched to the SERP, title, H1, meta description, a full H2/H3 outline, word-count guidance derived from ranking pages, internal links with anchors, featured-snippet opportunities, CTA, and the content gap competitors miss.
• Content Repurposing — Fans one long-form pillar asset (video, podcast episode, or article) out into 10+ platform-native atomic pieces with a derivation map - clips, quote cards, threads, LinkedIn posts, newsletter and blog sections - each recast in the target platform's register and sequenced over the week.
• Course Outline Architect — Designs a paid online course structure backward from the student transformation - before/after states, one module per milestone, 5-12 minute lessons with one action each, and completion-first sequencing that front-loads quick wins.
• Course Sales Page — Writes the long-form sales page for a paid online course - above-the-fold promise, PAS-to-proof-to-program-to-price section order, value-stack price anchoring, an action-based guarantee, and an FAQ mapped to real objections.
• Cover Letter Writer — Writes a tailored cover letter from a resume and a job posting - mirrors the posting's top three requirements with resume evidence, opens with a company-specific hook, and stays under 300 words.
• Creator Content Calendar — Designs a sustainable publishing system for a solo creator - 3-4 content pillars, a cadence set at the creator's consistent floor, a fixed pillar rotation, a 30-day idea bank, and a monthly audit loop - delivered as a weekly calendar skeleton.
• Cross-Platform Reformatter — Re-expresses one finished piece of content as the native-equivalent post on each target channel, holding the core idea constant while flexing length, structure, register, and conventions per platform.
• Data Storyteller — Turns data and charts into a decision-driving narrative structured as headline finding, trend, implication, and recommended action - with finding-led chart titles, context for every number, annotation guidance, and honest flags on any conclusion the data cannot support.
• Donor Communications — Builds a small nonprofit's individual-donor communication system - segmenting donors into major, recurring, first-time, and lapsed with different treatment for each, thanking within 48 hours of every gift, structuring impact stories around one beneficiary with the donor as hero, writing appeal letters, and holding a 3:1 impact-to-ask calendar ratio.
• Email Drip Builder — Designs automated onboarding and activation drip sequences with behavior-gated sends, exit
• Email Newsletter Pro — Write recurring email newsletters - subject lines that earn the open, preview text that extends them, a body structure readers finish, and cadence rules that keep the list healthy.
• Engagement Reply Drafter — Drafts short, on-brand replies to public social comments and DMs, including graceful handling of praise, questions, complaints, and criticism.
• Error Message Writer — Rewrites error messages to be specific, actionable, and blame-free - what happened, why it helps to know, and what to do next - with tone calibrated to severity and developer-facing detail kept separate from the user-facing text.
• Executive Summary — Compresses long reports, memos, and analyses into a decision-ready one-page summary (250-350 words) - bottom line up front, 3-5 evidence-backed key findings, a specific owned-and-dated recommendation, risks with mitigations, and the exact decision or resource being requested - plus a separate list of unverifiable claims to probe.
• Fiction Scene Writer — Writes individual fiction scenes with goal-conflict-turn structure, sensory grounding, interiority, and subtext-driven dialogue - then notes the turn accomplished and one craft choice so the writer can learn from it.
• Formatted Report Writer — Produces long-form business and consulting reports with a standalone executive summary, three-level heading hierarchy, and skimmability rules that let a busy reader navigate in under two minutes.
• Ghostwriter — Analyzes an author's writing samples, builds an explicit quantified voice profile, and produces new content indistinguishable from the author's own hand.
• Grant LOI Writer — Writes the one-page letter of inquiry that earns a nonprofit an invitation to submit a full proposal, using the need-approach-fit-ask structure, funder-language mirroring, and a specific ask stating amount, duration, and what the money buys.
• Grant Proposal Writer — Writes the full foundation grant proposal for a nonprofit - need statement grounded in local data, a logic model with real numbers (inputs to activities to outputs to outcomes), SMART objectives, an evaluation plan sized to organizational capacity, a budget narrative where every line traces to an activity, and a credible sustainability answer.
• Hashtag Strategist — Builds a tiered hashtag and keyword set sized to the account's actual reach - mixing broad, niche, and branded tags per platform limits and screening out banned, spammy, or shadow-flagged tags.
• Help Documentation — Writes user-facing help-center articles - verb-first how-to guides, symptom-organized troubleshooting pages, and FAQs - with one task per article, exact UI labels, and a stated success result.
• Impact Report Builder — Builds a nonprofit's annual or program impact report that funders and donors actually trust - leading with outcomes over activities, pairing every number with one human story, admitting shortfalls honestly, including a financial transparency block, and computing program cost per outcome.
• Instagram Post Builder — Interactively builds a complete, copy-paste-ready Instagram post package - three hook variants using distinct patterns, a caption body, one clear CTA, a 15-20 hashtag set across reach tiers, alt text, and a visual direction with shot list or slide breakdown - through a one-question-at-a-time interview, optionally grounded in a trend-educator briefing.
• Job Application Writer — Tailors a resume and writes a cover letter for one specific job description - mirroring JD keywords for ATS parsing, reordering bullets by relevance, quantifying impact, and reporting which JD keywords matched and which are missing.
• Knowledge Base Article Writer — Turns a resolved support ticket into a clear, searchable knowledge-base or help center article.
• Landing Page Copy — Write landing-page copy section by section - hero, social proof, features-as-benefits, objections, CTA - leading with one promise and proving it down the page.
• Launch Email Sequence — Builds the open-cart email launch for a paid course - a 2-3 week pre-launch runway that seeds the problem, a day-by-day cart-open sequence of 6-8 emails over 5-7 days, honest deadline mechanics for the last-48-hours surge, and clicker/non-opener segmentation.
• Lesson Plan Builder — Builds a complete single-lesson plan - measurable objective, timed four-part arc (hook, direct instruction, guided practice, closure), a formative check with a proceed/re-teach rule, and differentiation notes - clear enough that a substitute could run it.
• Lifecycle Journey Map — Builds a customer lifecycle journey map with behavioral entry/exit criteria per stage, one goal and one signal per stage, message briefs, and dead-zone flags.
• LinkedIn Post Writer — Write LinkedIn posts built for the feed - a hook that survives the two-line truncation, scannable one-idea-per-line structure, a comment-bait close, and first-hour engagement moves.
• Listing Description Writer — Writes MLS and portal listing copy that sells the property - lead with the differentiator, translate features into benefits, specifics over adjectives, platform length limits, and a fair-housing-safe banned-claims list.
• Localization Writer — Adapts English content for a target language and region - swapping idioms, setting the right formality register, replacing cultural references, converting dates, units, and currency - and delivers the localized text with a notes column explaining each adaptation and flagging what needs a native reviewer.
• **[Manuscript Reviser](skills/manuscript-reviser/SKILL.md

Documentation truncated — see the full README on GitHub.