linear-reference-architecture

Production-grade Linear integration architecture patterns. Use when designing system architecture, choosing integration patterns, or reviewing architectural decisions for Linear integrations. Trigger: "linear architecture", "linear system design", "linear integration patterns", "linear best practices architecture".

Jump to install

Repository: jeremylongshore/claude-code-plugins-plus-skills
Last source activity: July 17, 2026 at 22:18
Detected SKILL.md language: English
Stars: 2,604
Forks: 378

Install options

The review-first prompt is selected by default. You can switch to a direct command or download a local copy.

Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.

A direct command skips the review prompt. Inspect the source before running it.

npx skills add https://github.com/jeremylongshore/claude-code-plugins-plus-skills --skill linear-reference-architecture

The command stays on one line. Scroll horizontally to inspect it before copying.

Prefer a local copy? Download the files currently available to SkillsMP.

Review the source files

Read SKILL.md and any companion files shown by SkillsMP before deciding whether to install.

File Explorer

2 files

SKILL.md

Source instructions · Read-only preview

Back to search Back to installation

Linear Reference Architecture

Overview

Production-grade architectural patterns for Linear integrations. Choose the right pattern based on team size, complexity, and real-time requirements.

Architecture Decision Matrix

Pattern

Best For

Complexity

Rate Budget

Example

Simple

Single app, small team

Low

< 500 req/hr

Internal dashboard

Service-Oriented

Multiple apps, shared state

Medium

500-2,000 req/hr

Platform with Linear sync

Event-Driven

Real-time needs, many consumers

High

< 500 req/hr + webhooks

Multi-service notification system

CQRS

Audit trails, complex queries

Very High

Minimal API calls

Compliance-grade tracking

Architecture 1: Simple Integration

Direct SDK calls from your application. Best for scripts, internal tools, and prototypes.

// src/linear.ts — single module, shared client import { LinearClient } from "@linear/sdk"; const client = new LinearClient({ apiKey: process.env.LINEAR_API_KEY! }); // Direct SDK calls from any part of your app export async function getOpenIssues(teamKey: string) { return client.issues({ first: 50, filter: { team: { key: { eq: teamKey } }, : { : { : [, ] } }, }, : , }); } () { labels = client.({ : { : { : } } }); client.({ teamId, title, description, : , : labels.. ? [labels.[].] : [], }); }

name	linear-reference-architecture
description	Production-grade Linear integration architecture patterns. Use when designing system architecture, choosing integration patterns, or reviewing architectural decisions for Linear integrations. Trigger: "linear architecture", "linear system design", "linear integration patterns", "linear best practices architecture".
allowed-tools	Read, Write, Edit, Grep
version	1.12.0
license	MIT
author	Jeremy Longshore <jeremy@intentsolutions.io>
tags	["saas","linear","linear-reference"]
compatibility	Designed for Claude Code, also compatible with Codex and OpenClaw

Linear Reference Architecture

Overview

Production-grade architectural patterns for Linear integrations. Choose the right pattern based on team size, complexity, and real-time requirements.

Architecture Decision Matrix

Pattern	Best For	Complexity	Rate Budget	Example
Simple	Single app, small team	Low	< 500 req/hr	Internal dashboard
Service-Oriented	Multiple apps, shared state	Medium	500-2,000 req/hr	Platform with Linear sync
Event-Driven	Real-time needs, many consumers	High	< 500 req/hr + webhooks	Multi-service notification system
CQRS	Audit trails, complex queries	Very High	Minimal API calls	Compliance-grade tracking

Architecture 1: Simple Integration

Direct SDK calls from your application. Best for scripts, internal tools, and prototypes.

// src/linear.ts — single module, shared client
import { LinearClient } from "@linear/sdk";

const client = new LinearClient({ apiKey: process.env.LINEAR_API_KEY! });

// Direct SDK calls from any part of your app
export async function getOpenIssues(teamKey: string) {
  return client.issues({
    first: 50,
    filter: {
      team: { key: { eq: teamKey } },
      : { : { : [, ] } },
    },
    : ,
  });
}

   () {
   labels =  client.({ : { : { :  } } });
   client.({
    teamId,
    title,
    description,
    : ,
    : labels.. ? [labels.[].] : [],
  });
}

// src/linear-gateway.ts import { LinearClient } from "@linear/sdk"; class LinearGateway { private client: LinearClient; private cache = new Map<string, { data: any; expiresAt: number }>(); private requestQueue: Array<{ fn: () => Promise<any>; resolve: Function; reject: Function }> = []; private processing = false; constructor(apiKey: string) { this.client = new LinearClient({ apiKey }); } // Cached reads async getTeams() { return this.cachedQuery("teams", () => this.client.teams().then(r => r.nodes), 600); } async getStates(teamId: string) { return this.cachedQuery(`states:${teamId}`, async () => { const team = await this.client.team(teamId); return (await team.states()).nodes; }, 1800); } // Rate-limited writes async createIssue(input: any) { return this.enqueue(() => this.client.createIssue(input)); } async updateIssue(id: string, input: any) { return this.enqueue(() => this.client.updateIssue(id, input)); } // Custom queries through the gateway async rawQuery(query: string, variables?: any) { return this.enqueue(() => this.client.client.rawRequest(query, variables)); } // Cache invalidation (called from webhook handler) invalidate(pattern: string) { for (const key of this.cache.keys()) { if (key.startsWith(pattern)) this.cache.delete(key); } } private async cachedQuery<T>(key: string, fn: () => Promise<T>, ttlSec: number): Promise<T> { const cached = this.cache.get(key); if (cached && Date.now() < cached.expiresAt) return cached.data; const data = await this.enqueue(fn); this.cache.set(key, { data, expiresAt: Date.now() + ttlSec * 1000 }); return data; } private async enqueue<T>(fn: () => Promise<T>): Promise<T> { return new Promise((resolve, reject) => { this.requestQueue.push({ fn, resolve, reject }); if (!this.processing) this.processQueue(); }); } private async processQueue() { this.processing = true; while (this.requestQueue.length > 0) { const { fn, resolve, reject } = this.requestQueue.shift()!; try { resolve(await fn()); } catch (e) { reject(e); } if (this.requestQueue.length > 0) { await new Promise(r => setTimeout(r, 100)); // 10 req/sec max } } this.processing = false; } } export const gateway = new LinearGateway(process.env.LINEAR_API_KEY!);

Error	Cause	Solution
Rate limit exceeded	Too many direct API calls	Route all calls through gateway
Stale cache	TTL too long, missed webhook	Webhook invalidation + periodic full sync
Event loss	Webhook delivery failure	Idempotent handlers + consistency checks
Schema drift	SDK version mismatch	Pin version, test upgrades in staging

linear-reference-architecture

Install options

Review the source files

Linear Reference Architecture

Overview

Architecture Decision Matrix

Architecture 1: Simple Integration

Linear Reference Architecture

Overview

Architecture Decision Matrix

Architecture 1: Simple Integration

Architecture 2: Service-Oriented with Gateway

Architecture 3: Event-Driven

Architecture 4: CQRS with Local State

Project Structure

Error Handling

Resources

linear-reference-architecture

Source facts

Install options

Review the source files

More from this repository

More from this repository

Linear Reference Architecture

Overview

Architecture Decision Matrix

Architecture 1: Simple Integration

Linear Reference Architecture

Overview

Architecture Decision Matrix

Architecture 1: Simple Integration

Architecture 2: Service-Oriented with Gateway

Architecture 3: Event-Driven

Architecture 4: CQRS with Local State

Project Structure

Error Handling

Resources