AI Skills

Skills give your AI coding agent deep knowledge about Temps. Skills are structured guides that teach AI assistants how to deploy, configure, and integrate with the platform — no copy-pasting docs required.

Overview

Temps ships with 12 skills that work with Claude Code, Cursor, Windsurf, Cline, and any agent that supports the skills protocol. Each skill is a curated set of instructions, code examples, and reference material that the AI loads when it recognises a relevant task.

For example, if you tell your AI agent "deploy my app to Temps" and the deploy-to-temps skill is installed, the agent already knows the exact CLI commands, framework detection logic, Dockerfile patterns, and troubleshooting steps — without you having to explain anything.

Installation

Skills are installed using the npx skills CLI. You can install all Temps skills at once or pick individual ones.

Install all skills

npx skills add gotempsh/temps

This launches an interactive selector:

Select skills to install (space to toggle)
  ◻ add-custom-domain
  ◻ add-error-tracking
  ◻ add-node-sdk
  ◻ add-react-analytics
  ◻ add-session-recording
  ◻ deploy-to-temps
  ◻ estimate-temps-savings
  ◻ temps
  ◻ temps-best-practices
  ◻ temps-cli
  ◻ temps-platform-setup
  ◻ temps-plugin

Press space to toggle, then enter to install.

Install a specific skill

npx skills add gotempsh/temps --skill deploy-to-temps

Replace deploy-to-temps with any skill name from the table below.

Calling a skill

Never used an AI coding agent before? Here's the whole flow, start to finish — there's no special "run skill" command to memorise.

1. Install a coding agent. This is an AI assistant that runs in your terminal, reads your project, and can run commands for you. Popular choices: Claude Code, OpenAI Codex, and Opencode. Install whichever you like by following its own setup guide.
2. Install the skill into your project — for example npx skills add gotempsh/temps --skill temps-cli (see Installation above).
3. Open the agent in your project folder and describe what you want in plain English — for example: "Create a Postgres 18 database with Temps and link it to this project."

That's it. The agent automatically loads the matching skill the moment your request hits one of its triggers (for temps-cli, phrases like "temps cli" or "create a temps database"), then runs the correct @temps-sdk/cli commands for you. If you'd rather be explicit, call it directly by typing a slash command — /temps-cli — and then your request:

/temps-cli create a Postgres 18 database and link it to my project

Every skill follows the same pattern — type / followed by the skill name (/deploy-to-temps, /add-error-tracking, and so on).

Available skills

temps

The router skill. It treats Temps as a product workflow rather than a command catalogue: it classifies what you are asking for, inspects the repository and your current Temps context read-only, then loads only the focused reference that task needs.

npx skills add gotempsh/temps --skill temps

This is the skill the console installs when you connect an AI harness from Getting started → Connect your AI harness.

Covers: application preparation, deployment, platform operation, observability, recovery, and diagnosis — including projects, environments, services, domains, backups, logs, monitoring, analytics, Core Web Vitals, error tracking, OpenTelemetry, and session replay.

How it behaves:

• Inspects before changing anything — framework, current context, target project and environment.
• Explains the target and effect of a state change before making it, and asks for confirmation when the change is destructive or secret-bearing.
• Verifies the outcome with a read-only command, and with a real synthetic signal when telemetry is involved.
• Uses pinned bunx or npx CLI invocations with an explicit target context, so it never acts against the wrong instance.

Requirements: a shell and either bunx or npx; Python 3.9+ for the bundled read-only capability detector.

temps-best-practices

Best practices for application code that runs on Temps. This skill owns the runtime contract and production observability — use temps-cli for executing platform operations.

npx skills add gotempsh/temps --skill temps-best-practices

Runtime contract: .temps.yaml health checks, HOST/PORT binding, readiness, SIGTERM handling, replicas, and migrations.

Observability: errors, traces, metrics, logs, and analytics — including sampling, cardinality, privacy, and credential boundaries.

Use it when building or reviewing an app for Temps, configuring health checks, wiring up telemetry, or diagnosing missing and noisy signals. For a single SDK integration, prefer the focused setup skill instead — add-react-analytics, add-error-tracking, or add-node-sdk.

deploy-to-temps

Deploy applications to Temps with automatic framework detection, Dockerfile generation, and container orchestration.

npx skills add gotempsh/temps --skill deploy-to-temps

Supported frameworks: Next.js, Vite, Create React App, Remix, Express, NestJS, Python/Flask, Python/Django, Go, Rust, and more.

Quick deploy via CLI

# No install needed — bunx runs the latest version
bunx @temps-sdk/cli login

# Deploy current directory
bunx @temps-sdk/cli deploy

# Deploy with options
bunx @temps-sdk/cli deploy --project my-app --branch main

