Autonomous Agents122 skills

Autonomous Agent skills for AI agents

122 practitioner-grade autonomous agent skills, each a focused Markdown document your agent loads into context on demand. Search them from Claude Desktop, Cursor or any MCP client, or pull one with the CLI.

$ npx skilldb search "autonomous agent"

All 122 skills

Abstraction Control
Avoiding over-abstraction and unnecessary complexity by choosing the simplest solution that solves the actual problem
92 lines
Accessibility Implementation
Making web content accessible through ARIA attributes, semantic HTML, keyboard navigation, screen reader support, color contrast, focus management, and WCAG compliance.
83 lines
API Design Patterns
Designing and implementing clean APIs with proper REST conventions, pagination, versioning, authentication, and backward compatibility.
93 lines
API Integration
Integrating with external APIs effectively — reading API docs, authentication patterns, error handling, rate limiting, retry with backoff, response validation, SDK vs raw HTTP decisions, and API versioning.
126 lines
Assumption Validation
Detecting and validating assumptions before acting on them to prevent cascading errors from wrong guesses
85 lines
Authentication Implementation
Implementing authentication flows correctly including OAuth 2.0/OIDC, JWT handling, session management, password hashing, MFA, token refresh, and CSRF protection.
84 lines
Background Job Scheduling
Implementing scheduled and recurring jobs including cron patterns, scheduler selection, timezone handling, overlap prevention, distributed scheduling, and monitoring.
123 lines
Batch Processing
Processing large data sets efficiently with chunking, streaming, and partial failure recovery
81 lines
Browser Verification
Using browser automation to verify visual and interactive changes rather than relying solely on code-level testing
93 lines
Build System Interaction
Working with build tools, understanding build pipelines, interpreting build errors, and managing development vs production builds effectively.
87 lines
Caching Strategies
Implementing effective caching at every level including browser, CDN, application, and database caching with proper invalidation, TTL management, and stampede prevention.
82 lines
Checkpoint Strategy
Creating save points during long autonomous work to ensure rollback is always possible
73 lines
CI/CD Pipeline Management
Understanding and modifying CI/CD pipelines across GitHub Actions, GitLab CI, and other systems, including debugging failures and adding stages safely.
85 lines
Clipboard Operations
Working with the clipboard API for copy, paste, and rich content handling
86 lines
Code Generation Patterns
Generating clean, idiomatic code that follows language conventions, consistent naming, proper file organization, and formatting standards so output looks human-written.
74 lines
Code Review Self
Systematically reviewing your own generated code before presenting it, catching issues a human reviewer would flag
111 lines
Code Style Matching
Detecting and matching the existing code style of a project — indentation, naming, formatting, and patterns — so that new code blends in seamlessly.
93 lines
Codebase Navigation
Efficient strategies for understanding unfamiliar codebases through entry points, pattern recognition, and progressive mental model building
109 lines
Communication With User
Effective communication during autonomous work — when to give status updates, how to present options, asking targeted questions, showing work without overwhelming, tone calibration, admitting uncertainty, and summarizing changes concisely.
110 lines
Concurrency Patterns
Understanding and implementing concurrent code with async/await, Promises, thread safety, race conditions, and strategies for debugging timing-dependent bugs.
89 lines
Configuration File Management
Reading, modifying, and creating configuration files correctly while preserving formatting, understanding conventions, and managing environment-specific settings.
89 lines
Context Management
Managing limited context windows effectively through information triage, summarization, structured note-taking, and working memory optimization
123 lines
Cross-Browser Compatibility
Ensuring applications work across browsers using feature detection, polyfills, progressive enhancement, testing strategies, and graceful degradation.
118 lines
Cross-Cutting Concerns
Handling concerns like logging, authentication, and caching that span multiple modules
70 lines
CSS Architecture
Writing maintainable CSS at scale — BEM, CSS Modules, CSS-in-JS, utility-first patterns, theming with custom properties, specificity management, responsive design, and dark mode implementation.
94 lines
Dark Mode Implementation
Implementing theme switching with CSS custom properties, system preference detection, and persistence
99 lines
Data Extraction and Transformation
Techniques for extracting, parsing, cleaning, and transforming data across formats like CSV, JSON, XML, and more, including handling malformed input and large files.
84 lines
Data Validation Patterns
Validating data at system boundaries — schema validation, input sanitization, error message design, and choosing between fail-fast and collect-all-errors strategies.
105 lines
Database Operations
Safe database interaction patterns including SQL query construction, migration writing, transaction handling, and read/write operation safety.
88 lines
Dead Code Cleanup
Identifying and safely removing dead code during modifications without breaking hidden dependencies or dynamic references
96 lines
Debugging Strategies
Systematic approaches to finding and fixing bugs — hypothesis-driven debugging, bisection, stack trace reading, issue reproduction, variable isolation, log analysis, and avoiding shotgun debugging.
86 lines
Dependency Analysis
Understanding and managing project dependencies — reading manifest files, version conflict resolution, transitive dependency awareness, security audits, minimal dependency philosophy, and lock file handling.
116 lines
Dependency Injection Patterns
Understanding and implementing dependency injection — constructor injection, DI containers, inversion of control, and knowing when DI adds value vs when it is over-engineering.
77 lines
DNS and Networking Basics
Networking fundamentals for development including DNS, HTTP/HTTPS, TCP/UDP, CORS, SSL/TLS, load balancing, reverse proxies, and network debugging techniques.
120 lines
Docker Container Management
Working with Docker for development and deployment, including Dockerfile best practices, compose patterns, image optimization, and container debugging.
78 lines
Documentation Generation
Writing useful documentation during development — README structure, inline comments, API documentation, architecture decision records, changelog entries, doc-as-code philosophy, and keeping docs close to code.
153 lines
Drag and Drop Implementation
Implementing drag and drop interfaces with touch support, accessibility, and smooth animations
94 lines
Email and Notification Systems
Building email and notification systems covering SMTP/API sending, template systems, queue-based delivery, bounce handling, unsubscribe compliance, push notifications, and delivery tracking.
108 lines
Environment Setup
Setting up and troubleshooting development environments across platforms, including version managers, virtual environments, PATH issues, and common failure patterns.
82 lines
Error Cascade Prevention
Preventing small errors from compounding into catastrophic failures through checkpoints, verification, and early termination
90 lines
Error Handling Patterns
Implementing robust error handling with try/catch strategies, error hierarchies, error boundaries, graceful degradation, retry logic, and circuit breakers.
97 lines
Error Message Interpretation
Reading and acting on error messages effectively — common error patterns by language and framework, stack trace navigation, distinguishing root cause from symptoms, search strategies for unknown errors, compiler vs runtime errors, and environment issues vs code bugs.
139 lines
Event-Driven Architecture
Implementing event-driven systems — pub/sub patterns, event sourcing, message queues, eventual consistency, and building reliable event handlers.
88 lines
Feature Flag Implementation
Using feature flags for safe deployments including flag types, gradual rollouts, A/B testing, flag cleanup, kill switches, user segmentation, and configuration management.
83 lines
File System Operations
Safe and efficient file system operations including atomic writes, file locks, temp file patterns, directory traversal safety, path normalization, and cross-platform handling.
117 lines
File Upload Handling
Implementing file upload systems including multipart uploads, chunked uploads, validation, virus scanning, storage backends, presigned URLs, and resumable uploads.
122 lines
Form Handling
Implementing robust form systems with validation, accessibility, and state management
86 lines
Git Advanced Operations
Advanced git operations including interactive rebase, cherry-picking, bisect, stash management, submodules, worktrees, reflog recovery, merge strategies, and git hooks.
121 lines
Git Workflow
Proper git usage during autonomous work — commit hygiene, meaningful messages, staging specific files, avoiding destructive operations, branch awareness, merge conflict handling, and preserving user work.
91 lines
Go Patterns
Go development patterns and idioms — error handling, goroutines, channels, interface design, package organization, context propagation, dependency injection, testing, and modules.
102 lines
Graceful Degradation
Building systems that fail partially instead of completely when dependencies are unavailable
77 lines
GraphQL Implementation
Implementing and consuming GraphQL APIs including schema design, resolver patterns, N+1 prevention, mutation design, subscriptions, pagination, error handling, and federation.
108 lines
Hallucination Prevention
Techniques to avoid generating false information by grounding responses in verifiable code and data
73 lines
Idempotency Patterns
Making operations safe to retry without unintended side effects
78 lines
Image and Media Handling
Processing images and media in applications including optimization, responsive images, lazy loading, CDN delivery, video transcoding, and modern format adoption.
120 lines
Incremental Delivery
Delivering work in small verified increments — shipping the simplest working version first, building complexity gradually, verifying each increment, avoiding big-bang changes, keeping the project buildable, and using feature flags for partial work.
103 lines
Infrastructure as Code
Managing infrastructure through code using Terraform, Pulumi, and CloudFormation, with emphasis on state management, safety, and environment separation.
85 lines
Internationalization
Implementing i18n and localization including string externalization, ICU message format, pluralization, date/number/currency formatting, RTL support, locale detection, and translation management.
113 lines
JSON Manipulation
Advanced JSON processing and manipulation including deep merging, path-based access, schema validation, diffing, streaming large files, and preserving key ordering.
107 lines
Keyboard Shortcut Systems
Implementing keyboard shortcuts with modifier keys, scoping, conflict resolution, and discoverability
79 lines
Legacy Code Modification
Safely modifying legacy code without breaking things, including reading undocumented code, adding tests before changing, and applying minimal-impact strategies.
79 lines
Log Analysis
Reading and interpreting application logs effectively, including log level understanding, stack trace parsing, pattern identification, and extracting actionable insights.
88 lines
Markdown Generation
Generating well-formatted Markdown documents with proper heading hierarchy, code blocks, tables, link references, image embedding, escaping, and linting.
121 lines
Memory Leak Detection
Identifying and fixing memory leaks — common leak patterns, heap analysis, profiling tools, garbage collection understanding, and preventive techniques like WeakRef and proper cleanup.
109 lines
Microservices Patterns
Designing and working with microservice architectures including service boundaries, communication patterns, data consistency, and resilience strategies.
85 lines
Migration Strategies
Planning and executing code migrations safely — database migrations, API version upgrades, framework migrations, feature flag driven rollouts, backward compatibility, data migration scripts, rollback plans, and testing migration paths.
161 lines
Modal Dialog Patterns
Implementing modals and dialogs correctly with focus management, accessibility, and interaction patterns
90 lines
Monitoring and Observability
Adding monitoring and observability to applications through metrics collection, structured logging, distributed tracing, health checks, alerting, and SLI/SLO definition.
92 lines
Monorepo Navigation
Working effectively in monorepo codebases with package boundaries, workspace tools, shared dependencies, and scoped changes.
79 lines
Multi File Editing
Coordinating changes across multiple files safely with consistency guarantees, dependency tracking, and partial-update prevention
143 lines
Next.js Patterns
Next.js application development patterns — App Router, server components, server actions, data fetching, middleware, route handlers, static generation, and metadata management.
97 lines
NoSQL Patterns
Working with NoSQL databases effectively — MongoDB document design, Redis data structures, DynamoDB access patterns, denormalization strategies, eventual consistency, secondary indexes, TTL expiration, and atomic operations.
97 lines
Observability Instrumentation
Adding telemetry to code systematically with traces, metrics, and structured logs
75 lines
ORM Patterns
Working with Object-Relational Mappers effectively — Prisma, Sequelize, SQLAlchemy, TypeORM patterns for relation handling, migrations, query optimization, and transaction management.
85 lines
Output Verification
Systematic verification of your own work through testing, diff review, regression checking, and scope validation before presenting results
120 lines
Package Publishing
Publishing packages to registries including npm and PyPI workflows, semantic versioning, changelog generation, pre-publish checks, handling breaking changes, and deprecation.
114 lines
Parallel Task Execution
Running independent subtasks in parallel for efficiency while managing shared state, resource conflicts, and result merging
94 lines
Payment Integration
Integrating payment processing with Stripe/PayPal APIs, handling webhooks, subscriptions, refunds, PCI compliance, currency handling, and tax calculation.
121 lines
PDF Document Generation
Generating PDF documents programmatically including HTML-to-PDF conversion, template-based generation, layout control, compliance, and digital signatures.
121 lines
Performance Optimization
Identifying and fixing performance issues — profiling before optimizing, common bottlenecks, Big-O awareness, caching strategies, lazy loading, measuring before and after, and avoiding premature optimization.
154 lines
Planning Before Coding
How to plan implementation before writing code — requirements analysis, identifying unknowns, architectural decisions, file impact analysis, choosing between approaches, and knowing when a plan is needed vs when to just start.
105 lines
Progress Reporting
Communicating progress effectively during long tasks — when to update, what to share, and how to structure status messages without overwhelming the user.
85 lines
Python Best Practices
Idiomatic Python development — PEP 8 style, type hints, virtual environments, package management, comprehensions, context managers, decorators, dataclasses, and testing with pytest.
99 lines
Queue Processing
Implementing job queues and background processing — queue selection, retry policies, dead letter queues, concurrency control, and reliable idempotent job execution.
111 lines
Rate Limiting Implementation
Implementing rate limiting and throttling — token bucket, sliding window, distributed limiting, response headers, and graceful degradation under load.
89 lines
ReAct Loop Reasoning
The ReAct (Reason + Act) pattern for structured problem solving, alternating between thinking and doing while maintaining a coherent reasoning trace.
66 lines
React Patterns
Modern React development patterns — hooks, custom hooks, component composition, context usage, state management selection, render optimization, error boundaries, and suspense.
89 lines
Refactoring Patterns
Safe refactoring techniques for autonomous agents — extract method/class, rename with propagation, dead code removal, simplifying conditionals, reducing duplication, maintaining backward compatibility, and refactoring in small verified steps.
112 lines
Regex Pattern Crafting
Writing correct and efficient regular expressions for code manipulation, including avoiding catastrophic backtracking, testing strategies, and knowing when regex is the wrong tool.
85 lines
Responsive Design Implementation
Building responsive layouts across devices using mobile-first approaches, flexbox and grid, fluid typography, container queries, and thorough cross-device testing.
81 lines
Risk Assessment
Evaluating risks before taking actions — classifying operations by reversibility, blast radius, and impact to decide when to proceed vs pause and confirm.
84 lines
Rust Fundamentals
Rust development patterns for agents working in Rust codebases — ownership, borrowing, lifetimes, Result/Option handling, traits, generics, error handling, cargo workspaces, and common idioms.
96 lines
Scope Control
Staying focused on what was actually requested — avoiding feature creep, not refactoring code you were not asked to touch, minimal viable changes, recognizing gold-plating, asking before expanding scope, and the discipline of
144 lines
Scope Discipline
Resisting the urge to over-engineer, gold-plate, and bundle unrequested changes with simple fixes
95 lines
Search Implementation
Adding search functionality to applications including full-text search, Elasticsearch/Algolia/Meilisearch patterns, indexing strategies, relevance tuning, and autocomplete.
94 lines
Secret Management
Handling secrets and credentials safely throughout the development lifecycle
77 lines
Security Awareness
Security considerations during code generation — avoiding injection vulnerabilities, secrets management, input validation, safe defaults, recognizing insecure patterns, and OWASP top 10 awareness.
95 lines
Self Correction
How to detect, diagnose, and recover from mistakes during autonomous execution without cascading failures
112 lines
Semantic Code Search
Finding code by meaning and concept rather than exact text matches
73 lines
Serverless Patterns
Building serverless applications with Lambda/Cloud Functions, including cold start optimization, event-driven design, state management, and deployment automation.
104 lines
Session and Cookie Management
Managing sessions and cookies correctly including cookie attributes, session stores, security hardening, consent handling, and token-based alternatives.
115 lines
Shell Command Safety
Executing shell commands safely and effectively, including proper quoting, exit code handling, avoiding destructive operations, and cross-platform compatibility.
101 lines
Specification Interpretation
Correctly interpreting user requirements by reading between the lines, identifying gaps, and building accurate mental models of intent
98 lines
SQL Optimization
Writing efficient SQL queries — index design, EXPLAIN analysis, join optimization, CTEs vs subqueries, pagination techniques, aggregate optimization, parameterized queries, and connection pooling.
94 lines
State Machine Patterns
Using state machines for complex workflows — state definition, transitions, guard conditions, hierarchical states, and knowing when a state machine is the right abstraction.
127 lines
State Management Across Sessions
Maintaining coherent progress and context across context window boundaries and separate agent sessions
115 lines
Structured Output Generation
Producing well-structured, parseable output in formats like JSON, YAML, and TOML with correct syntax, schema adherence, and validation.
77 lines
Sycophancy Resistance
Pushing back on bad ideas instead of blindly executing user requests that will cause problems
69 lines
Table and List Rendering
Building performant data tables and lists with virtualization, sorting, and responsive patterns
86 lines
Task Decomposition
How to break complex tasks into atomic subtasks with dependency awareness, scope estimation, and ambiguity handling
87 lines
Technical Debt Assessment
Identifying, quantifying, and communicating technical debt with actionable remediation plans
72 lines
Test-Driven Workflow
Using tests to drive autonomous development through red-green-refactor cycles, leveraging test failures as navigation signals, and building confidence through coverage.
72 lines
Test Writing
Writing effective tests autonomously — test structure (arrange-act-assert), choosing what to test, edge cases, mocking strategies, integration vs unit decisions, test naming, avoiding brittle tests, and testing error paths.
121 lines
Tool Selection
Choosing the right tool for each subtask based on cost-benefit analysis, parallelization opportunities, and thoroughness calibration
146 lines
Type System Usage
Leveraging type systems effectively across languages including TypeScript, Python, Go, and Rust for safer, more expressive, and self-documenting code.
82 lines
Advanced TypeScript
Advanced TypeScript patterns for agents — generic types, conditional types, mapped types, discriminated unions, type guards, utility types, declaration files, strict mode, and module resolution.
99 lines
Undo Redo Implementation
Implementing undo/redo functionality with command patterns, state history, and memory efficiency
91 lines
URL Routing Patterns
Implementing URL routing in web applications with RESTful design and modern patterns
85 lines
Web Research Synthesis
Effective web research techniques including query formulation, source evaluation, cross-referencing, and synthesizing findings into actionable intelligence.
79 lines
Webhook Integration
Implementing and consuming webhooks with endpoint security, signature verification, idempotency handling, retry logic, payload validation, and dead letter queues.
95 lines
WebSocket Implementation
Real-time communication with WebSockets including connection lifecycle, reconnection strategies, heartbeat patterns, room/channel design, scaling, authentication, and graceful disconnection handling.
109 lines
YAML and TOML Processing
Working with YAML and TOML configuration formats including multiline strings, anchors, TOML tables, comment preservation, common YAML gotchas, and format selection guidance.
116 lines