Database

Expert guidance for building declarative React charts with Recharts

Expert guidance for building low-level, composable React visualizations with visx

Accessible form design patterns including labels, validation, error handling, and multi-step forms

ARIA roles, states, and properties for building accessible custom widgets and UI components

Automated accessibility testing with axe-core, including CI integration, custom rules, and result analysis

Color contrast ratios, visual accessibility, and inclusive design for users with low vision or color blindness

Focus management strategies for single-page applications, modals, route changes, and dynamic content

Keyboard navigation patterns, focus order, and shortcut design for fully keyboard-accessible interfaces

Building web content that works correctly with screen readers like NVDA, JAWS, and VoiceOver

WCAG 2.2 compliance levels, success criteria, and implementation strategies for accessible web content

Reduce JavaScript bundle size through tree shaking, dependency analysis, and build configuration tuning.

Design effective browser and CDN caching strategies using Cache-Control headers, ETags, service workers, and edge caching.

Reduce initial load time with route-based and component-level code splitting using dynamic imports and framework-specific patterns.

Optimize Largest Contentful Paint, First Input Delay, and Cumulative Layout Shift for better user experience and search rankings.

Optimize database queries through indexing, query planning, N+1 elimination, connection pooling, and schema design.

Optimize image delivery with modern formats, responsive sizing, lazy loading, and CDN-based transformations.

Prevent memory leaks and optimize memory usage through proper cleanup patterns, profiling, and garbage collection awareness.

Improve time-to-first-byte and perceived performance with server-side rendering, static generation, and streaming patterns.

Style terminal output with chalk and picocolors for colored, formatted CLI text

Build beautiful interactive CLI prompts using @clack/prompts with minimal boilerplate

Package and distribute CLI tools via npm/npx, standalone binaries with pkg, and Homebrew taps

Test CLI applications using subprocess execution, mock filesystems, and snapshot testing

Build structured CLI applications with Commander.js including commands, options, and argument parsing

Build rich interactive terminal UIs using Ink, a React renderer for the command line

Build production-grade, extensible CLI tools using the oclif framework with TypeScript

Add progress indicators to CLI tools using ora and nanospinner for async operation feedback

Service workers and background scripts for event-driven extension logic, lifecycle management, and persistent tasks

Content scripts for DOM manipulation, page interaction, and isolated world execution in browser extensions

Cross-browser extension compatibility across Chrome, Firefox, and Safari with API normalization and build strategies

Publishing browser extensions to Chrome Web Store and Firefox Add-ons including review processes and automation

Chrome Manifest V3 fundamentals including configuration, permissions, and migration from V2

Message passing between extension components including content scripts, service workers, popups, and external pages

Building popup and options page UIs for browser extensions with responsive layouts and framework integration

Extension storage APIs and state management patterns including sync, local, and session storage

API authentication patterns including OAuth 2.0, JWT, and API keys for securing HTTP APIs

OpenAPI and Swagger documentation practices for generating accurate, maintainable API references

Error response design and HTTP status code conventions for consistent, actionable API error reporting

Pagination patterns including cursor-based, offset, and keyset pagination for efficient list endpoints

API versioning strategies for evolving APIs without breaking existing consumers

GraphQL schema design patterns for building flexible, efficient, and evolvable query APIs

RESTful API design principles for building consistent, intuitive, and scalable HTTP APIs

Webhook design and delivery patterns for reliable, secure event-driven API integrations

CDN setup and optimization with Cloudflare, Fastly, and CloudFront for global content delivery

This skill elucidates the hierarchical, distributed nature of the Domain Name System, covering its core components and resolution process. Activate it when designing, deploying, or troubleshooting reliable and performant name resolution infrastructure.

DNS configuration, record management, and resolution strategies for reliable domain infrastructure

Load balancing patterns, algorithms, and tools for distributing traffic across backend services

Network security patterns including firewalls, DDoS protection, WAFs, and intrusion detection

Reverse proxy configuration with Nginx and Caddy for routing, TLS termination, and request handling

Service mesh patterns with Istio and Linkerd for observability, traffic management, and mTLS

SSL/TLS certificate management, HTTPS configuration, and transport security best practices

You master the foundational protocols of the internet, TCP and IP. Activate this skill when designing network architectures, troubleshooting connectivity issues, or optimizing data transmission for robust and efficient systems.

VPN and private networking patterns for secure inter-service and remote access connectivity

Create nominally distinct types from structural primitives using phantom brands.

Implement fluent, type-accumulating builders that enforce required fields at compile time.

Branch at the type level with conditional expressions, infer, and distributive behavior.

Model mutually exclusive states with tagged union types and exhaustive narrowing.

Constrain generic type parameters to enforce structural and behavioral contracts at compile time.

Extend third-party and global type declarations without modifying source using module augmentation.

Construct and parse string-level types using template literal syntax for compile-time string validation.

Narrow types at runtime with user-defined type predicates and assertion functions.