Skip to main content
skill CX Codex

graphql-expert · travisjneuman — Claude Code skill: what it does, how to install

graphql-expert — a skill for Claude Code guides GraphQL schema design, resolver implementation, and query optimization. Runs when drafting schemas or resolving N+1 bottlenecks.

MIT 132 installs ★ 114 updated 2026-11-10

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add travisjneuman/.claude --skill graphql-expert -a claude-code
Open on GitHub

What graphql-expert does

This skill guides the agent through architecting GraphQL APIs. It enforces naming conventions, default nullability patterns, dedicated input types for mutations, and root type definitions across queries and subscriptions.

Modular reference files cover pagination, sorting, batch mutations, resolver context, and error formatting. Performance practices rely on DataLoader for N+1 query elimination, alongside depth limits and persisted queries. Client setup files also cover Apollo Client and React hooks.

All schemas are verified against an included checklist. It checks PascalCase naming, mutation payloads, and pagination across all list fields.

What it helps with

  • design GraphQL schemas with consistent nullability and input types
  • resolve N+1 query bottlenecks in resolvers using DataLoader
  • set up context-based or directive-based authorization
  • enforce query depth and complexity limits on incoming operations

Example prompts for the agent

  • Design a GraphQL schema for a blog with paginated user posts
  • Write resolvers using DataLoader to fix N+1 queries when fetching authors
  • Review this GraphQL schema against the schema checklist

How to install graphql-expert

1Skills CLI (Vercel)

npx skills add travisjneuman/.claude --skill graphql-expert -a claude-code

2Manually: put the files in place

~/.claude/skills/graphql-expert/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/graphql-expert/

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

Questions about graphql-expert

How to install graphql-expert in Claude Code?

Run npx skills add travisjneuman/.claude --skill graphql-expert -a claude-code.

What does graphql-expert do?

It guides coding agents on designing GraphQL schemas, building resolvers, handling errors, and configuring subscriptions.

What performance optimizations are covered?

The skill includes DataLoader implementations for N+1 queries, persisted queries, and controls for query depth and complexity.

Source text

SKILL.md · MIT
---
name: graphql-expert
description: GraphQL API design and implementation. Use when building GraphQL APIs, designing schemas, implementing resolvers, or optimizing GraphQL performance.
---

# GraphQL Expert

Comprehensive guide for designing and implementing GraphQL APIs.

## GraphQL Fundamentals

### What is GraphQL?

```
GraphQL is a query language for APIs that:
✓ Lets clients request exactly what they need
✓ Gets multiple resources in one request
✓ Uses a type system to describe data
✓ Provides introspection (self-documenting)

GraphQL vs REST:
┌─────────────────────────────────────────┐
│ REST: Multiple endpoints, fixed shapes  │
│ GET /users/1                            │
│ GET /users/1/posts                      │
│ GET /users/1/followers                  │
├─────────────────────────────────────────┤
│ GraphQL: Single endpoint, flexible      │
│ POST /graphql                           │
│ query { user(id: 1) {                   │
│   name                                  │
│   posts { title }                       │
│   followers { name }                    │
│ }}                                      │
└─────────────────────────────────────────┘
```

---

## Schema Design

### Type System

```graphql
# Scalar Types (built-in)
String, Int, Float, Boolean, ID

# Custom Scalar
scalar DateTime
scalar JSON

# Object Type
type User {
  id: ID!
  email: String!
  name: String
  createdAt: DateTime!
  posts: [Post!]!
}

# Enum
enum Role {
  ADMIN
  USER
  GUEST
}

# Interface
interface Node {
  id: ID!
}

type User implements Node {
  id: ID!
  # ... other fields
}

# Union
union SearchResult = User | Post | Comment

# Input Type (for mutations)
input CreateUserInput {
  email: String!
  name: String!
  role: Role = USER
}
```

### Nullability

```graphql
# Field modifiers:
String      # Nullable string
String!     # Non-null string
[String]    # Nullable list of nullable strings
[String!]   # Nullable list of non-null strings
[String]!   # Non-null list of nullable strings
[String!]!  # Non-null list of non-null strings

# Best practice:
# - Make fields nullable by default
# - Use ! only when guaranteed non-null
# - Lists should usually be non-null: [Item!]!
```

### Schema Structure

```graphql
# Root Types
type Query {
  # Read operations
  user(id: ID!): User
  users(limit: Int, offset: Int): [User!]!
  me: User
}

type Mutation {
  # Write operations
  createUser(input: CreateUserInput!): User!
  updateUser(id: ID!, input: UpdateUserInput!): User!
  deleteUser(id: ID!): Boolean!
}

type Subscription {
  # Real-time updates
  userCreated: User!
  messageReceived(roomId: ID!): Message!
}
```

---

## Reference files

Detailed material is in separate files so this overview stays short. Read only the file whose topic matches the task; each one is self-contained. Paths are relative to the folder that holds this `SKILL.md` (in the full toolkit install, `~/.claude/skills/graphql-expert/`).

