The directory
All 504 Claude Code skills
Every skill is a complete, installable SKILL.md playbook. Filter by category or search by
technology, file type or task — results update as you type. Prefer your stack?
Browse skills by technology, from TypeScript and
Python to PostgreSQL and Kubernetes.
Agent Eval Harness
Prove a skill or prompt change helped, run after run
Agent SDK Builder
Ship a custom agent on Claude Code's own loop
Command to Skill Migration
Move slash commands into skills without breaking a name
Context Window Hygiene
Keep long sessions sharp instead of slowly forgetful
Devcontainer Sandboxing
Skip prompts only inside a boundary you have tested
Git Worktree Parallelism
Several Claude sessions, one repo, zero collisions
Headless CI Agent
Claude in your pipeline, bounded and injection-aware
Hooks Automation
Turn 'always do X' into behavior that never skips
MCP Server Builder
Connect Claude to your systems with tools it picks right
MCP Troubleshooting
From 'Failed to connect' to a named cause in six rungs
CLAUDE.md Architect
Short memory files that Claude actually follows
Multi-Repo Workflows
Change several repos without breaking any consumer
Output Styles
Reshape every reply without touching how code gets written
Permissions Policy
Fewer prompts for safe work, hard stops for the rest
Plugin Marketplace Publisher
Ship your skills, agents and hooks as one install
Repo Agent Bootstrap
One pass from fresh clone to agent-ready repository
Session Handoff Notes
Resume long tasks in minutes, not another hour of digging
Skill Authoring
Write skills that load when needed and teach something
Skill Description Tuning
Make skills fire on the right prompts, and only those
Spec-Driven Development
Requirements, design, tasks, code — each traced to the last
Status Line Scripts
Context, cost and branch at a glance, under 50 ms
Subagent Design
Delegate noisy work and get back only what matters
Task Decomposition Plans
Plans with checks, risk first, before a line of code
Usage and Cost Tracking
Find where the tokens went, then cut the top three
Code Archaeology
Learn why code exists before you delete it
Code Review
Findings ranked by severity, minus the nitpicks
Code Search
Find every usage, and prove you found them all
Codebase Onboarding
From git clone to a verified map in one session
Codemods
Hundreds of call sites changed, tested, and accounted for
Commit Craft
Commits that bisect cleanly and explain why
Dead Code Removal
Delete unused code with two kinds of proof
Dependency Upgrades
Major version bumps without the Friday surprise
Git History Surgery
Rewrite history with a backup ref and a tree diff
Issue Triage
Every issue leaves triage with one clear state
Legacy Code Rescue
Change untested code without breaking production
Migration Planning
Phased migrations that ship, roll back, and finish
Monorepo Navigation
Run the affected tasks, not the whole repo
Pull Request Writer
PRs a reviewer can approve in one sitting
Release Management
Version numbers that tell consumers the truth
Requirements Clarification
Five sharp questions before five days of wrong work
Review Feedback Resolution
Every review thread closed with a commit or a reason
Safe Refactoring
Change the structure, prove the behavior did not
Systematic Debugging
Root causes, not lucky patches
TDD Loop
See it fail, make it pass, then clean it up
Technical Spike
Answer one hard question inside a time box
Work Estimation
Ranges with confidence levels, not wishful dates
Accessibility Audit
WCAG 2.2 AA findings you can hand to engineers
Modern Angular
Signals, control flow and zoneless, version-aware
Astro Sites
Static HTML first, hydrate only what users touch
CSS Architecture
Cascade layers instead of specificity wars
Data Tables
Fast, accessible tables at 100k rows
Drag and Drop
Drag as a shortcut, with a click path behind it
Forms and Validation
One schema, server-checked, errors a screen reader hears
htmx Hypermedia
Server-rendered fragments instead of a SPA
i18n and Localization
ICU messages, Intl formatting, RTL that holds up
Micro-frontends
Split the frontend only when the org chart demands it
Next.js App Router
Layouts, caching and invalidation that behave in prod
Nuxt Apps
Fetch once on the server, render per route
PWAs and Service Workers
Installable, offline-ready, never stuck on old builds
React Patterns
Fewer effects, derived state, components that compose
React Router Framework Mode
Loaders, actions and typed routes, the Remix way
React Server Components
Keep data on the server and props serializable
Rich Text Editors
Tight schemas, JSON storage, sanitized output
SolidJS Apps
Fine-grained reactivity without React reflexes
State Management
One owner per value: URL, cache, store or component
Storybook Components
Stories as tested fixtures, not a demo gallery
SvelteKit Apps
Runes, load functions and forms that work without JS
Tailwind CSS v4
Tokens in @theme, complete class names, no @apply sprawl
TanStack Query
Server state with keys, staleTime and rollback
Virtualized Lists
Thousands of rows, a few dozen DOM nodes
Vue Composition API
Refs that stay reactive and composables that compose
Web Animations
Transform and opacity, interruptible, reduced-motion safe
Web Components
Custom elements that behave like native ones
Web Maps
GPU layers, honest tile costs, points in the right place
API Versioning and Deprecation
Change public APIs without surprising a single client
ASP.NET Core APIs
Problem details, fail-closed auth, real integration tests
Axum Rust Services
Thin handlers, typed state, errors that map to HTTP
Background Jobs
Jobs that survive duplicates, crashes and retries
Bun Runtime
Adopt Bun one role at a time, with proof
Deno Runtime
Scoped permissions instead of -A everywhere
Django Apps
Constant query counts and migrations safe on live data
Express on Node
Express 5 services that fail loudly and shut down cleanly
FastAPI Services
Async APIs that never block the event loop
Flask Apps
App factory, 2.0-style models, gunicorn in prod
Go HTTP Services
Stdlib Go servers with timeouts, slog and clean drains
GraphQL Schema Design
Client-shaped schemas that resolve in bounded queries
gRPC Services
Safe proto evolution and calls that always have deadlines
Hono on the Edge
One typed API for Workers, Bun, Deno and Node
Laravel Apps
Eloquent without N+1, jobs that survive retries
NestJS Modules
Clear module boundaries and enhancers in the right place
OpenAPI Codegen
Generated clients that stay in sync with the spec
Pagination and Filtering
Page one and page ten thousand cost the same
Phoenix Framework
Scoped contexts and LiveViews that never leak rows
Rails Conventions
Code that follows the Rails grain instead of fighting it
Realtime WebSockets and SSE
Live connections that scale out and recover on their own
REST API Design
Predictable endpoints, machine-readable errors, safe retries
Spring Boot
Typed config, honest JPA and fast test slices
Temporal Workflows
Durable processes that survive deploys and replays
tRPC APIs
Typesafe procedures with auth that narrows context
Webhook Handling
Verified, deduplicated webhooks that never get lost
Bash Scripting
Shell scripts that fail loudly and clean up after
C Systems Programming
C that carries its buffer sizes and frees on every path
Modern C++
C++20/23 with clear owners and sanitizer-clean tests
C# and .NET
Nullable-clean, cancellable, typed .NET code
Dart Language
Sealed states, exhaustive switches, no bang operators
Elixir and OTP
Processes for state and failure, not for code
Go Idioms
Go that passes review on the first round
Haskell Functional
Total functions, typed domains, and leak-free IO
Modern Java
Records, sealed types, and virtual threads done right
Julia Scientific Computing
Type-stable Julia, measured before and after
Kotlin Idioms
No !!, no GlobalScope, no leaked coroutines
Lua Scripting
Lua for Neovim, Redis and game hosts, minus the globals
Modern PHP
Typed, enum-driven PHP that PHPStan trusts
PowerShell Scripting
Object pipelines that stop on errors and honor -WhatIf
Modern Python
uv, ruff, strict types, one pyproject.toml
R Tidyverse
Pipelines with predictable row counts and real plots
Regex Crafting
Patterns with test cases and no ReDoS surprises
Ruby Idioms
Enumerable over loops, small objects, clean Bundler
Rust Ownership
Satisfy the borrow checker without clone spam
Scala 3 Functional
Exhaustive ADTs, typed errors and one effect system
Swift Concurrency
Reach Swift 6 mode with zero data-race warnings
TypeScript Strict
Make impossible states fail to compile
WebAssembly Modules
Ship wasm only where it pays, and keep it small
Zig Programming
Zig for your pinned compiler, not last year's stdlib
API Testing
Prove every endpoint's contract, including who can't call it
Benchmark Testing
Faster means significant, not one lucky run
Contract Testing
Catch breaking API changes before either side deploys
Coverage Analysis
Find untested risk instead of chasing a percentage
Cypress E2E
Cypress tests that wait on aliases, never on timers
Flaky Test Triage
Find flakes from CI data and fix the cause
Fuzz Testing
Throw hostile bytes at parsers before attackers do
Jest Testing
Jest suites with hoisting-safe mocks and honest snapshots
Load Testing with k6
A verdict and a bottleneck, not just a pile of numbers
Mobile E2E Testing
Mobile UI tests that pass ten runs out of ten
Mocking Strategy
Mock the edges, run everything you own
Mutation Testing
Find out if your tests would notice a real bug
Playwright E2E
End-to-end tests that never need a sleep
Property-Based Testing
Let the generator find the edge case you missed
pytest Suites
Strict, fast pytest suites with clean fixtures
Test Data Factories
Valid test data by default, only relevant fields shown
Testcontainers
Real databases in tests, started once and reset fast
Testing Library
Component tests that query like a screen reader
Unit Testing
Tests that survive refactors and catch real bugs
Visual Regression
Screenshot tests that fail on real change, not noise
Vitest Testing
Vitest suites with no leaking mocks or hung timers
Ansible Playbooks
Second run, zero changes
Argo CD GitOps
Every cluster change is a reviewed, revertable commit
Blue-Green and Canary Deploys
Ship gradually, roll back in one command
Chaos Engineering
Break one thing on purpose, with an abort button
CI Pipeline Speed
Shorten the critical path, prove it with medians
DNS and TLS Certificates
Records verified at the source, certs that renew themselves
Docker Compose
One command to a working local stack
Dockerfile Optimization
Smaller images, cached builds, no root, no leaks
GitHub Actions
Faster CI, read-only tokens, zero stored cloud keys
GitLab CI
One pipeline per change, jobs that start early
Grafana Dashboards
Broken, where, since when: answered in 30 seconds
Helm Charts
Charts that render clean and upgrade safely
Incident Response
Stop the bleeding first, explain it later
Kubernetes Autoscaling
Scale on the right signal, before latency breaks
Kubernetes Deploy
Rollouts that finish, pods that stay up
Linux Troubleshooting
Name the saturated resource, with evidence
Log Analysis
Count, compare to baseline, then read
Nginx Reverse Proxy
Proxy configs proven with curl, not hope
Nix Dev Environments
One command, the exact tools CI uses
OpenTelemetry
One request, one connected trace
Prometheus Alerting
Pages that mean act now, routed to one thread
Pulumi IaC
Real code for infra, with previews you actually read
SLOs and Error Budgets
Page when the budget burns, not when a graph wiggles
systemd Services
Units that restart sanely and run sandboxed
Terraform IaC
Read the plan before the plan reads you
AWS CDK
CDK diffs you can trust before you hit deploy
AWS CloudFront
Private origins, small cache keys, high hit ratios
AWS ECS on Fargate
Containers that deploy, drain and roll back cleanly
AWS IAM Least Privilege
Exact permissions, and AccessDenied solved by evidence
AWS Lambda
Fast cold starts, safe retries, no silent drops
AWS Messaging
Queues, topics and buses that survive duplicates
AWS RDS and Aurora
Right engine, tested failover, no surprise I/O bill
Azure Container Apps
Revisions, KEDA scaling and secrets without passwords
Azure Functions
Current models, managed identity and handled poison queues
Cloud Cost Audit
Find the money, prove it, cut it with sign-off
Google Cloud Run
Containers tuned for concurrency, cost and calm rollouts
Cloudflare Workers
Right storage per binding, typed env, one-command rollback
Firebase Backend
Query-shaped Firestore models guarded by tested rules
Fly.io Apps
Machines, volumes and regions configured on purpose
Google BigQuery
Scan less, pay less, know who spent what
Netlify Deploys
Builds, redirects and functions that behave per context
PaaS Deploys
Render, Railway or Heroku, configured from the repo
S3 and R2 Object Storage
Private buckets, presigned uploads, no surprise bills
Supabase Backend
Treat the database as the security boundary it is
Vercel Deploys
Reproducible builds, scoped env vars, instant rollback
VPS Deployment
One server, done properly: TLS, backups, no-drop deploys
Backup and Restore
Backups count only after a timed restore
ClickHouse Analytics
Sorting keys that skip 99% of granules
Connection Pooling
Pools sized to database cores, not request counts
Drizzle ORM
Typed SQL, reviewed migrations, zero drift
DuckDB Analytics
SQL over Parquet and CSV files, no warehouse needed
DynamoDB Modeling
Keys designed from queries, not from entity diagrams
Elasticsearch Search
Explicit mappings, measured relevance, sane shards
MongoDB Modeling
Model documents for reads, not for an ERD
MySQL Tuning
Fix the top digests, keep replicas caught up
Neo4j Graphs
Graph models anchored on indexes, traversals bounded
Postgres Full-Text Search
Real search in the database you already run
Postgres Indexing
Every index justified by a plan, every drop by data
Postgres JSONB
Flexible documents without giving up indexes
Postgres Schema Design
Tables where bad data simply cannot land
Prisma ORM
Read the SQL Prisma writes before it hits prod
Redis Patterns
Caches, limits and locks that survive a flush
Postgres Row-Level Security
Tenant isolation the database enforces and tests prove
Zero-Downtime Migrations
Change live tables without a maintenance window
SQL Query Tuning
Find the slow plan node, fix the estimate behind it
SQLAlchemy ORM
Typed models, owned sessions, loads you chose on purpose
SQLite in Production
One file, real pragmas, no more database is locked
TimescaleDB Time-Series
Hypertables, rollups and retention sized to your ingest
Transactions and Locking
Name the race, pick the lock, prove it under load
Airflow DAGs
Airflow 3 DAGs that parse fast and rerun cleanly
Analytics SQL
Stated grain, no fan-out, numbers that reconcile
BI Dashboards
One definition per number, one owner per dashboard
CSV Cleaning
From mojibake and shifted columns to clean UTF-8
Data Anonymization
Share data without sharing the people in it
Data Pipelines
Rerun any day, get the same data
Data Quality Checks
Catch bad data before the dashboard does
Data Visualization
Charts that make one point, honestly
dbt Models
Declared grain, tested keys, idempotent increments
Dimensional Modeling
Declare the grain, conform the dimensions
Experiment Analysis
A/B decisions you can defend
Geospatial Analysis
Right CRS, indexed joins, maps you can trust
Jupyter Notebooks
Restart, run all, same answer every time
Kafka Streaming
Keyed order, durable writes, idempotent consumers
Lakehouse with Apache Iceberg
One catalog, pruned scans, maintenance on a schedule
Pandas Analysis
Every row accounted for, every number reproducible
Polars DataFrames
Lazy plans, pushed-down filters, no row loops
PySpark Jobs
Fewer shuffles, no stragglers, right-sized files
Statistical Testing
The right test, an effect size, honest corrections
Streamlit Apps
Data apps that do not re-query on every click
Time-Series Forecasting
Beat seasonal naive on a real backtest first
Web Scraping
Polite scrapers that notice when sites change
Agent Memory
Remember what matters, forget on request
Computer-Use Agents
Agents that click safely, inside a sandbox
Computer Vision
Detectors that hold up on your real cameras
Content Moderation
Policy first, thresholds from data, humans for the gray zone
Document Extraction with LLMs
Invoices to validated JSON, with evidence per field
Fine-Tuning
Fine-tune only after the prompt baseline plateaus
Hugging Face Transformers
Pinned models, right templates, correct padding
Image Generation
Consistent image sets, priced per accepted image
LLM App Builder
Ship LLM features with timeouts, streams, and budgets
LLM Batch Jobs
Every input accounted for, at batch prices
LLM Classification
Labels that match careful humans, per class
LLM Evals
Know whether the change helped, with error bars
LLM Gateway Routing
Fallbacks that are tested, retries that cannot snowball
LLM Observability
Trace any bad answer back to its exact prompt
Local LLMs
Size it, quantize it, benchmark it, then serve
MLOps Tracking
Trace any production model back to code and data
Model Serving
Self-hosted LLM endpoints sized to a real SLO
Multi-Agent Orchestration
Parallel agents only where they pay for themselves
Prompt Caching and Costs
Cut the LLM bill with caching before downgrades
Prompt Engineering
Prompts measured against evals, not eyeballed
Prompt Injection Defense
Contain what an injected instruction can do
PyTorch Training
Overfit one batch, resume exactly, then scale
RAG Pipelines
Fix retrieval first, then make answers cite it
Realtime Voice Agents
Answer fast, stop when interrupted, never talk over callers
Recommendation Systems
Beat the popularity baseline where it counts: online
Speech-to-Text
Transcripts measured by WER on your own audio
Structured Outputs
Schema-valid JSON, then checks on what it says
Synthetic Data
Generated data that beats real-only on real tests
Text-to-Speech
Natural voice output without seams or misreads
Tool-Use Agents
Tools the model can pick right, loops that stop
Vector Search
ANN tuned against exact search, with filters on
API Security
Prove every endpoint denies the wrong user
Auth and Sessions
Login, sessions and recovery an attacker can't shortcut
Authorization Models
One decision point, default deny, tested matrix
Bot and Fraud Defense
Stop credential stuffing without taxing real users
Cloud Security Posture
Find the public bucket before someone else does
Container Security
Minimal images, non-root pods, scanned on every build
Cryptography Basics
Right primitive, vetted library, no novel designs
GDPR Privacy Engineering
Data maps, consent, and deletion you can actually prove
Input Validation
Safe sinks first, schemas second, payload tests always
JWT Handling
Verify, never just decode
MFA Implementation
Second factors with no back door left open
Mobile App Security
Ship an app binary with nothing worth stealing
OAuth 2.1 and OIDC
PKCE, state and nonce, checked every single time
OWASP Top 10 Review
Findings with file:line evidence, not vague advice
Passkeys and WebAuthn
Phishing-resistant sign-in with a recovery path to match
SAML SSO
Enterprise single sign-on without the XML bypasses
Secrets Management
Rotate first, rewrite history second
Secure File Uploads
Uploads that can't execute, escape, or exhaust you
Security Headers
Strict CSP shipped without breaking production
Security Logging
Audit trails that answer who did what, and page on it
Semgrep Rules
Custom rules with tests, tuned to zero noise
SOC 2 Readiness
Controls engineers actually run, with evidence on tap
Supply Chain Audit
Triage every CVE instead of just counting them
Threat Modeling
Find design flaws before they become incidents
Vulnerability Triage
Turn 900 scanner CVEs into the dozen that matter
Async Concurrency
Parallel I/O with limits, timeouts, and backpressure
Bundle Analysis
Cut the initial JS users actually download
Core Web Vitals
Fix the sub-part that is actually slow
Go pprof Profiling
The profile picks the hot path; benchstat judges the fix
HTTP Caching
Year-long assets, always-fresh HTML, zero leaks
Image Optimization
Right size, modern format, loaded at the right time
JVM Tuning
GC logs and JFR first, then a short flag set with reasons
Lighthouse CI
Fail the PR when pages get slower, not later
Memory Leak Hunting
From growing heap to the exact retaining reference
N+1 Queries
Query counts that stay flat as data grows
Node.js Profiling
Flamegraphs and event loop lag, not guesses
Python Profiling
Find the slow line before rewriting anything
React Re-renders
Profile first, memoize last
Rendering Strategies
Static where you can, per-request only where you must
TTFB Optimization
Find the slow phase of the first byte, then fix only that
Web Font Loading
Fonts that arrive early and move nothing when they swap
Web Workers
Get heavy computation off the main thread, measured
ADR Records
Decisions your team can still explain next year
Backend for Frontend
Add a BFF or gateway only for a named problem
C4 Diagrams
Architecture diagrams as code that newcomers can read
Cache Invalidation
Staleness budgets, closed races, no stampedes
Capacity Planning
Know which resource runs out first, and when
CQRS and Event Sourcing
Event-source only what truly needs history
Data Partitioning
Pick shard keys from data, not from hope
Domain-Driven Design
Code boundaries that match how the business works
Event-Driven Architecture
Events that survive duplicates, crashes and reordering
Feature Flags
Gradual rollouts, instant rollback, no flag graveyard
Fitness Functions
Architecture rules that fail the build, not reviews
Hexagonal Architecture
Business logic that runs without a framework attached
Idempotency and Retries
Retry anything without charging anyone twice
Modular Monolith
Service-grade boundaries inside one deployable
Multi-Tenancy
No leaks between customers, no noisy neighbors
Rate Limiting
Atomic limits, honest headers, clients that back off
Resilience Patterns
One slow dependency should never sink the service
Saga Transactions
Multi-service transactions that undo cleanly, without 2PC
Service Boundaries
Split services on evidence, not fashion
System Design Review
Turn 'it scales' into numbers and ranked findings
Android Architecture
Layers, Hilt and modules that keep Android apps testable
App Store Release
Signed, reviewed and rolled out without surprises
Deep Links
One https URL that opens the right screen everywhere
Fastlane CI
One command from commit to TestFlight and Play
Flutter Widgets
Small const widgets, one state owner, no overflow stripes
In-App Purchases
Subscriptions that unlock, renew and refund correctly
iOS Architecture
SwiftUI apps with real boundaries and injected services
iOS Widgets
Fresh widgets and Live Activities without reload spam
Jetpack Compose
Stateless screens, StateFlow state, no recomposition storms
Kotlin Multiplatform
Share the logic, keep the native feel on Android and iOS
Mobile Accessibility
Apps that work with VoiceOver, TalkBack and huge text
Mobile Biometric Auth
Face ID that guards a key, not a boolean
Mobile Performance
Faster launches and smooth lists, proven on real devices
Mobile Push Notifications
Delivered, opted-in, and opening the right screen
Offline Sync
Local-first writes that never vanish or duplicate
React Native with Expo
Dev builds, Expo Router and OTA updates that are safe
SwiftUI Views
Clear state ownership and navigation that scales
Brand Identity
A brand you can recognize with the logo covered
Color Systems
OKLCH palettes where every pair passes contrast
Dark Mode
Right theme on the first frame, legible everywhere
Dashboard UI
Every widget answers a question you can name
Design System Tokens
Semantic tokens, so a new theme is one file
Email Design
HTML email that survives Outlook, Gmail and dark mode
Empty and Error States
No blank screens, no endless spinners, no dead ends
Figma to Code
Build what the designer meant, not just what they drew
Form UX Design
Fewer fields, clearer errors, more finished forms
Information Architecture
Navigation built from user tasks and tested labels
Landing Page Design
Pages with a point of view, not a SaaS template
Mobile UI Patterns
Apps that feel native, not like a site in a wrapper
Onboarding Flows
Get new users to their first real outcome, fast
Pricing Page Design
Buyers find their plan and real cost in a minute
Responsive Layouts
Layouts that fit the content, not a device list
SVG Icons
One grid, currentColor, and names screen readers say
Typography Scale
One ratio, readable measure, zero font shift
UI Motion
Fast, purposeful motion with real numbers
UX Heuristics Review
Task-based findings with severity and fixes
Contract Analysis
Cited clause tables and deadlines, not legal advice
Document Redaction
Remove the data, not just hide it under a box
Word Documents (.docx)
Styled, editable Word files that survive review
EPUB Ebooks
Ebooks that pass epubcheck and read well anywhere
Financial Models
Live formulas, one input sheet, a balance check at zero
Google Sheets Automation
Batched, idempotent Sheets jobs that respect quotas
HTML to PDF
Print CSS that breaks pages where you meant
Invoice Generation
Gapless numbers, exact cents, immutable invoices
LaTeX Documents
Clean builds, resolved citations, no ?? in the PDF
Markdown Publishing
One Markdown source, clean PDF, DOCX and HTML
Mermaid Diagrams
Diagrams as code that render on the first try
OCR for Scans
Searchable scans with measured, not assumed, accuracy
PDF Toolkit
Inspect first, then extract, merge, fill or generate
PowerPoint Decks (.pptx)
On-brand slides you've actually looked at
Report Automation
Recurring reports that refuse to send bad numbers
Excel Spreadsheets (.xlsx)
Live formulas, real number formats, zero #REF!
API Documentation
First successful call in under five minutes
Case Studies
Results with baselines, quotes the customer approved
Changelog and Release Notes
Tell users what changed for them, not what you typed
Conference Talks
Proposals that get accepted, talks that land
Design Docs and RFCs
Proposals that end in a recorded decision
Dev Blog Posts
Engineering stories with a point, proof and code
Docs Site
Docs people can navigate, search and trust
Help Center Articles
Customers find the answer and never open a ticket
Onboarding Docs
New engineers productive on day one, not week three
Postmortems
Blameless reviews with numbers and owned actions
PRD Writing
Requirements engineers can estimate and test
Prose Editing
Cut a third, keep the meaning and the voice
README Writer
From landing on the repo to a working result
Resume Writing
Impact bullets with real numbers, never invented ones
Runbooks
From page to mitigation without asking anyone
Status Updates
Readers know where it stands in 30 seconds
Style Guides
One voice and one term list, enforced in CI
Technical Writing
Docs that get one reader to one goal
UX Microcopy
Labels that say exactly what will happen
Airtable API
Field IDs, 10-record batches, and verified webhooks
Auth Providers
Hosted login wired in, authorization kept server-side
Calendar Scheduling
Bookings that survive DST, races, and Outlook
Discord Bots
Slash-command bots that never miss the 3-second window
Email Deliverability
From p=none to p=reject without losing real mail
GitHub API Automation
Bulk GitHub changes with dry runs and throttling
Google Workspace APIs
Drive, Calendar, Gmail and Sheets with minimal scopes
HubSpot CRM
Upserts, labeled associations and loop-free CRM sync
Jira and Linear APIs
Ticket automation that never files the same bug twice
Media CDN
Signed uploads, signed URLs, no surprise media bills
Merchant of Record Billing
Sell globally while the MoR owes the VAT and sales tax
Microsoft Graph
Outlook, OneDrive and Teams calls with fenced permissions
Notion API
Notion sync scripts that page, pace and chunk
Plaid Banking
Bank linking with encrypted tokens and cursor-based sync
Product Analytics
One person per user, one name per event
Salesforce API
JWT auth, Bulk 2.0 loads and CDC-driven CRM sync
Search Integration
Search that ranks right and never drifts from the DB
Sentry Error Tracking
Readable stack traces, quiet quotas, useful alerts
Shopify Apps
GraphQL-first Shopify apps that pass review
Slack Apps
Bolt apps that ack in time and ask for few scopes
Stripe Payments
Webhook-driven checkout that never double-charges
Transactional Email
Receipts and resets that reach the inbox
Twilio Messaging
Texts that get delivered and stay compliant
AI Search Optimization
Get cited in AI answers without gaming anything
Analytics Tracking Plan
Every event traced to a decision and verified live
App Store Optimization
More store impressions, more of them installing
Cold Outreach
Fewer, truer cold emails that people answer
Competitor Analysis
Sourced rival research that ends in decisions
Content Refresh
Fix the pages that are actually decaying, and only those
Conversion Optimization
Research-led A/B tests sized before they start
Email Campaigns
Lifecycle emails triggered by behavior, judged by lift
International SEO
The right language version, in every market
Keyword Research
A ranked page plan instead of a 5,000-row export
Landing Page Copy
Copy a competitor could not paste onto their page
Local SEO
Win the map pack without risking a suspension
Pricing Strategy
Prices that scale with the value customers get
Product Launch
Launch-day attention turned into activated users
Programmatic SEO
Thousands of pages, each one worth indexing
Referral Programs
Referral rewards you can afford and fraud can't farm
Schema Markup
JSON-LD that earns rich results and matches the page
SEO Content Briefs
Briefs built from the SERP, not from keyword density
SEO Site Migration
Move domains or platforms and keep your traffic
Social Media Posts
Platform-native posts with hooks that pay off
Technical SEO
Every page you want indexed, provably indexable
ECS Architecture
Data-oriented design without the cargo cult
Game AI and Pathfinding
Agents that route well, decide clearly, never stall
Game Performance
Hit the frame budget with captures, not hunches
Game Physics
Fixed steps, no tunneling, bugs you can replay
Godot Games
Typed GDScript, clean scenes, exports that build
Multiplayer Netcode
Instant input, honest servers, no rubber-banding
Phaser Games
HTML5 games that load clean and play on phones
Procedural Generation
Seeded worlds that replay exactly and always work
Shader Programming
GPU code with named spaces and no NaN speckles
Three.js Scenes
Correct color, compressed assets, zero GPU leaks
Unity Development
Unity 6 C# that stays fast and stays organized
Unreal Engine 5
C++ foundations, Blueprint flexibility, clean cooks
Arduino Projects
Sketches that never block and never cook a pin
Embedded Rust
no_std firmware with one owner per peripheral
ESP32 Firmware
Wi-Fi that reconnects, partitions that still fit
Firmware OTA Updates
Updates that survive power cuts and bad builds
FreeRTOS Tasks
Tasks that block, ISRs that defer, stacks that fit
Low-Power Firmware
Measured microamps, not datasheet wishes
MQTT for IoT
Topics, QoS and ACLs that scale past ten devices
Raspberry Pi Projects
Headless Pi builds that survive a pulled plug
Serial Protocols
Capture the bus before blaming the firmware
STM32 HAL Firmware
CubeMX projects that survive regeneration and real traffic
Zephyr RTOS
Devicetree and Kconfig without the guesswork
Customer Feedback Analysis
From ticket noise to ranked, revenue-aware problems
Feature Prioritization
Rankings anyone can challenge, cut lines that hold
Jobs to Be Done
Find the progress customers hire you for
Launch Readiness
Go/no-go calls backed by evidence, not vibes
Meeting Facilitation
Meetings that end in decisions and named owners
OKR Planning
Key results that measure change, not activity
Product Discovery
Test the risky assumption before writing code
Product Metrics
A north star and a metric tree teams can move
Retrospectives
Three owned actions, checked at the next retro
Roadmap Planning
Now, Next, Later roadmaps built on outcomes
Sprint Planning
Commit to what the data says, not what feels good
User Research Synthesis
Findings you can trace back to the quote
User Stories
Thin vertical slices a tester can verify alone
Academic Writing
Papers where every claim matches its evidence
Citation Management
Clean bibliographies built from DOIs, not memory
Fact-Checking
Trace every claim to a primary source you opened
Literature Review
Reproducible searches, verified sources, argued gaps
Market Research
TAM you can defend, every number with a source
Paper Analysis
Map every claim to its evidence before judging
Qualitative Coding
Codebooks, kappa checks and themes backed by quotes
Reproducible Research
One command from raw data to every figure
Survey Design
Questions that map to decisions, samples that hold up
Systematic Reviews
Protocol first, PRISMA counts that actually add up
Technology Evaluation
Pick tools with evidence, a PoC and an exit plan
Browser Automation
Script browser chores that resume, not break
CLI Tool Building
CLIs that work for humans and in pipes
Dotfiles Management
One command to a working machine, zero secrets in git
Email Automation
Process every message once, never reply to robots
Git Hooks Automation
Fast commit hooks backed by the same checks in CI
Home Assistant
Automations that fire right and explain themselves
macOS Automation
Shortcuts, AppleScript and launchd that just keep running
n8n Workflows
n8n automations that retry safely and report failures
No-Code Automation
Zaps and scenarios that run once, alert and stay cheap
Scheduled Jobs
Cron jobs safe to rerun, overlap-proof and watched
Task Runners
One command menu for every repo, same in CI
Terminal Productivity
A fast shell where everything is a few keys away
Windows Automation
Scheduled tasks and installs that run with nobody logged in
No skill matches that yet.
Try a broader term, or .