Skip to main content
skill CX Codex

reactive-dashboard-performance — Claude Code skill: how to install

reactive-dashboard-performance sets up React dashboard performance patterns and speeds up async test suites. Helps replace spinners with skeletons and resolve test runner timeouts.

MIT 220 installs ★ 274 updated 2026-10-30

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add curiositech/some_claude_skills --skill reactive-dashboard-performance -a claude-code
Open on GitHub

What reactive-dashboard-performance does

This skill guides the agent through performance architectures inspired by Linear, Notion, and Vercel. It prioritizes skeleton renders within 16ms, streaming data progressively without spinners for sub-200ms requests. For state handling, it applies React Query configs with a 5-minute staleTime, 30-minute cacheTime, and optimistic UI updates.

The second section focuses on fixing fragile test setups. It enforces testing real DOM nodes instead of mocking React UI widgets, isolating only network boundaries through tools like MSW. When integration tests hang, the diagnostic protocol directs the agent to inspect the DOM with screen.debug() and replace synchronous getBy* queries with asynchronous findBy* calls.

Without a proper TestProviders wrapper supplying QueryClientProvider, async component tests will fail immediately on missing context.

What it helps with

  • replace slow spinners with instant skeleton loading
  • fix integration test timeouts caused by race conditions
  • configure aggressive data caching in React Query
  • apply React.lazy and component-level code splitting

Example prompts for the agent

  • Debug why our dashboard integration test is timing out
  • Configure React Query caching rules for this analytics view
  • Refactor the dashboard layout to use skeleton-first loading

How to install reactive-dashboard-performance

1Skills CLI (Vercel)

npx skills add curiositech/some_claude_skills --skill reactive-dashboard-performance -a claude-code

2Manually: put the files in place

~/.claude/skills/reactive-dashboard-performance/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/reactive-dashboard-performance/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about reactive-dashboard-performance

How to install reactive-dashboard-performance in Claude Code?

Run npx skills add curiositech/some_claude_skills --skill reactive-dashboard-performance -a claude-code in your terminal. This creates the skill file at ~/.claude/skills/reactive-dashboard-performance/SKILL.md.

What does reactive-dashboard-performance do?

It provides guidelines for optimizing React dashboard render cycles and resolving async testing failures. The rules cover caching strategies, skeleton patterns, and diagnostic steps for hanging test runners.

How does the skill troubleshoot hanging integration tests?

It directs the agent to call screen.debug() to inspect what rendered, check the console for unhandled network calls, and swap getBy* methods for async findBy* queries.

Source text

SKILL.md · MIT
---
name: reactive-dashboard-performance
description: Expert in building blazing-fast reactive dashboards with comprehensive testing. Masters React performance patterns, testing strategies for async components, and real-world patterns from Linear,
  Vercel, Notion.
allowed-tools:
- Read
- Write
- Edit
- Bash
- Grep
- Glob
version: 1.0.0
triggers:
- dashboard performance
- slow tests
- reactive testing
- integration tests timeout
- dashboard optimization
metadata:
  category: Frontend Development
  tags:
  - react
  - performance
  - testing
  - dashboard
  - optimization
  pairs-with:
  - skill: react-performance-optimizer
    reason: Dashboard performance depends on React memoization, virtualization, and state management
  - skill: admin-dashboard
    reason: Admin dashboards are the primary consumer of reactive dashboard performance patterns
  - skill: data-viz-2025
    reason: Dashboard charts and graphs require performant data visualization rendering
---

# Reactive Dashboard Performance

Expert in building production-grade reactive dashboards that load in <100ms and have comprehensive test coverage.

## Core Expertise

### Performance Patterns (Linear, Vercel, Notion-grade)

1. **Skeleton-First Loading**
   - Render skeleton immediately (0ms perceived load)
   - Stream in data progressively
   - Never show spinners for <200ms loads

2. **Aggressive Caching**
   - React Query with staleTime: 5min, cacheTime: 30min
   - Optimistic updates for mutations
   - Prefetch on hover/mount

3. **Code Splitting**
   - Route-based splitting (Next.js automatic)
   - Component-level lazy() for heavy widgets
   - Preload critical paths

4. **Memoization Strategy**
   - useMemo for expensive computations
   - React.memo for pure components
   - useCallback for stable references

### Testing Reactive Dashboards

1. **Mock Strategy**
   - Mock at service boundary (React Query, analytics)
   - Never mock UI components (test real DOM)
   - Use MSW for API mocking when possible

