Skills Marketplace

Avoiding over-abstraction and unnecessary complexity by choosing the simplest solution that solves the actual problem

Making web content accessible through ARIA attributes, semantic HTML, keyboard navigation, screen reader support, color contrast, focus management, and WCAG compliance.

Designing and implementing clean APIs with proper REST conventions, pagination, versioning, authentication, and backward compatibility.

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.

Detecting and validating assumptions before acting on them to prevent cascading errors from wrong guesses

Implementing authentication flows correctly including OAuth 2.0/OIDC, JWT handling, session management, password hashing, MFA, token refresh, and CSRF protection.

Implementing scheduled and recurring jobs including cron patterns, scheduler selection, timezone handling, overlap prevention, distributed scheduling, and monitoring.

Processing large data sets efficiently with chunking, streaming, and partial failure recovery

Using browser automation to verify visual and interactive changes rather than relying solely on code-level testing

Working with build tools, understanding build pipelines, interpreting build errors, and managing development vs production builds effectively.

Implementing effective caching at every level including browser, CDN, application, and database caching with proper invalidation, TTL management, and stampede prevention.

Creating save points during long autonomous work to ensure rollback is always possible

Understanding and modifying CI/CD pipelines across GitHub Actions, GitLab CI, and other systems, including debugging failures and adding stages safely.

Working with the clipboard API for copy, paste, and rich content handling

Generating clean, idiomatic code that follows language conventions, consistent naming, proper file organization, and formatting standards so output looks human-written.

Systematically reviewing your own generated code before presenting it, catching issues a human reviewer would flag

Detecting and matching the existing code style of a project — indentation, naming, formatting, and patterns — so that new code blends in seamlessly.

Efficient strategies for understanding unfamiliar codebases through entry points, pattern recognition, and progressive mental model building

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.

Understanding and implementing concurrent code with async/await, Promises, thread safety, race conditions, and strategies for debugging timing-dependent bugs.

Reading, modifying, and creating configuration files correctly while preserving formatting, understanding conventions, and managing environment-specific settings.

Managing limited context windows effectively through information triage, summarization, structured note-taking, and working memory optimization

Ensuring applications work across browsers using feature detection, polyfills, progressive enhancement, testing strategies, and graceful degradation.

Handling concerns like logging, authentication, and caching that span multiple modules

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.

Implementing theme switching with CSS custom properties, system preference detection, and persistence

Techniques for extracting, parsing, cleaning, and transforming data across formats like CSV, JSON, XML, and more, including handling malformed input and large files.

Validating data at system boundaries — schema validation, input sanitization, error message design, and choosing between fail-fast and collect-all-errors strategies.

Safe database interaction patterns including SQL query construction, migration writing, transaction handling, and read/write operation safety.

Identifying and safely removing dead code during modifications without breaking hidden dependencies or dynamic references

Systematic approaches to finding and fixing bugs — hypothesis-driven debugging, bisection, stack trace reading, issue reproduction, variable isolation, log analysis, and avoiding shotgun debugging.

Understanding and managing project dependencies — reading manifest files, version conflict resolution, transitive dependency awareness, security audits, minimal dependency philosophy, and lock file handling.

Understanding and implementing dependency injection — constructor injection, DI containers, inversion of control, and knowing when DI adds value vs when it is over-engineering.

Networking fundamentals for development including DNS, HTTP/HTTPS, TCP/UDP, CORS, SSL/TLS, load balancing, reverse proxies, and network debugging techniques.

Working with Docker for development and deployment, including Dockerfile best practices, compose patterns, image optimization, and container debugging.

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.

Implementing drag and drop interfaces with touch support, accessibility, and smooth animations

Building email and notification systems covering SMTP/API sending, template systems, queue-based delivery, bounce handling, unsubscribe compliance, push notifications, and delivery tracking.

Setting up and troubleshooting development environments across platforms, including version managers, virtual environments, PATH issues, and common failure patterns.

Preventing small errors from compounding into catastrophic failures through checkpoints, verification, and early termination

Implementing robust error handling with try/catch strategies, error hierarchies, error boundaries, graceful degradation, retry logic, and circuit breakers.

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.

Implementing event-driven systems — pub/sub patterns, event sourcing, message queues, eventual consistency, and building reliable event handlers.

Using feature flags for safe deployments including flag types, gradual rollouts, A/B testing, flag cleanup, kill switches, user segmentation, and configuration management.

Safe and efficient file system operations including atomic writes, file locks, temp file patterns, directory traversal safety, path normalization, and cross-platform handling.

Implementing file upload systems including multipart uploads, chunked uploads, validation, virus scanning, storage backends, presigned URLs, and resumable uploads.

Implementing robust form systems with validation, accessibility, and state management

Advanced git operations including interactive rebase, cherry-picking, bisect, stash management, submodules, worktrees, reflog recovery, merge strategies, and git hooks.

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.

Go development patterns and idioms — error handling, goroutines, channels, interface design, package organization, context propagation, dependency injection, testing, and modules.

Building systems that fail partially instead of completely when dependencies are unavailable

Implementing and consuming GraphQL APIs including schema design, resolver patterns, N+1 prevention, mutation design, subscriptions, pagination, error handling, and federation.

Techniques to avoid generating false information by grounding responses in verifiable code and data

Making operations safe to retry without unintended side effects

Processing images and media in applications including optimization, responsive images, lazy loading, CDN delivery, video transcoding, and modern format adoption.

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.

Managing infrastructure through code using Terraform, Pulumi, and CloudFormation, with emphasis on state management, safety, and environment separation.

Implementing i18n and localization including string externalization, ICU message format, pluralization, date/number/currency formatting, RTL support, locale detection, and translation management.

Advanced JSON processing and manipulation including deep merging, path-based access, schema validation, diffing, streaming large files, and preserving key ordering.

Implementing keyboard shortcuts with modifier keys, scoping, conflict resolution, and discoverability