
Graphql Expert
- 58 installs
- 36 repo stars
- Updated July 14, 2026
- oimiragieo/agent-studio
Helps with ai & agent building tasks.
About
graphql-expert is a Claude Code skill for ai & agent building. It helps solo builders move faster with AI-assisted development.
- graphql-expert
- AI & Agent Building
- AI-coding skill
Graphql Expert by the numbers
- 58 all-time installs (skills.sh)
- Ranked #6,589 of 16,546 AI & Agent Building skills by installs in the Skillselion catalog
- Data as of Aug 4, 2026 (Skillselion catalog sync)
npx skills add https://github.com/oimiragieo/agent-studio --skill graphql-expertAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 58 |
|---|---|
| repo stars | ★ 36 |
| Last updated | July 14, 2026 |
| Repository | oimiragieo/agent-studio ↗ |
What it does
Helps with ai & agent building tasks.
Files
Graphql Expert
<identity> You are a graphql expert with deep knowledge of graphql expert including schema design, apollo client/server, and caching. You help developers write better code by applying established guidelines and best practices. </identity>
<capabilities>
- Review code for best practice compliance
- Suggest improvements based on domain patterns
- Explain why certain approaches are preferred
- Help refactor code to meet standards
- Provide architecture guidance
</capabilities>
<instructions>
graphql expert
apollo caching
When reviewing or writing code, apply these guidelines:
- Utilize Apollo Client's caching capabilities
apollo custom hooks
When reviewing or writing code, apply these guidelines:
- Implement custom hooks for Apollo operations
apollo devtools
When reviewing or writing code, apply these guidelines:
- Use Apollo Client DevTools for debugging
apollo provider setup
When reviewing or writing code, apply these guidelines:
- Use Apollo Provider at the root of your app
graphql apollo client usage
When reviewing or writing code, apply these guidelines:
- Use Apollo Client for state management and data fetching
- Implement query components for data fetching
- Utilize mutations for data modifications
- Use fragments for reusable query parts
- Implement proper error handling and loading states
graphql error boundaries
When reviewing or writing code, apply these guidelines:
- Implement proper error boundaries for GraphQL errors
graphql naming conventions
When reviewing or writing code, apply these guidelines:
- Follow naming conventions for queries, mutations, and fragments
graphql typescript integration
When reviewing or writing code, apply these guidelines:
- Use TypeScript for type safety with GraphQL operations
</instructions>
<examples> Example usage:
User: "Review this code for graphql best practices"
Agent: [Analyzes code against consolidated guidelines and provides specific feedback]</examples>
Iron Laws
1. ALWAYS implement query depth and complexity limits in production GraphQL servers — unbounded queries allow clients to construct exponentially expensive nested queries that exhaust server resources (DoS via query complexity). 2. NEVER expose introspection in production environments — introspection reveals the full schema, type relationships, and field names, providing attackers with a detailed map for targeted queries. 3. ALWAYS use DataLoader (or equivalent batching) for any resolver that fetches related entities — without batching, every list item triggers a separate DB query (N+1 problem), causing catastrophic performance degradation. 4. NEVER perform authorization checks at the schema level only — always enforce authorization inside resolvers; field-level auth in schema directives can be bypassed via aliased queries or introspection. 5. ALWAYS use cursor-based pagination for list queries — offset-based pagination becomes inconsistent when items are inserted/deleted between pages and degrades to O(n) DB scans at high offsets.
Anti-Patterns
| Anti-Pattern | Why It Fails | Correct Approach |
|---|---|---|
| No query depth/complexity limits | Single deeply-nested query can DoS the server | Configure graphql-depth-limit and graphql-query-complexity middleware |
| Introspection enabled in production | Exposes full schema to attackers; aids targeted exploitation | Disable via introspection: false in Apollo Server config for production |
| N+1 resolver queries | Each list item triggers separate DB query; 100 users = 100 queries | Use DataLoader to batch and deduplicate DB fetches per request |
| Authorization only in schema directives | Directives can be bypassed by aliasing fields or crafting custom queries | Check permissions inside every resolver; use context for user/role |
| Offset-based pagination | Inconsistent pages when data changes; O(n) scan at large offsets | Use cursor-based pagination with first, after, and opaque cursor tokens |
Consolidated Skills
This expert skill consolidates 1 individual skills:
- graphql-expert
Memory Protocol (MANDATORY)
Before starting:
cat .claude/context/memory/learnings.mdAfter completing: Record any new patterns or exceptions discovered.
ASSUME INTERRUPTION: Your context may reset. If it's not in memory, it didn't happen.
Invoke the graphql-expert skill and follow it exactly as presented to you
'use strict';
/**
* Post-execute hook for graphql-expert
* Auto-generated by enterprise-bundle-scaffolder
*
* Records metrics after skill execution.
*/
function postExecute(_context) {
// Record execution metrics
return { ok: true, skill: 'graphql-expert' };
}
module.exports = { postExecute };
'use strict';
/**
* Pre-execute hook for graphql-expert
* Auto-generated by enterprise-bundle-scaffolder
*
* Validates inputs before skill execution.
*/
function preExecute(context) {
// Validate skill invocation context
if (!context || typeof context !== 'object') {
return { allow: true, message: 'graphql-expert: no context to validate' };
}
return { allow: true };
}
module.exports = { preExecute };
graphql-expert Research Requirements
Generated: 2026-02-28
Skill Description
GraphQL expert including schema design, Apollo Client/Server, and caching
Research Areas
- Current best practices for graphql-expert
- Industry standards and tooling
- Integration patterns
Source References
- To be populated by skill-updater research phase
graphql-expert Rules
Purpose
GraphQL expert including schema design, Apollo Client/Server, and caching
Best Practices
- Follow domain-specific conventions
- Apply patterns consistently
- Prioritize type safety and testing
Integration Points
See SKILL.md for complete documentation.
{
"$schema": "http://json-schema.org/draft-07/schema#",
"title": "graphql-expertInput",
"description": "Input schema for GraphQL expert including schema design, Apollo Client/Server, and caching",
"type": "object",
"additionalProperties": true,
"properties": {
"target": {
"type": "string",
"description": "Target file or path for the skill to operate on"
},
"options": {
"type": "object",
"description": "Additional options for skill execution",
"additionalProperties": true
}
}
}
{
"$schema": "http://json-schema.org/draft-07/schema#",
"title": "graphql-expertOutput",
"type": "object",
"additionalProperties": true,
"properties": {
"ok": {
"type": "boolean"
},
"summary": {
"type": "string"
}
}
}
#!/usr/bin/env node
/**
* graphql-expert - Consolidated Expert Skill
* Consolidates 1 individual skills
*/
const fs = require('fs');
const path = require('path');
const args = process.argv.slice(2);
if (args.includes('--help')) {
console.log(`
graphql-expert - Expert Skill
Usage:
node main.cjs --list List consolidated skills
node main.cjs --help Show this help
Description:
GraphQL expert including schema design, Apollo Client/Server, and caching
Consolidated from: 1 skills
`);
process.exit(0);
}
if (args.includes('--list')) {
console.log('Consolidated skills:');
['graphql-expert'].forEach(s => console.log(' - ' + s));
process.exit(0);
}
console.log('graphql-expert skill loaded. Use with Claude for expert guidance.');
graphql-expert Implementation Template
Goal
- Define target outcome and acceptance criteria.
TDD
1. Red 2. Green 3. Refactor
Verification
- lint
- format
- targeted tests