2. **Async Handling**
   ```typescript
   // WRONG - races with React
   render(<Dashboard />);
   const element = screen.getByText('Welcome');

   // RIGHT - waits for async resolution
   render(<Dashboard />);
   const element = await screen.findByText('Welcome');
   ```

3. **Timeout Debugging**
   - Timeouts mean: missing mock, wrong query, or component not rendering
   - Use screen.debug() to see actual DOM
   - Check console for unmocked errors

4. **Test Wrapper Pattern**
   ```typescript
   const TestProviders = ({ children }) => (
     <QueryClientProvider client={testQueryClient}>
       <AuthProvider>
         {children}
       </AuthProvider>
     </QueryClientProvider>
   );
   ```

### Real-World Examples

- **Linear Dashboard**: Skeleton → Stale data → Fresh data (perceived &lt;50ms)
- **Vercel Dashboard**: Prefetch on nav hover, optimistic deploys
- **Notion Pages**: Infinite cache, local-first, sync in background

## Diagnostic Protocol

### Integration Test Timeouts

1. **Check what's actually rendering**
   ```typescript
   render(<Component />);
   screen.debug(); // See actual DOM
   ```

2. **Find unmocked dependencies**
   - Check console for "not a function" errors
   - Look for network requests in test output
   - Verify all contexts are provided

3. **Fix async queries**
   - Use findBy* instead of getBy*
   - Increase timeout if needed: `waitFor(() => {...}, { timeout: 3000 })`
   - Mock React Query properly

4. **Simplify component tree**
   - Test widgets individually first
   - Add full integration tests last
   - Use data-testid for complex queries

## Performance Optimization

### Dashboard Load Budget

| Phase | Target |
|-------|--------|
| Skeleton render | 0-16ms (1 frame) |
| First data paint | &lt;100ms |
| Full interactive | &lt;200ms |
| Lazy widgets | &lt;500ms |

### React Query Config

```typescript
const queryClient = new QueryClient({
  defaultOptions: {
    queries: {
      staleTime: 5 * 60 * 1000, // 5min
      cacheTime: 30 * 60 * 1000, // 30min
      refetchOnWindowFocus: false,
      refetchOnMount: false,
      retry: 1,
    },
  },
});
```

### Skeleton Pattern

```typescript
function Dashboard() {
  const { data, isLoading } = useQuery('dashboard', fetchDashboard);

  // Show skeleton immediately, no loading check
  return (
    <div>
      {data ? <RealWidget data={data} /> : <SkeletonWidget />}
    </div>
  );
}
```

## Common Pitfalls

1. **Spinners for fast loads** - Use skeletons instead
2. **Unmemoized expensive computations** - Wrap in useMemo
3. **Testing implementation details** - Test user behavior
4. **Mocking too much** - Mock at boundaries only
5. **Synchronous test expectations** - Everything is async

When debugging test timeouts, ALWAYS start with `screen.debug()` to see what actually rendered.

© curiositech · MIT · curiositech/some_claude_skills

Similar skills

All skills for Frontend and UI →

From the same set180

The whole set →
seo-visibility-expert seo-visibility-expert configures technical SEO, llms.txt files for AI scrapers, and schema markup. Useful when preparing web projects for launch. CX Codex +1 224installs mcp-creator mcp-creator is a Claude Code skill for building MCP servers that connect agents to external services. It activates on requests to create or develop an MCP server. CX Codex +1 222installs chatbot-analytics chatbot-analytics adds conversation monitoring and token usage tracking for AI chats while respecting HIPAA constraints. CX Codex +1 221installs technical-writer technical-writer structures developer docs, API references, ADRs, and runbooks using the Diátaxis framework with working code examples. CX Codex +1 221installs devops-automator devops-automator — a skill that turns your AI coder into a DevOps engineer: designs pipelines, writes Terraform and Kubernetes configs, sets up GitOps. Use it when building infrastructure or automating deployments. CX Codex +1 219installs bot-developer The bot-developer skill guides bot development for Discord, Telegram, and Slack, covering conversation state, API limits, and moderation. Use it when a bot needs multi-step interactions or automated rules. CX Codex +1 218installs prompt-engineer prompt-engineer — a skill for crafting and debugging prompts. Eliminates hallucinations, improves response consistency, and strengthens agent instructions through systematic optimization techniques. CX Codex +1 217installs team-builder team-builder designs team structures using organizational psychology. When a required role is missing from the skill library, it writes a new skill right away. CX Codex +1 216installs

More in the catalog

Project sponsors

Companies that keep this analytics open