PluginBench
Skill
Pass
Audit score 90

tanstack-query-best-practices

deckardger/tanstack-agent-skills

TanStack Query best practices for optimized data fetching, caching, and server state management in React.

What is tanstack-query-best-practices?

Comprehensive guidelines for implementing TanStack Query (React Query) patterns in React applications. Covers query keys, caching strategies, mutations, error handling, prefetching, infinite queries, SSR integration, and performance optimization. Use when building data-driven React apps with server state management.

  • Provides 32+ best-practice rules organized by priority (Critical, High, Medium, Low)
  • Covers query key structure and hierarchical organization to prevent cache bugs
  • Defines caching strategies including staleTime, gcTime, and targeted invalidation
  • Implements mutation patterns with optimistic updates and rollback handling
  • Guides error handling, retry configuration, and error boundaries
  • Enables prefetching strategies for improved perceived performance

How to install tanstack-query-best-practices

npx skills add https://github.com/deckardger/tanstack-agent-skills --skill tanstack-query-best-practices
Prerequisites
  • React application with TanStack Query (React Query) installed
  • Understanding of React hooks and component lifecycle
  • Familiarity with async data fetching concepts
Claude Code
Cursor
Windsurf
Cline

How to use tanstack-query-best-practices

  1. 1.Review the rule categories table to understand priority levels and impact areas
  2. 2.Identify which rule categories apply to your current implementation (queries, mutations, caching, etc.)
  3. 3.Consult individual rule files in the rules/ directory for detailed explanations
  4. 4.Compare bad examples against your current code patterns
  5. 5.Implement the recommended good examples in your application
  6. 6.Apply rules progressively, starting with CRITICAL priority rules
  7. 7.Test caching behavior and data consistency after applying rules

Use cases

Good for
  • Setting up query configurations and cache strategies for new React applications
  • Implementing mutations with optimistic updates for responsive user interfaces
  • Configuring prefetching on user intent (hover, focus) and route transitions
  • Integrating TanStack Query with server-side rendering and hydration
  • Refactoring existing data fetching code to follow best practices
Who it's for
  • React developers building data-driven applications
  • Frontend engineers implementing server state management
  • Teams adopting TanStack Query for the first time
  • Developers optimizing existing React Query implementations
  • Full-stack developers working with SSR/SSG patterns

tanstack-query-best-practices FAQ

What is the difference between staleTime and gcTime?

staleTime determines how long data is considered fresh before a background refetch; gcTime (formerly cacheTime) determines how long inactive queries are retained in memory before garbage collection.

When should I use optimistic updates?

Use optimistic updates for mutations that are likely to succeed (e.g., form submissions, toggles) to provide instant UI feedback, but always implement rollback logic in case the mutation fails.

How do I prevent cache inconsistencies?

Use array-based hierarchical query keys that include all dependencies, implement targeted query invalidation after mutations, and use query key factories for complex applications.

What is the HydrationBoundary and when do I need it?

HydrationBoundary wraps your app during SSR to properly hydrate cached query data from the server, ensuring client-side queries match server state and preventing hydration mismatches.

How do I handle offline scenarios?

Configure the network mode setting and implement query persistence to cache data locally, allowing your app to serve stale data when offline and sync when connectivity returns.

Full instructions (SKILL.md)

Source of truth, from deckardger/tanstack-agent-skills.


name: tanstack-query-best-practices description: TanStack Query (React Query) best practices for data fetching, caching, mutations, and server state management. Activate when building data-driven React applications with server state.

TanStack Query Best Practices

Comprehensive guidelines for implementing TanStack Query (React Query) patterns in React applications. These rules optimize data fetching, caching, mutations, and server state synchronization.

When to Apply

  • Creating new data fetching logic
  • Setting up query configurations
  • Implementing mutations and optimistic updates
  • Configuring caching strategies
  • Integrating with SSR/SSG
  • Refactoring existing data fetching code

