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
npx skills add curiositech/some_claude_skills --skill reactive-dashboard-performance -a claude-codeWhat 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-code2Manually: put the files in place
~/.claude/skills/reactive-dashboard-performance/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/reactive-dashboard-performance/
1Skills CLI (Vercel)
npx skills add curiositech/some_claude_skills --skill reactive-dashboard-performance -a codex2Manually: put the files in place
.agents/skills/reactive-dashboard-performance/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add curiositech/some_claude_skills --skill reactive-dashboard-performance -a cursor2Manually: put the files in place
.cursor/skills/reactive-dashboard-performance/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install curiositech/some_claude_skills .claude/skills/reactive-dashboard-performance2Manually: put the files in place
.github/skills/reactive-dashboard-performance/SKILL.md1Skills CLI (Vercel)
npx skills add curiositech/some_claude_skills --skill reactive-dashboard-performance -a gemini-cli2Platform CLI
gemini skills install https://github.com/curiositech/some_claude_skills --path .claude/skills/reactive-dashboard-performanceManually: put the files in place
.devin/skills/reactive-dashboard-performance/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add curiositech/some_claude_skills --skill reactive-dashboard-performance -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
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 <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 | <100ms |
| Full interactive | <200ms |
| Lazy widgets | <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