paulpas/agent-skill-router - Page 2

java-kotlin-best-practices

Implements best practices for Java/Kotlin applications using Spring Boot, leveraging Maven/Gradle, JVM tuning, and Jakarta EE patterns.

memory-management-and-concurrency

Explores essential software engineering principles for C/C++, focusing on memory management techniques, CMake usage, RAII, and concurrency primitives to build robust applications.

microservices-pattern

Implements microservices architecture patterns, including service discovery, inter-service communication, and data management techniques.

software-architecture-event-driven

Implements event-driven architecture, detailing event sourcing, message brokers, and consumer strategies for handling events efficiently.

software-architecture-hexagonal

Guides the implementation of hexagonal (ports and adapters) architecture, focusing on best practices for decoupling business logic from external concerns.

software-architecture-microservices

Implements strategies for designing, developing, and deploying microservices architecture. Offers guidance on best practices, patterns, and anti-patterns for microservices.

software-architecture-monolith

Guides the design and implementation of monolithic architecture, focusing on best practices and pitfalls in monolithic systems.

ci-cd-pipeline-design

Implements strategies for automation in building, testing, and deploying software through continuous integration and delivery principles.

security-owasp-top-10

Provides an in-depth analysis of the OWASP Top 10 vulnerabilities, along with strategies to mitigate them effectively in software applications.

testing-contract

Validates external APIs and service contracts, ensuring that your application correctly consumes and produces expected data structures.

testing-end-to-end

Facilitates end-to-end testing of complete workflows, verifying entire systems operate as intended from a user's perspective.

testing-integration

Executes integration tests to validate combined components and their interactions in a system, ensuring workflows operate seamlessly.

testing-unit

Implements unit testing strategies using popular frameworks to ensure the smallest parts of your application work as intended.

gatling

Implements load testing strategies using Gatling for performance testing of web applications and microservices.

k6

Implements best practices for load testing web applications using K6, a modern performance testing tool optimized for developers.

locust

Implements load testing strategies using Locust to simulate user behavior and assess application performance, ensuring that systems are prepared for real-world traffic conditions effectively while providing actionable insights for optimization, scalability,…

software-testing-best-practices

Explains various software testing methodologies including unit testing, integration testing, and system testing with best practices.

agent-memory-systems

Implements memory systems for LLM agents including conversation buffers, windowed context, bounded model context management, and vector store-backed long-term memory retrieval with embeddings.

agent-multi-agent-orchestration

Implements multi-agent orchestration patterns (CrewAI sequential crews, AutoGen group chat, supervisor-worker hierarchy, task guardrails) to coordinate specialized agents on complex workflows.

agent-planning-reasoning

Implements planning and reasoning patterns for LLM agents including ReAct loops with native tool calling, modern LangGraph state graphs, and self-reflection quality evaluation loops.

agent-tool-calling-architecture

Implements tool calling architecture (Pydantic schemas, function-to-schema conversion, output parsing with error recovery, parallel execution with fallback chains) for LLM agents in Python.

rag-pipeline-architecture

Implements production-quality RAG pipelines combining semantic document chunking, hybrid BM25+vector search, cross-encoder and LLM-based re-ranking, and reciprocal rank fusion for maximum retrieval quality.

react-advanced-patterns

Implements advanced React patterns including render props, higher-order components, custom hooks composition, portals, error boundaries, and ref forwarding for complex component architectures.

react-async-waterfalls

Eliminates async request waterfalls in React applications by parallelizing data fetching, hoisting fetches to route and page level, and using streaming SSR with Suspense boundaries.

react-bundle-size

Optimizes JavaScript bundle size in React applications through route-level code splitting, tree shaking configuration, granular imports, dynamic imports, and CI bundle size budgets.

react-client-data-fetching

Implements efficient client-side data fetching in React using TanStack Query with proper caching, stale time configuration, error boundaries, optimistic updates, and query key conventions.

react-composition-patterns

Implements React composition patterns including compound components, state lifting, polymorphic components, slot-based layouts, and variant-driven designs for reusable component APIs.

react-js-performance

Optimizes JavaScript execution performance in React applications through efficient event handling, debouncing/throttling, Web Worker offloading, and DOM operation reduction.

react-native-animation

Implements smooth, performant animations in React Native using Reanimated for UI thread animations, Animated API with native driver, gesture-driven interactions, and layout animations.

react-native-list-performance

Optimizes React Native FlatList and SectionList performance through windowing, item memoization, getItemLayout, and efficient rendering strategies for smooth scrolling.

react-native-monorepo-config

Configures React Native projects in monorepo environments using npm/yarn workspaces, Metro bundler, shared packages, and cross-platform module resolution.

react-native-navigation

Implements navigation in React Native using React Navigation with type-safe TypeScript configuration, deep linking, screen lifecycle management, and performance optimization.

react-native-rendering

Optimizes React Native component rendering through virtualization, memoization, image optimization, and efficient component architecture for mobile performance.

react-native-state-management

Manages application state in React Native using Context API, Zustand, Redux Toolkit, and Jotai with proper persistence, middleware, and re-render optimization for mobile.

react-native-ui-patterns

Implements responsive, accessible, and consistent UI components in React Native using Flexbox layouts, theme systems with dark mode support, platform-specific styling, and safe area handling.

react-rerender-optimization

Reduces unnecessary React component re-renders using targeted memoization (React.memo, useMemo, useCallback), stable key props for list rendering, atomic state management, and context value stabilization.

react-server-performance

Optimizes React server rendering performance using Server Components, streaming SSR with Suspense boundaries, React.cache deduplication, static generation, and ISR caching strategies.

react-view-transitions

Implements smooth page transitions and element animations using the View Transition API in React applications with CSS animation recipes and progressive enhancement.

vercel-cli-token-deploy

Deploys projects to Vercel using the Vercel CLI with token-based authentication for CI/CD environments, preview deployments, and production releases.

vercel-deploy

Deploys frontend applications to Vercel with preview deployments, production releases, and environment-specific configuration management via Git integration.