How to use the GraphQL Architect agent skill

What the GraphQL Architect skill makes the agent do

GraphQL is a way to define an API as a typed schema that clients query for exactly the fields they need. This skill focuses on the design and server-side work around that schema. It guides the agent to model business data as a GraphQL schema, split that schema across services using Apollo Federation, write resolvers that avoid repeated database lookups with DataLoader, add query complexity and depth limits, and set up real-time subscriptions.

The skill also includes reference notes on schema design, resolvers, federation, subscriptions, security and migrating from REST. It contains sample schema, resolver and complexity-check code that the agent can adapt to your project.

• Schema design: types, interfaces, unions, enums and input types, with a schema-first approach
• Federation: subgraphs, entities and federation directives such as @key and @shareable
• Resolvers: batching with DataLoader to prevent N+1 query problems
• Security: query depth limits, complexity analysis and field-level authorization
• Subscriptions: real-time updates over WebSockets and pub/sub patterns
• Migration: moving a REST API to GraphQL

Install the GraphQL Architect skill

Download the skill ZIP from the item page on this site. Then choose one of the two installation methods below.

For a personal setup available across your projects, unzip the download into ~/.claude/skills/. To limit the skill to one project, unzip it into that project's .claude/skills/ folder instead.

If you use the Claude apps, you can upload the ZIP instead. Open Settings, go to Capabilities, then Skills, and upload the file there.

• Personal install: unzip into ~/.claude/skills/
• Project install: unzip into the project's .claude/skills/ folder
• Claude apps: Settings → Capabilities → Skills, then upload the ZIP

How to trigger the skill with natural requests

You do not need a special command. The skill's description says it should be used when designing GraphQL schemas, implementing Apollo Federation, or building real-time subscriptions, so ask for those tasks in plain language. Mentioning GraphQL, Apollo Federation, DataLoader or subscriptions in your request makes it clear which skill applies.

Be specific about your situation. Name your server, your data model and the problem you are solving, because the skill gives generic guidance that the agent must adapt to your code.

• Design a schema for an e-commerce catalogue with products, orders and reviews, using Apollo Server.
• Split our users, orders and inventory services into Apollo Federation subgraphs.
• Our reviews resolver runs one database query per review. Fix the N+1 problem with DataLoader.
• Add a query complexity limit to our Apollo Server and explain which fields are most expensive.
• Add real-time order status updates using GraphQL subscriptions over WebSockets.
• Help me plan migrating our REST endpoints for the mobile app to GraphQL.

What a typical result looks like

When the skill is in use, the agent's output follows a consistent pattern. It typically provides a schema definition in SDL with types and directives, a resolver implementation that uses DataLoader, example queries, mutations or subscriptions, and a short explanation of the design decisions.

The skill's own workflow also asks the agent to validate the schema with a composition check when using federation, and to confirm that entity keys resolve correctly. If you run that check yourself, you can compare the agent's result against it.

• Schema definition (SDL with types and directives)
• Resolver implementation with DataLoader patterns
• Query, mutation and subscription examples
• Brief explanation of design decisions

What the skill needs before you use it

The skill produces code, so you need an existing or planned GraphQL server and someone technical to run and maintain it. The examples use Apollo Server. Other libraries the skill relies on are DataLoader, the graphql-query-complexity library for the complexity example, and Apollo Federation if you use federation.

The skill does not run scripts and does not use the network, according to the item details.

• Apollo Server or a compatible GraphQL server (examples use Apollo Server)
• DataLoader library
• graphql-query-complexity library (for the complexity example)
• Apollo Federation 2 setup, if you use federation

Safety notes and what to review before deploying

The skill's guidance is generic. Schemas, security rules and authorization logic it generates must be checked against your actual data and auth model before they reach production. The skill itself says to avoid hardcoding authorization logic, but the agent still needs your real rules to write it correctly.

Review the complexity limit before deployment. The example sets a maximum complexity and logs each query's score. Choose a threshold based on your own queries rather than the sample value.

• Do not deploy generated schemas or security rules without review by someone who knows your data.
• Check that the example complexity threshold suits your queries before using it.
• Test federation changes with composition checks before rolling them out.
• Keep sensitive internal fields out of the schema; the skill advises against exposing implementation details.