| Topic | File | Covers |
| --- | --- | --- |
| Query Design | [`references/query-design.md`](references/query-design.md) | Basic Queries; Pagination; Filtering & Sorting |
| Mutations | [`references/mutations.md`](references/mutations.md) | Mutation Design; Batch Mutations |
| Resolvers | [`references/resolvers.md`](references/resolvers.md) | Basic Resolvers; Resolver Context |
| Performance Optimization | [`references/performance-optimization.md`](references/performance-optimization.md) | DataLoader (N+1 Solution); Query Complexity; Query Depth Limiting; Persisted Queries |
| Authentication & Authorization | [`references/authentication-and-authorization.md`](references/authentication-and-authorization.md) | Context-Based Auth; Directive-Based Auth |
| Error Handling | [`references/error-handling.md`](references/error-handling.md) | Error Types; Error Formatting |
| Subscriptions | [`references/subscriptions.md`](references/subscriptions.md) | Setup; With Filtering |
| Client Integration | [`references/client-integration.md`](references/client-integration.md) | Apollo Client Setup; React Hooks |
| Best Practices | [`references/best-practices.md`](references/best-practices.md) | DO:; DON'T: |

## Schema Checklist

- [ ] Types named descriptively (singular, PascalCase)
- [ ] Consistent nullability patterns
- [ ] Input types for all mutations
- [ ] Payload types with error handling
- [ ] Pagination for all lists
- [ ] Authentication/authorization considered
- [ ] Performance optimizations in place

© travisjneuman · MIT · travisjneuman/.claude

Similar skills

All skills for Backend and APIs →

graphql-expert by other authors comes first.

graphql-expert martinholovsky graphql-expert is a Claude Code skill for designing GraphQL schemas, building resolvers, and working with federation. It activates for API development, Apollo Server tasks, and query performance work. CX Codex +1 220installs graphql-expert personamanagmentlayer graphql-expert is a Claude Code skill for GraphQL schema design, resolvers, and subscriptions, with guidance on Apollo federation and N+1 queries. CX Codex +1 169installs graphql-schema-designer patricio0312rev graphql-schema-designer is a Claude Code skill for shaping GraphQL APIs with types, queries, mutations, subscriptions, and resolvers. It activates for requests about schema design, GraphQL setup, or Apollo Server. CX Codex +1 230installs graphql-implementation secondsky graphql-implementation — a skill for Claude Code, Codex, Cursor, and other agents that designs GraphQL schemas, writes resolvers, sets up DataLoader, and wires error handling. CX Codex +1 400installs graphql davila7 Guides Claude Code in designing GraphQL schemas, batching database queries with DataLoader, and preventing nested query DoS attacks. CX Codex +1 124installs rest-to-graphql-migrator patricio0312rev rest-to-graphql-migrator — a skill that walks a REST API over to GraphQL one endpoint at a time, wrapping existing routes instead of rebuilding the backend. CX Codex +1 277installs graphql-performance-optimizer davila7 graphql-performance-optimizer is a Claude Code subagent that diagnoses slow GraphQL APIs and changes resolvers or caching. It activates for N+1 queries, pagination bottlenecks, and federation latency. CX Codex 599installs graphql-development Mindrally graphql-development — a skill that gives the agent GraphQL guidelines: schema design, type-safe clients, React and Next.js integration. Useful when it writes resolvers and queries. CX Codex +1 701installs

From the same set117

The whole set →
battle-card-builder battle-card-builder builds sales battle cards, competitive comparisons, and structured objection scripts using an 8-part framework. CX Codex +1 137installs serverless-development serverless-development — a skill for AI coding on serverless compute: AWS Lambda, Vercel Edge, Cloudflare Workers. Useful when an API or webhook has to scale on its own. CX Codex +1 133installs growth-engineering growth-engineering is a Claude Code skill with architecture patterns for feature flags, A/B testing, PLG funnels, and referral tracking. CX Codex +1 133installs email-systems email-systems — a skill for Claude Code that guides transactional email setup, template design, and deliverability records. Runs when configuring sending infrastructure, building HTML templates, or troubleshooting inboxing. CX Codex +1 132installs ar-vr-xr ar-vr-xr is a Claude Code skill that guides AR, VR, and XR app design for Unity, WebXR, Apple, and Meta, including spatial interactions, interfaces, and performance. CX Codex +1 125installs blockchain-web3 The blockchain-web3 skill supports Solidity contracts, dApps, DeFi, NFTs, and EVM work. Use it when you need contract security checks or Web3 wallet integration. CX Codex +1 109installs data-engineering The data-engineering Claude Code skill covers data pipelines and warehouse schema design. It activates for ETL/ELT work, stream processing, and dbt transformations. CX Codex +1 105installs compliance-engineering The compliance-engineering Claude Code skill covers implementing SOC 2, HIPAA, GDPR, PCI-DSS, and FedRAMP requirements in code. It comes into play when adding audit logs, encryption, or access controls to a system. CX Codex +1 102installs

Project sponsors

Companies that keep this analytics open