Rule Categories by Priority

PriorityCategoryRulesImpact
CRITICALQuery Keys5 rulesPrevents cache bugs and data inconsistencies
CRITICALCaching5 rulesOptimizes performance and data freshness
HIGHMutations6 rulesEnsures data integrity and UI consistency
HIGHError Handling3 rulesPrevents poor user experiences
MEDIUMPrefetching4 rulesImproves perceived performance
MEDIUMParallel Queries2 rulesEnables dynamic parallel fetching
MEDIUMInfinite Queries3 rulesPrevents pagination bugs
MEDIUMSSR Integration4 rulesEnables proper hydration
LOWPerformance4 rulesReduces unnecessary re-renders
LOWOffline Support2 rulesEnables offline-first patterns

Quick Reference

Query Keys (Prefix: qk-)

  • qk-array-structure — Always use arrays for query keys
  • qk-include-dependencies — Include all variables the query depends on
  • qk-hierarchical-organization — Organize keys hierarchically (entity → id → filters)
  • qk-factory-pattern — Use query key factories for complex applications
  • qk-serializable — Ensure all key parts are JSON-serializable

Caching (Prefix: cache-)

  • cache-stale-time — Set appropriate staleTime based on data volatility
  • cache-gc-time — Configure gcTime for inactive query retention
  • cache-defaults — Set sensible defaults at QueryClient level
  • cache-invalidation — Use targeted invalidation over broad patterns
  • cache-placeholder-vs-initial — Understand placeholder vs initial data differences

Mutations (Prefix: mut-)

  • mut-invalidate-queries — Always invalidate related queries after mutations
  • mut-optimistic-updates — Implement optimistic updates for responsive UI
  • mut-rollback-context — Provide rollback context from onMutate
  • mut-error-handling — Handle mutation errors gracefully
  • mut-loading-states — Use isPending for mutation loading states
  • mut-mutation-state — Use useMutationState for cross-component tracking

Error Handling (Prefix: err-)

  • err-error-boundaries — Use error boundaries with useQueryErrorResetBoundary
  • err-retry-config — Configure retry logic appropriately
  • err-fallback-data — Provide fallback data when appropriate

Prefetching (Prefix: pf-)

  • pf-intent-prefetch — Prefetch on user intent (hover, focus)
  • pf-route-prefetch — Prefetch data during route transitions
  • pf-stale-time-config — Set staleTime when prefetching
  • pf-ensure-query-data — Use ensureQueryData for conditional prefetching

Infinite Queries (Prefix: inf-)

  • inf-page-params — Always provide getNextPageParam
  • inf-loading-guards — Check isFetchingNextPage before fetching more
  • inf-max-pages — Consider maxPages for large datasets

SSR Integration (Prefix: ssr-)

  • ssr-dehydration — Use dehydrate/hydrate pattern for SSR
  • ssr-client-per-request — Create QueryClient per request
  • ssr-stale-time-server — Set higher staleTime on server
  • ssr-hydration-boundary — Wrap with HydrationBoundary

Parallel Queries (Prefix: parallel-)

  • parallel-use-queries — Use useQueries for dynamic parallel queries
  • query-cancellation — Implement query cancellation properly

Performance (Prefix: perf-)

  • perf-select-transform — Use select to transform/filter data
  • perf-structural-sharing — Leverage structural sharing
  • perf-notify-change-props — Limit re-renders with notifyOnChangeProps
  • perf-placeholder-data — Use placeholderData for instant UI

Offline Support (Prefix: offline-)

  • network-mode — Configure network mode for offline support
  • persist-queries — Configure query persistence for offline support

How to Use

Each rule file in the rules/ directory contains:

  1. Explanation — Why this pattern matters
  2. Bad Example — Anti-pattern to avoid
  3. Good Example — Recommended implementation
  4. Context — When to apply or skip this rule

Full Reference

See individual rule files in rules/ directory for detailed guidance and code examples.