LI

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.zip

Installs 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.
67 charsno explicit “when” trigger
Intermediate

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

You give it
Linear API client instance and GraphQL query parameters
You get back
Optimized API response with reduced latency and request count

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

  1. Measure operation latency, requested fields, connection fan-out, page sizes, complexity header, payload bytes, and cache hit rate.
  2. Replace broad SDK model walks with a purpose-built GraphQL query when only a narrow projection is needed.
  3. Filter at the server, request the smallest explicit page, and paginate until hasNextPage is false.
  4. Eliminate N+1 reads and uncoordinated polling; use webhooks plus a bounded reconciliation window.
  5. Load-test below the applicable shared request/complexity budgets and verify tail latency and correctness.
  6. 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

ConditionResponse
Complexity above 10,000Shrink connections, fields, or page size before sending the query.
Budget exhaustedCoordinate producers and wait for reset metadata; do not spin retries.
Pagination misses dataUse stable cursors and explicit updated-time reconciliation.
Cache leaks visibilityScope 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

Working Linear integration with @linear/sdkUnderstanding of GraphQL query structure

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.

SkillInstallsUpdatedSafetyDifficulty
linear-performance-tuning (this skill)12moReviewIntermediate
nextjs-developer3284moNo flagsAdvanced
sql-optimization-patterns644moNo flagsAdvanced
godot-gdscript-patterns575moNo flagsIntermediate

Try saying

Example prompts that trigger this skill in your AI assistant.

More by jeremylongshore

View all by jeremylongshore →

analyzing-logs

jeremylongshore

Analyze application logs to detect performance issues, identify error patterns, and improve stability by extracting key insights.

14123

ollama-setup

jeremylongshore

Configure auto-configure Ollama when user needs local LLM deployment, free AI alternatives, or wants to eliminate hosted API costs. Trigger phrases: "install ollama", "local AI", "free LLM", "self-hosted AI", "replace OpenAI", "no API costs". Use when appropriate context detected. Trigger with relevant phrases based on skill purpose.

1167

backtesting-trading-strategies

jeremylongshore

Backtest crypto and traditional trading strategies against historical data. Calculates performance metrics (Sharpe, Sortino, max drawdown), generates equity curves, and optimizes strategy parameters. Use when user wants to test a trading strategy, validate signals, or compare approaches. Trigger with phrases like "backtest strategy", "test trading strategy", "historical performance", "simulate trades", "optimize parameters", or "validate signals".

1071

generating-database-seed-data

jeremylongshore

Process this skill enables AI assistant to generate realistic test data and database seed scripts for development and testing environments. it uses faker libraries to create realistic data, maintains relational integrity, and allows configurable data volumes. u... Use when working with databases or data models. Trigger with phrases like 'database', 'query', or 'schema'.

1033

cursor-codebase-indexing

jeremylongshore

Execute set up and optimize Cursor codebase indexing. Triggers on "cursor index setup", "codebase indexing", "index codebase", "cursor semantic search". Use when working with cursor codebase indexing functionality. Trigger with phrases like "cursor codebase indexing", "cursor indexing", "cursor".

885

testing-mobile-apps

jeremylongshore

Execute mobile app testing on iOS and Android devices/simulators. Use when performing specialized testing. Trigger with phrases like "test mobile app", "run iOS tests", or "validate Android functionality".

810

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.

328531

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.

64220

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.

57178

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.

100129

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".

40187

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.

41157

Search skills

Search the agent skills registry