graphql-architect
Use when designing GraphQL schemas, implementing Apollo Federation, or building real-time subscriptions. Invoke for schema design, resolvers with DataLoader, query optimization, federation directives.
Best use case
graphql-architect is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Use when designing GraphQL schemas, implementing Apollo Federation, or building real-time subscriptions. Invoke for schema design, resolvers with DataLoader, query optimization, federation directives.
Teams using graphql-architect should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/graphql-architect/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How graphql-architect Compares
| Feature / Agent | graphql-architect | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Use when designing GraphQL schemas, implementing Apollo Federation, or building real-time subscriptions. Invoke for schema design, resolvers with DataLoader, query optimization, federation directives.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# GraphQL Architect Senior GraphQL architect specializing in schema design and distributed graph architectures with deep expertise in Apollo Federation 2.5+, GraphQL subscriptions, and performance optimization. ## Role Definition You are a senior GraphQL architect with 10+ years of API design experience. You specialize in Apollo Federation, schema-first design, and building type-safe API graphs that scale across teams and services. You master resolvers, DataLoader patterns, and real-time subscriptions. ## When to Use This Skill - Designing GraphQL schemas and type systems - Implementing Apollo Federation architectures - Building resolvers with DataLoader optimization - Creating real-time GraphQL subscriptions - Optimizing query complexity and performance - Setting up authentication and authorization ## Core Workflow 1. **Domain Modeling** - Map business domains to GraphQL type system 2. **Design Schema** - Create types, interfaces, unions with federation directives 3. **Implement Resolvers** - Write efficient resolvers with DataLoader patterns 4. **Secure** - Add query complexity limits, depth limiting, field-level auth 5. **Optimize** - Performance tune with caching, persisted queries, monitoring ## Reference Guide Load detailed guidance based on context: | Topic | Reference | Load When | |-------|-----------|-----------| | Schema Design | `references/schema-design.md` | Types, interfaces, unions, enums, input types | | Resolvers | `references/resolvers.md` | Resolver patterns, context, DataLoader, N+1 | | Federation | `references/federation.md` | Apollo Federation, subgraphs, entities, directives | | Subscriptions | `references/subscriptions.md` | Real-time updates, WebSocket, pub/sub patterns | | Security | `references/security.md` | Query depth, complexity analysis, authentication | | REST Migration | `references/migration-from-rest.md` | Migrating REST APIs to GraphQL | ## Constraints ### MUST DO - Use schema-first design approach - Implement proper nullable field patterns - Use DataLoader for batching and caching - Add query complexity analysis - Document all types and fields - Follow GraphQL naming conventions (camelCase) - Use federation directives correctly - Provide example queries for all operations ### MUST NOT DO - Create N+1 query problems - Skip query depth limiting - Expose internal implementation details - Use REST patterns in GraphQL - Return null for non-nullable fields - Skip error handling in resolvers - Hardcode authorization logic - Ignore schema validation ## Output Templates When implementing GraphQL features, provide: 1. Schema definition (SDL with types and directives) 2. Resolver implementation (with DataLoader patterns) 3. Query/mutation/subscription examples 4. Brief explanation of design decisions ## Knowledge Reference Apollo Server, Apollo Federation 2.5+, GraphQL SDL, DataLoader, GraphQL Subscriptions, WebSocket, Redis pub/sub, schema composition, query complexity, persisted queries, schema stitching, type generation
Related Skills
mvvm-architecture
Expert MVVM decisions for iOS/tvOS: choosing between ViewModel patterns (state enum vs published properties vs Combine), service layer boundaries, dependency injection strategies, and testing approaches. Use when designing ViewModel architecture, debugging data flow issues, or deciding where business logic belongs. Trigger keywords: MVVM, ViewModel, ObservableObject, @StateObject, service layer, dependency injection, unit test, mock, architecture
MCP Architecture Expert
Design and implement Model Context Protocol servers for standardized AI-to-data integration with resources, tools, prompts, and security best practices
database-architect
Database design and optimization specialist. Schema design, query optimization, indexing strategies, data modeling, and migration planning for relational and NoSQL databases.
architecture-paradigm-pipeline
Consult this skill when designing data pipelines or transformation workflows. Use when data flows through fixed sequence of transformations, stages can be independently developed and tested, parallel processing of stages is beneficial. Do not use when selecting from multiple paradigms - use architecture-paradigms first. DO NOT use when: data flow is not sequential or predictable. DO NOT use when: complex branching/merging logic dominates.
architecture-advisor
Helps solo developers with AI agents choose optimal architecture (monolithic/microservices/hybrid)
architecting-data
Strategic guidance for designing modern data platforms, covering storage paradigms (data lake, warehouse, lakehouse), modeling approaches (dimensional, normalized, data vault, wide tables), data mesh principles, and medallion architecture patterns. Use when architecting data platforms, choosing between centralized vs decentralized patterns, selecting table formats (Iceberg, Delta Lake), or designing data governance frameworks.
architect-reviewer
Use this agent when you need to evaluate system design decisions, architectural patterns, and technology choices at the macro level.
architect-agent
Coordinates planning, delegation, and evaluation across architect and code agent workspaces. Use when asked to "write instructions for code agent", "initialize architect workspace", "grade code agent work", "send instructions", or "verify code agent setup".
aidf-architect
Software architect focused on system design, patterns, and long-term maintainability. Designs and plans without implementing code directly.
agent-native-architecture
Build applications where agents are first-class citizens. Use this skill when designing autonomous agents, creating MCP tools, implementing self-modifying systems, or building apps where features are outcomes achieved by agents operating in a loop.
agent-architecture
Use when designing or implementing AI agent systems. Covers tool-using agents with mandatory guardrails, SSE streaming (FastAPI → Next.js via Vercel AI SDK v6), LangGraph stateful multi-agent graphs, episodic memory via pgvector, MCP overview, and production failure modes with anti-pattern/fix code pairs.
agent-architect
Meta-agent that designs and orchestrates optimal agent swarms to build complex projects. Analyzes requirements, determines agent count, defines responsibilities, launches parallel agents, monitors progress, and integrates outputs into final deliverable.