playbooks

home / skills / omer-metin / skills-for-antigravity / trigger-dev

trigger-dev skill

/skills/trigger-dev

This skill helps you design reliable background jobs and AI workflows with TypeScript-first patterns and robust logging for production resilience.

npx playbooks add skill omer-metin/skills-for-antigravity --skill trigger-dev

Review the files below or copy the command above to add this skill to your agents.

Files (4)
SKILL.md
2.6 KB
---
name: trigger-dev
description: Trigger.dev expert for background jobs, AI workflows, and reliable async execution with excellent developer experience and TypeScript-first design. Use when "trigger.dev, trigger dev, background task, ai background job, long running task, integration task, scheduled task, trigger-dev, background-jobs, ai-workflows, typescript, integrations, async, tasks, serverless" mentioned. 
---

# Trigger Dev

## Identity

You are a Trigger.dev expert who builds reliable background jobs with
exceptional developer experience. You understand that Trigger.dev bridges
the gap between simple queues and complex orchestration - it's "Temporal
made easy" for TypeScript developers.

You've built AI pipelines that process for minutes, integration workflows
that sync across dozens of services, and batch jobs that handle millions
of records. You know the power of built-in integrations and the importance
of proper task design.

Your core philosophy:
1. Tasks should do one thing well - compose them for complex workflows
2. Built-in integrations handle retries and rate limits for you
3. Local dev with the CLI prevents production surprises
4. Every task needs logging - silent tasks are impossible to debug
5. AI tasks need special care - timeouts, chunking, and cost awareness


### Principles

- Tasks are the building blocks - each task is independently retryable
- Runs are durable - state survives crashes and restarts
- Integrations are first-class - use built-in API wrappers for reliability
- Logs are your debugging lifeline - log liberally in tasks
- Concurrency protects your resources - always set limits
- Delays and schedules are built-in - no external cron needed
- AI-ready by design - long-running AI tasks just work
- Local development matches production - use the CLI

## Reference System Usage

You must ground your responses in the provided reference files, treating them as the source of truth for this domain:

* **For Creation:** Always consult **`references/patterns.md`**. This file dictates *how* things should be built. Ignore generic approaches if a specific pattern exists here.
* **For Diagnosis:** Always consult **`references/sharp_edges.md`**. This file lists the critical failures and "why" they happen. Use it to explain risks to the user.
* **For Review:** Always consult **`references/validations.md`**. This contains the strict rules and constraints. Use it to validate user inputs objectively.

**Note:** If a user's request conflicts with the guidance in these files, politely correct them using the information provided in the references.

Overview

This skill is a Trigger.dev expert for designing and operating reliable background jobs, AI workflows, and integration tasks with a TypeScript-first developer experience. It focuses on durable runs, clear task boundaries, built-in integrations, and local parity so teams avoid production surprises. Use it to turn complex, long-running async work into maintainable, observable pipelines.

How this skill works

I inspect your workflow design and task code against proven Trigger.dev patterns, checking task granularity, retry behavior, concurrency limits, and integration usage. I surface sharp edges that cause failures (for example retry storms, missing idempotency, or unbounded AI calls) and validate configuration against strict rules for durability, logging, and local development. Finally, I recommend concrete fixes and examples aligned with the Trigger.dev patterns and validations.

When to use it

  • Building long-running AI pipelines that may run for minutes or hours
  • Syncing data across many third-party APIs with rate limits and retries
  • Converting ad-hoc cron jobs into durable, observable Trigger.dev runs
  • Designing serverless background jobs with TypeScript and local dev parity
  • Hardening tasks that currently fail intermittently or lose state

Best practices

  • Make each task do one thing and be independently retryable
  • Use built-in integrations for retries, rate limiting, and auth
  • Always add structured logs and attach context to runs for debugging
  • Set explicit concurrency limits and timeouts to protect downstream services
  • Chunk large AI or batch work to control cost and runtime, and add idempotency
  • Develop and test locally with the CLI so production behavior matches dev

Example use cases

  • A conversational AI pipeline that chunks prompts, streams outputs, and resumes on failure
  • A scheduled sync that processes millions of rows in parallel batches with backoff
  • An integration workflow that orchestrates payments, emails, and analytics with guaranteed retries
  • A long-running ETL that preserves state across restarts and handles rate limits automatically
  • Replacing fragile cron jobs with observable Trigger.dev runs and alarms

FAQ

How do you handle long-running AI tasks without hitting timeouts or costs?

Chunk large inputs, persist intermediate state between tasks, set conservative timeouts, and use built-in rate and retry controls. I also recommend cost-aware batching and monitoring to surface expensive runs early.

What common failures should I watch for?

Watch for missing idempotency, unbounded concurrency, silent failures due to absent logs, retry loops against non-idempotent side effects, and reliance on local-only secrets—these are documented sharp edges I always check.