linear-performance-tuning
Optimize Linear API performance by reducing N+1 queries, using efficient GraphQL patterns, and implementing caching.
Install
mkdir -p .claude/skills/linear-performance-tuning && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/7847" && unzip -o skill.zip -d .claude/skills/linear-performance-tuning && rm skill.zipInstalls to .claude/skills/linear-performance-tuning
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
Optimize Linear API queries, caching, and batching for performance.Key capabilities
- →Flatten GraphQL queries to eliminate N+1 request patterns
- →Implement client-side caching for static data with TTLs
- →Batch multiple mutations into single GraphQL requests
- →Use webhooks for event-driven cache invalidation
- →Coalesce concurrent identical API requests
- →Perform incremental synchronization using updatedAt filters
How it works
The skill optimizes Linear API interactions by replacing lazy-loaded SDK relations with raw GraphQL queries, implementing local caching for static entities, and batching multiple mutations into single requests to stay within complexity budgets.
Inputs & outputs
When to use linear-performance-tuning
- →Fixing N+1 query patterns
- →Reducing Linear API request count
- →Implementing server-side caching
- →Optimizing GraphQL complexity budgets
About this skill
Linear Query Performance Tuning
Overview
Tune the measured operation rather than applying guessed delays, and preserve correctness with bounded pagination and reconciliation.
Prerequisites
- The target repository, Linear workspace, environment, and accountable owner
- Current security, privacy, compliance, capacity, and change-control requirements
- An approved Linear credential only when a bounded live verification is necessary
Tool Discipline
Use Read, Glob, and Grep to inspect code, configuration, and evidence. Use WebFetch only for current first-party Linear documentation and package metadata. Use Write or Edit only for requested implementation with known target files. Never write credentials, customer content, unrestricted environment output, or unredacted GraphQL variables.
Current Contract
- Each property costs 0.1 complexity point, each object 1 point, and connections multiply child cost by the requested page size or default 50, rounded up.
- A single query cannot exceed 10,000 complexity points; hourly complexity and request limits are shared by user or app actor.
- Filtering server-side, requesting explicit page sizes, ordering by updated time, and using webhooks reduce unnecessary work.
Authentication
Use a personal API key only for owner-controlled scripts, OAuth with PKCE for user-delegated applications, or an enabled client-credentials grant for approved automation. Personal keys use Authorization: <API_KEY>; OAuth tokens use Authorization: Bearer <ACCESS_TOKEN>. Store credentials server-side in an approved secret manager.
Treat app approval, team access, scope changes, credential creation, rotation, revocation, and production access as owner-approved actions.
Instructions
- Measure operation latency, requested fields, connection fan-out, page sizes, complexity header, payload bytes, and cache hit rate.
- Replace broad SDK model walks with a purpose-built GraphQL query when only a narrow projection is needed.
- Filter at the server, request the smallest explicit page, and paginate until
hasNextPageis false. - Eliminate N+1 reads and uncoordinated polling; use webhooks plus a bounded reconciliation window.
- Load-test below the applicable shared request/complexity budgets and verify tail latency and correctness.
- Document before/after evidence and rollback the query change if semantics or visibility differ.
Approval Boundaries
Do not create, reveal, rotate, or revoke credentials; authorize an OAuth app; change scopes or team access; create, mutate, archive, or delete workspace data; configure or re-enable webhooks; import or export data; change roles, SCIM, or audit streaming; transmit diagnostics; change paid entitlements; or perform another production mutation without explicit approval from the accountable owner. Keep diagnosis read-only unless implementation was requested.
Output
Return the workspace and team scope, auth mode without credential value, files and contracts inspected, exact operation names, evidence collected, validation result, sensitive fields redacted, remaining risk, accountable owner, approval state, and rollback or next action.
Error Handling
| Condition | Response |
|---|---|
| Complexity above 10,000 | Shrink connections, fields, or page size before sending the query. |
| Budget exhausted | Coordinate producers and wait for reset metadata; do not spin retries. |
| Pagination misses data | Use stable cursors and explicit updated-time reconciliation. |
| Cache leaks visibility | Scope keys by workspace/team/access context or disable the cache. |
Examples
Use a compact handoff that makes scope, mutation authority, and verification evidence reviewable.
Input:
operation=IssueSync; first=50; nested-connections=3; complexity=measured
Expected handoff:
query=narrowed; pagination=cursor; polling=replaced; correctness=verified
Resources
When not to use it
- →When data requires real-time consistency without caching
- →When mutation volume is too low to benefit from batching
Prerequisites
Limitations
- →Query complexity is capped at 250,000 points per hour
- →Individual queries are limited to 10,000 complexity points
How it compares
Unlike standard SDK usage which triggers individual requests for related fields, this approach uses raw GraphQL queries to fetch all required data in a single round trip.
Compared to similar skills
linear-performance-tuning side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| linear-performance-tuning (this skill) | 1 | 2mo | Review | Intermediate |
| nextjs-developer | 328 | 4mo | No flags | Advanced |
| sql-optimization-patterns | 64 | 4mo | No flags | Advanced |
| godot-gdscript-patterns | 57 | 5mo | No flags | Intermediate |
Try saying
Example prompts that trigger this skill in your AI assistant.
More by jeremylongshore
View all by jeremylongshore →You might also like
nextjs-developer
zenobi-us
Expert Next.js developer mastering Next.js 14+ with App Router and full-stack features. Specializes in server components, server actions, performance optimization, and production deployment with focus on building fast, SEO-friendly applications.
sql-optimization-patterns
wshobson
Master SQL query optimization, indexing strategies, and EXPLAIN analysis to dramatically improve database performance and eliminate slow queries. Use when debugging slow queries, designing database schemas, or optimizing application performance.
godot-gdscript-patterns
sickn33
Master Godot 4 GDScript patterns including signals, scenes, state machines, and optimization. Use when building Godot games, implementing game systems, or learning GDScript best practices.
angular
sickn33
Modern Angular (v20+) expert with deep knowledge of Signals, Standalone Components, Zoneless applications, SSR/Hydration, and reactive patterns. Use PROACTIVELY for Angular development, component architecture, state management, performance optimization, and migration to modern patterns.
core-web-vitals
davila7
Optimize Core Web Vitals (LCP, INP, CLS) for better page experience and search ranking. Use when asked to "improve Core Web Vitals", "fix LCP", "reduce CLS", "optimize INP", "page experience optimization", or "fix layout shifts".
chrome-devtools
mrgoonie
Browser automation, debugging, and performance analysis using Puppeteer CLI scripts. Use for automating browsers, taking screenshots, analyzing performance, monitoring network traffic, web scraping, form automation, and JavaScript debugging.