Build configuration

Create a temps.json in your project root for custom settings:

{
  "name": "my-app",
  "framework": "nextjs",
  "buildCommand": "npm run build",
  "installCommand": "npm ci",
  "outputDirectory": ".next",
  "nodeVersion": "20",
  "healthCheck": {
    "path": "/api/health",
    "interval": 30,
    "timeout": 10
  },
  "resources": {
    "cpu": "0.5",
    "memory": "512Mi",
    "replicas": { "min": 1, "max": 5 }
  }
}

Environment variables

bunx @temps-sdk/cli environments vars set DATABASE_URL="postgres://..."
bunx @temps-sdk/cli environments vars set --environments production  # import from file
bunx @temps-sdk/cli environments vars --project my-app

Rollbacks

bunx @temps-sdk/cli deployments list
# Roll back to a specific deployment
bunx @temps-sdk/cli rollback --project my-app --to <deployment-id>
# Roll back to previous deployment (omit --to)
bunx @temps-sdk/cli rollback --project my-app

temps-cli

Complete command-line reference covering all 56+ CLI commands — the most comprehensive skill at 2,000+ lines of documentation.

npx skills add gotempsh/temps --skill temps-cli

Installation

# No install needed — bunx runs the latest version
bunx @temps-sdk/cli --version

Command groups

temps-platform-setup

Install, configure, and manage a self-hosted Temps instance from scratch.

npx skills add gotempsh/temps --skill temps-platform-setup

Installation methods

# Install script
curl -fsSL https://temps.sh/deploy.sh -o deploy.sh
less deploy.sh
bash deploy.sh

# Docker Compose
git clone https://github.com/gotempsh/temps.git && cd temps
docker-compose up -d

# From source (requires Rust 1.70+)
cargo build --release

Initial setup

temps setup \
  --database-url "postgresql://postgres:temps@localhost:16432/temps" \
  --admin-email "you@example.com" \
  --wildcard-domain "*.yourdomain.com" \
  --dns-provider "cloudflare" \
  --cloudflare-token "your-token"

Start the server

temps serve \
  --database-url "postgresql://..." \
  --address 0.0.0.0:80 \
  --tls-address 0.0.0.0:443 \
  --console-address 0.0.0.0:8081

estimate-temps-savings

Audit a project's infrastructure and SaaS stack, then produce a cost report showing what you pay today and what you would save by consolidating onto Temps.

npx skills add gotempsh/temps --skill estimate-temps-savings

It reads your dependencies, config files, and environment variable names to detect hosting platforms (Vercel, Netlify, Railway, Render, Heroku, Fly.io), analytics (PostHog, Plausible, Mixpanel, Amplitude, Fathom), error tracking (Sentry, Bugsnag, Rollbar, Honeybadger), session replay (LogRocket, FullStory, Hotjar, Highlight), uptime monitoring (Pingdom, UptimeRobot, Better Stack, Checkly), managed databases (Supabase, Neon, PlanetScale, MongoDB Atlas, Upstash, RDS), and transactional email (SendGrid, Postmark, Resend, Mailgun).

Triggers on: "how much would I save", "temps savings", "cost comparison", "audit my stack", "am I overpaying".

MCP servers

Temps previously published a @temps-sdk/mcp server for pointing an AI assistant at your instance. That package is no longer maintained. Temps standardised on skills plus bunx @temps-sdk/cli as the integration surface instead — the CLI already covers the same operations without a second package to keep in sync with the API.

If you want your assistant to manage Temps, install the temps skill and connect the CLI. The console walks you through it under Getting started → Connect your AI harness.

Existing @temps-sdk/mcp installs keep working against the last published version, but they will drift from the API over time and should be migrated.

add-react-analytics

Add analytics to React applications: page views, custom events, scroll depth, engagement, session recording, and Web Vitals.

npx skills add gotempsh/temps --skill add-react-analytics

Setup

npm install @temps-sdk/react-analytics

Wrap your app with TempsAnalyticsProvider:

import { TempsAnalyticsProvider } from '@temps-sdk/react-analytics'

export default function RootLayout({ children }) {
  return (
    <TempsAnalyticsProvider projectId={process.env.NEXT_PUBLIC_TEMPS_PROJECT_ID}>
      {children}
    </TempsAnalyticsProvider>
  )
}

Available hooks

Framework support: Next.js App Router, Next.js Pages Router, Vite, Create React App, Remix.

add-session-recording

Add privacy-aware session recording and replay using rrweb.

npx skills add gotempsh/temps --skill add-session-recording

Wrap your app with both providers:

import { TempsAnalyticsProvider, SessionRecordingProvider } from '@temps-sdk/react-analytics'

