server-components — Claude Code skill: what it does, install
This skill explains React Server Components in Next.js, including client boundaries, composition patterns, and data fetching choices.
MIT 158 installs ★ 3,785 updated 2026-10-25
npx skills add davepoon/buildwithclaude --skill server-components -a claude-codeWhat server-components does
The skill covers React Server Components in the Next.js App Router. It explains the server-first default, when 'use client' is needed, how data moves into interactive components, and how sensitive values stay on the server.
Its guidance includes the Server/Client boundary, children composition, named slots, async components, parallel requests, and streaming with Suspense. It also points to examples and reference files for composition and data fetching. A Client Component cannot import a Server Component, so that import direction needs checking before restructuring a tree.
What it helps with
- separate a component tree at the server-client boundary
- pass fetched data into an interactive component
- decide where to place the
'use client'directive - compose layouts with
childrenand slots - run independent data requests in parallel
Example prompts for the agent
- Review this Next.js page and mark each component as Server or Client.
- Show how to pass fetched data from the page into an interactive list through
props. - Rewrite these independent requests to run in parallel, then stream the slow section with
Suspense.
How to install server-components
1Skills CLI (Vercel)
npx skills add davepoon/buildwithclaude --skill server-components -a claude-code2Manually: put the files in place
~/.claude/skills/server-components/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/server-components/
1Skills CLI (Vercel)
npx skills add davepoon/buildwithclaude --skill server-components -a codex2Manually: put the files in place
.agents/skills/server-components/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add davepoon/buildwithclaude --skill server-components -a cursor2Manually: put the files in place
.cursor/skills/server-components/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install davepoon/buildwithclaude plugins/nextjs-expert/skills/server-components2Manually: put the files in place
.github/skills/server-components/SKILL.md1Skills CLI (Vercel)
npx skills add davepoon/buildwithclaude --skill server-components -a gemini-cli2Platform CLI
gemini skills install https://github.com/davepoon/buildwithclaude --path plugins/nextjs-expert/skills/server-componentsManually: put the files in place
.devin/skills/server-components/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add davepoon/buildwithclaude --skill server-components -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 server-components
How do I install server-components in Claude Code?
Run npx skills add davepoon/buildwithclaude --skill server-components -a claude-code, then check ~/.claude/skills/server-components/SKILL.md.
What does server-components do?
It guides React Server Components architecture in Next.js, covering client boundaries, composition, data fetching, and the choice between server and client execution.
Can a Client Component import a Server Component?
No. Server Components may import Client Components. To place server-rendered content inside a client wrapper, pass it through children or a slot.
Source text
SKILL.md · MIT
---
name: server-components
description: This skill should be used when the user asks about "Server Components", "Client Components", "'use client' directive", "when to use server vs client", "RSC patterns", "component composition", "data fetching in components", or needs guidance on React Server Components architecture in Next.js.
version: 1.0.0
---
# React Server Components in Next.js
## Overview
React Server Components (RSC) allow components to render on the server, reducing client-side JavaScript and enabling direct data access. In Next.js App Router, all components are Server Components by default.
## Server vs Client Components
### Server Components (Default)
Server Components run only on the server:
```tsx
// app/users/page.tsx (Server Component - default)
async function UsersPage() {
const users = await db.user.findMany() // Direct DB access
return (
<ul>
{users.map(user => (
<li key={user.id}>{user.name}</li>
))}
</ul>
)
}
```
**Benefits:**
- Direct database/filesystem access
- Keep sensitive data on server (API keys, tokens)
- Reduce client bundle size
- Automatic code splitting
### Client Components
Add `'use client'` directive for interactivity:
```tsx
// components/counter.tsx
'use client'
import { useState } from 'react'
export function Counter() {
const [count, setCount] = useState(0)
return (
<button onClick={() => setCount(count + 1)}>
Count: {count}
</button>
)
}
```
**Use Client Components for:**
- `useState`, `useEffect`, `useReducer`
- Event handlers (`onClick`, `onChange`)
- Browser APIs (`window`, `document`)
- Custom hooks with state
## The Mental Model
Think of the component tree as having a "client boundary":
```
Server Component (page.tsx)
├── Server Component (header.tsx)
├── Client Component ('use client') ← boundary
│ ├── Client Component (child)
│ └── Client Component (child)
└── Server Component (footer.tsx)
```
**Key rules:**
1. Server Components can import Client Components
2. Client Components cannot import Server Components
3. You can pass Server Components as `children` to Client Components
## Composition Patterns
### Pattern 1: Server Data → Client Interactivity
Fetch data in Server Component, pass to Client:
```tsx
// app/products/page.tsx (Server)
import { ProductList } from './product-list'
export default async function ProductsPage() {
const products = await getProducts()
return <ProductList products={products} />
}
// app/products/product-list.tsx (Client)
'use client'
export function ProductList({ products }: { products: Product[] }) {
const [filter, setFilter] = useState('')
const filtered = products.filter(p =>
p.name.includes(filter)
)
return (
<>
<input onChange={e => setFilter(e.target.value)} />
{filtered.map(p => <ProductCard key={p.id} product={p} />)}
</>
)
}
```
### Pattern 2: Children as Server Components
Pass Server Components through children prop:
```tsx
// components/client-wrapper.tsx
'use client'
export function ClientWrapper({ children }: { children: React.ReactNode }) {
const [isOpen, setIsOpen] = useState(false)
return (
<div>
<button onClick={() => setIsOpen(!isOpen)}>Toggle</button>
{isOpen && children} {/* Server Component content */}
</div>
)
}
// app/page.tsx (Server)
import { ClientWrapper } from '@/components/client-wrapper'
import { ServerContent } from '@/components/server-content'
export default function Page() {
return (
<ClientWrapper>
<ServerContent /> {/* Renders on server! */}
</ClientWrapper>
)
}
```
### Pattern 3: Slots for Complex Layouts
Use multiple children slots:
```tsx
// components/dashboard-shell.tsx
'use client'
interface Props {
sidebar: React.ReactNode
main: React.ReactNode
}
export function DashboardShell({ sidebar, main }: Props) {
const [collapsed, setCollapsed] = useState(false)
return (
<div className="flex">
{!collapsed && <aside>{sidebar}</aside>}
<main>{main}</main>
</div>
)
}
```
## Data Fetching
### Async Server Components
Server Components can be async:
```tsx
// app/posts/page.tsx
export default async function PostsPage() {
const posts = await fetch('https://api.example.com/posts')
.then(res => res.json())
return (
<ul>
{posts.map(post => (
<li key={post.id}>{post.title}</li>
))}
</ul>
)
}
```
### Parallel Data Fetching
Fetch multiple resources in parallel:
```tsx
export default async function DashboardPage() {
const [user, posts, analytics] = await Promise.all([
getUser(),
getPosts(),
getAnalytics(),
])
return (
<Dashboard user={user} posts={posts} analytics={analytics} />
)
}
```
### Streaming with Suspense
Stream slow components:
```tsx
import { Suspense } from 'react'
export default function Page() {
return (
<div>
<Header /> {/* Renders immediately */}
<Suspense fallback={<PostsSkeleton />}>
<SlowPosts /> {/* Streams when ready */}
</Suspense>
</div>
)
}
```
## Decision Guide
**Use Server Component when:**
- Fetching data
- Accessing backend resources
- Keeping sensitive info on server
- Reducing client JavaScript
- Component has no interactivity
**Use Client Component when:**
- Using state (`useState`, `useReducer`)
- Using effects (`useEffect`)
- Using event listeners
- Using browser APIs
- Using custom hooks with state
## Common Mistakes
1. **Don't** add `'use client'` unnecessarily - it increases bundle size
2. **Don't** try to import Server Components into Client Components
3. **Do** serialize data at boundaries (no functions, classes, or dates)
4. **Do** use the children pattern for composition
## Resources
For detailed patterns, see:
- `references/server-vs-client.md` - Complete comparison guide
- `references/composition-patterns.md` - Advanced composition
- `examples/data-fetching-patterns.md` - Data fetching examples
© davepoon · MIT · davepoon/buildwithclaude