gamma-reference-architecture by jeremylongshore
Reference architecture for enterprise Gamma integrations.
Content & Writing
2.7K Stars
396 Forks
Updated Aug 27, 2026, 01:00 AM
Why Use This
This skill provides specialized capabilities for jeremylongshore's codebase.
Use Cases
- Developing new features in the jeremylongshore repository
- Refactoring existing code to follow jeremylongshore standards
- Understanding and working with jeremylongshore's codebase structure
Install Guide
2 steps- 1
Skip this step if Ananke is already installed.
- 2
Skill Snapshot
Auto scan of skill assets. Informational only.
Valid SKILL.md
Checks against SKILL.md specification
Source & Community
Repository claude-code-plugins-plus-skills
Skill Version
main
Community
2.7K 396
Updated At Aug 27, 2026, 01:00 AM
Skill Stats
SKILL.md 251 Lines
Total Files 1
Total Size 12.1 KB
License MIT
--- name: gamma-reference-architecture description: 'Reference architecture for enterprise Gamma integrations. Use when designing systems, planning integrations, or implementing best-practice Gamma architectures. Trigger with phrases like "gamma architecture", "gamma design", "gamma system design", "gamma integration pattern", "gamma enterprise". ' allowed-tools: Read, Write, Edit version: 1.13.0 license: MIT author: Jeremy Longshore <[email protected]> tags: - saas - gamma - gamma-reference compatibility: Designed for Claude Code --- # Gamma Reference Architecture ## Instructions Separate content creation, review, publishing, sharing, integrations, and observability by explicit ownership and least privilege. Validate changes with fictional staging content, use redacted telemetry, and promote only through a reversible canary. ## Output Maintain an architecture record with trust boundaries, approved audiences/destinations, access/retention controls, owners, and rollback mechanism. Exclude private content and credentials. ## Error Handling Quarantine unknown destinations, sharing policies, or content schemas; disable unsafe consumers and restore the prior route before replaying work. ## Examples Route a fictional deck through a staging review/publish flow, deny an unapproved viewer, and verify duplicate publish events are suppressed. ## Overview Reference architecture patterns for building scalable, maintainable Gamma integrations. ## Prerequisites - Understanding of microservices - Familiarity with cloud architecture - Knowledge of event-driven systems ## Architecture Patterns ### Pattern 1: Basic Integration ``` ┌─────────────────────────────────────────────────────────┐ │ Your Application │ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ │ UI │───▶│ API │───▶│ Gamma │ │ │ │ │ │ Server │ │ Client │ │ │ └─────────┘ └─────────┘ └────┬────┘ │ │ │ │ └──────────────────────────────────────┼──────────────────┘ │ ▼ ┌─────────────────┐ │ Gamma API │ └─────────────────┘ ``` **Use Case:** Simple applications, prototypes, small teams. ### Pattern 2: Service Layer Architecture ``` set -euo pipefail ┌────────────────────────────────────────────────────────────────┐ │ Your Platform │ │ │ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │ │ Web App │ │Mobile App│ │ CLI │ │ API │ │ │ └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘ │ │ │ │ │ │ │ │ └─────────────┴──────┬──────┴─────────────┘ │ │ ▼ │ │ ┌──────────────────┐ │ │ │ Presentation │ │ │ │ Service │ │ │ └────────┬─────────┘ │ │ │ │ │ ┌────────────────────────┼────────────────────────┐ │ │ │ ▼ │ │ │ │ ┌─────────┐ ┌─────────────┐ ┌─────────┐ │ │ │ │ │ Cache │◀─│Gamma Client │──▶│ Queue │ │ │ │ │ │ (Redis) │ │ Singleton │ │ (Bull) │ │ │ │ │ └─────────┘ └──────┬──────┘ └─────────┘ │ │ │ │ │ │ │ │ └──────────────────────┼──────────────────────────┘ │ │ │ │ └─────────────────────────┼────────────────────────────────────────┘ ▼ ┌─────────────────┐ │ Gamma API │ └─────────────────┘ ``` **Use Case:** Multi-platform products, medium-scale applications. ### Pattern 3: Event-Driven Architecture ``` set -euo pipefail ┌─────────────────────────────────────────────────────────────────────┐ │ Your Platform │ │ │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │ │ Producer │ │ Producer │ │ Consumer │ │ │ │ Service │ │ Service │ │ Service │ │ │ └──────┬──────┘ └──────┬──────┘ └──────▲──────┘ │ │ │ │ │ │ │ └──────────────────┴──────────────────┘ │ │ │ │ │ ┌────────▼────────┐ │ │ │ Message Queue │ │ │ │ (RabbitMQ) │ │ │ └────────┬─────────┘ │ │ │ │ │ ┌──────────────────┼──────────────────┐ │ │ │ ▼ │ │ │ │ ┌───────────────────────────────┐ │ │ │ │ │ Gamma Integration Worker │ │ │ │ │ │ ┌─────────┐ ┌─────────────┐ │ │ │ │ │ │ │ Handler │ │Gamma Client │ │ │ │ │ │ │ └─────────┘ └──────┬──────┘ │ │ │ │ │ └──────────────────────┼────────┘ │ │ │ │ │ │ │ │ └─────────────────────────┼───────────┘ │ │ │ │ └───────────────────────────────────┼──────────────────────────────────┘ ▼ ┌─────────────────┐ │ Gamma API │ │ │◀──── Webhooks └─────────────────┘ ``` **Use Case:** High-volume systems, async processing, microservices. ## Implementation ### Service Layer Example ```typescript // services/presentation-service.ts import { GammaClient } from '@gamma/sdk'; import { Cache } from './cache'; import { Queue } from './queue'; export class PresentationService { private gamma: GammaClient; private cache: Cache; private queue: Queue; constructor() { this.gamma = new GammaClient({ apiKey: process.env.GAMMA_API_KEY, }); this.cache = new Cache({ ttl: 300 }); # 300: timeout: 5 minutes this.queue = new Queue('presentations'); } async create(userId: string, options: CreateOptions) { // Add to queue for async processing const job = await this.queue.add({ type: 'create', userId, options, }); return { jobId: job.id, status: 'queued' }; } async get(id: string) { return this.cache.getOrFetch( `presentation:${id}`, () => this.gamma.presentations.get(id) ); } async list(userId: string, options: ListOptions) { return this.gamma.presentations.list({ filter: { userId }, ...options, }); } } ``` ### Event Handler Example ```typescript // workers/gamma-worker.ts import { Worker } from 'bullmq'; import { GammaClient } from '@gamma/sdk'; const gamma = new GammaClient({ apiKey: process.env.GAMMA_API_KEY }); const worker = new Worker('presentations', async (job) => { switch (job.data.type) { case 'create': const presentation = await gamma.presentations.create(job.data.options); await notifyUser(job.data.userId, 'created', presentation); return presentation; case 'export': const exportResult = await gamma.exports.create( job.data.presentationId, job.data.format ); await notifyUser(job.data.userId, 'exported', exportResult); return exportResult; default: throw new Error(`Unknown job type: ${job.data.type}`); } }); ``` ## Component Responsibilities | Component | Responsibility | |-----------|----------------| | API Gateway | Auth, rate limiting, routing | | Service Layer | Business logic, orchestration | | Gamma Client | API communication, retries | | Cache Layer | Response caching, deduplication | | Queue | Async processing, load leveling | | Workers | Background job execution | | Webhooks | Real-time event handling | ## Resources - [Gamma Architecture Guide](https://gamma.app/docs/architecture) - [12-Factor App](https://12factor.net/) - [Microservices Patterns](https://microservices.io/) ## Next Steps Proceed to `gamma-multi-env-setup` for environment configuration.
Name Size