export default function App({ children }) {
  return (
    <TempsAnalyticsProvider projectId="...">
      <SessionRecordingProvider>
        {children}
      </SessionRecordingProvider>
    </TempsAnalyticsProvider>
  )
}

Privacy controls

<!-- Block entire element -->
<div data-rr-block>Payment form</div>

<!-- Mask text content (shows asterisks) -->
<span data-rr-mask>Sensitive info</span>

<!-- Block by CSS class -->
<input class="sensitive" />

Runtime control

import { useSessionRecording } from '@temps-sdk/react-analytics'

// Inside a component wrapped with SessionRecordingProvider:
function ConsentBanner() {
  const { isRecordingEnabled, enableRecording, disableRecording } = useSessionRecording()

  return isRecordingEnabled
    ? <button onClick={disableRecording}>Opt out of recording</button>
    : <button onClick={enableRecording}>Allow session recording</button>
}

// Standalone (no provider needed):
import { useSessionRecordingControl } from '@temps-sdk/react-analytics'

function RecordingToggle() {
  const { isEnabled, enable, disable } = useSessionRecordingControl()
  return <button onClick={isEnabled ? disable : enable}>Toggle recording</button>
}

CLI access

Browse and export recordings from the terminal:

# List recent sessions for a project
bunx @temps-sdk/cli session-replay list -p my-app

# Show session metadata
bunx @temps-sdk/cli session-replay show <visitor-id> <session-id>

# Download all events from a session as JSON
bunx @temps-sdk/cli session-replay events <visitor-id> <session-id> --output session.json

add-node-sdk

Integrate the Temps Node.js SDK for server-side analytics, KV storage, blob storage, and API access.

npx skills add gotempsh/temps --skill add-node-sdk

npm install @temps-sdk/node @temps-sdk/kv @temps-sdk/blob

Server-side analytics

import { Temps } from '@temps-sdk/node'

const temps = new Temps({
  apiKey: process.env.TEMPS_API_KEY,
  projectId: process.env.TEMPS_PROJECT_ID,
})

temps.track('purchase_completed', { amount: 99, currency: 'USD' })
temps.identify(userId, { plan: 'pro' })

KV storage

import { kv } from '@temps-sdk/kv'

await kv.set('key', { value: 'data' }, { ttl: 3600 })
const value = await kv.get('key')
await kv.list({ prefix: 'user:' })

Blob storage

import { blob } from '@temps-sdk/blob'

await blob.put('file.txt', buffer)
const url = await blob.getSignedUrl('file.txt', { expiresIn: 3600 })

add-custom-domain

Configure custom domains for Temps deployments with automatic SSL/TLS via Let's Encrypt.

npx skills add gotempsh/temps --skill add-custom-domain

Via CLI

# Subdomain (CNAME)
bunx @temps-sdk/cli cdom add --domain app.example.com --project-id <project-id>

# Apex domain (A record)
bunx @temps-sdk/cli cdom add --domain example.com --project-id <project-id>

# Wildcard (requires Cloudflare DNS-01)
bunx @temps-sdk/cli cdom add --domain "*.example.com" --project-id <project-id>

bunx @temps-sdk/cli cdom list --project-id <project-id>

DNS records

Certificates renew automatically 30 days before expiry.

add-error-tracking

Add Sentry-compatible error tracking to any framework. The Temps DSN is a drop-in replacement for a Sentry DSN — use the official Sentry SDK and point it at your Temps instance.

npx skills add gotempsh/temps --skill add-error-tracking

Next.js

npm install @sentry/nextjs

// sentry.client.config.ts
import * as Sentry from '@sentry/nextjs'

Sentry.init({
  dsn: process.env.NEXT_PUBLIC_SENTRY_DSN, // your Temps DSN
})

Environment variable by framework

Find your Temps DSN in the dashboard under Error Tracking → Project Settings.

temps-plugin

Build external plugins for the Temps platform as standalone Rust binaries. Plugins are discovered automatically, spawned by Temps, and communicate over Unix domain sockets.

npx skills add gotempsh/temps --skill temps-plugin

Temps proxies POST /api/x/{plugin_name}/* to your plugin's socket and serves the plugin UI at /api/x/{plugin_name}/ui/*.

Project structure

my-plugin/
├── Cargo.toml       # SDK dependency
├── build.rs         # Vite UI compilation
├── src/
│   ├── main.rs      # Plugin struct and routes
│   ├── db.rs        # SQLite via sea-orm
│   └── types.rs     # API DTOs
└── web/             # React + TypeScript UI

Key constraints

• Never register a /health route — the SDK provides one automatically
• Never use #[tokio::main] — the SDK creates its own runtime
• Use tokio::task::block_in_place() for async in the router() function
• Access Temps data via ctx.temps(), never directly via the database

Additional Resources