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

The current release, v0.1.0-beta.56, ships 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.

npx skills add gotempsh/temps installs from the repository's default branch, which also carries a 13th skill, temps-mcp-setup. It configures the built-in MCP server that only nightly builds have, so skip it unless you run a nightly (see MCP servers).

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-mcp-setup
  ◻ 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.

Docs: CLI getting started.

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.

Docs: Production checklist and Add observability.

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

Frameworks: Temps auto-detects Next.js, Vite, Rsbuild, Docusaurus, Python (Django, FastAPI, Flask), Go, Rust and Java. Create React App isn't detected; choose the react-app preset. Express, NestJS, Remix and other Node servers use the Node preset, and any app with a Dockerfile works.

Docs: Your first deployment and Supported platforms.

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

Build settings (preset, build and install commands, port) live in the project's settings in the dashboard. Health checks, cron jobs and alerts go in a .temps.yaml file at the repository root:

# .temps.yaml
health:
  path: /api/health

Replicas, CPU and memory are set per environment; see Scaling.

Environment variables

bunx @temps-sdk/cli environments vars set DATABASE_URL "postgres://..." -e production
bunx @temps-sdk/cli environments vars import .env -e production  # import from a file
bunx @temps-sdk/cli environments vars list -e production

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

Docs: CLI reference.

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 (installs Docker if needed, runs TimescaleDB in Docker,
# then runs `temps setup` and creates the first admin for you)
curl -fsSL https://temps.sh/deploy.sh -o deploy.sh
less deploy.sh
bash deploy.sh

# Docker Compose: set POSTGRES_PASSWORD and REDIS_PASSWORD in a .env file first
git clone https://github.com/gotempsh/temps.git && cd temps
docker compose up -d

# From source (needs a Rust toolchain)
cargo build --release

Initial setup

The install script runs this for you. Run it yourself only for a manual install:

temps setup \
  --database-url "postgresql://temps:<password>@localhost:5432/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

Docs: Quickstart and Upgrade Temps.

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.

Nightly only: nightly builds add an MCP server built into the temps binary (off by default) and a temps-mcp-setup skill that connects Claude Code, Cursor and other clients to it. Neither is in v0.1.0-beta.56, so on the current release use the temps skill and the CLI.

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. For an app deployed on Temps no configuration is needed: events go to the default basePath, /api/_temps, which the Temps proxy routes to analytics ingest.

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

export default function RootLayout({ children }) {
  return (
    <TempsAnalyticsProvider>
      {children}
    </TempsAnalyticsProvider>
  )
}

Available hooks

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

Docs: React analytics SDK and Analytics.

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

Docs: Session replay.

add-node-sdk

Integrate the Temps Node.js packages: the platform API client and server-side error tracking, KV storage, and blob storage.

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

npm install @temps-sdk/node-sdk   # platform API client + error tracking
npm install @temps-sdk/kv         # optional: KV storage
npm install @temps-sdk/blob       # optional: blob storage

Platform API client

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

const temps = new TempsClient({
  baseUrl: process.env.TEMPS_API_URL,
  apiKey: process.env.TEMPS_API_KEY,
})
// Resource namespaces: temps.projects, temps.deployments, temps.analytics, ...

KV storage

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

await kv.set('session:abc', { userId: '123' }, { ex: 3600 }) // expires in 1 hour
const session = await kv.get('session:abc')
const keys = await kv.keys('session:*')

Blob storage

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

const info = await blob.put('avatars/user-123.png', imageBuffer, { contentType: 'image/png' })
const res = await blob.download(info.url)

Docs: Node SDK and KV storage.

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 DNS-01 through a supported DNS provider)
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

Let's Encrypt certificates renew automatically before they expire.

Docs: Add a custom domain and Domains and SSL.

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.

Docs: Error tracking.

temps-plugin

Build external plugins for the Temps platform: standalone binaries that Temps discovers in its plugins directory, spawns, and talks to over a Unix domain socket. Write them in TypeScript with Bun (@temps-sdk/plugin, beta) or in Rust.

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/*.

Rust 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 for Rust plugins

• 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

Docs: Plugins. Published plugins are listed in the plugin catalogue.

Related

• MCP Servers — register the external tools a Temps agent can call from its sandbox.
• Sandboxes & Workspaces — isolated containers where AI coding agents run.
• AI Gateway — one OpenAI-compatible endpoint for OpenAI, Anthropic, Gemini and xAI.
• Plugins — extend Temps with in-process or external plugins.
• AI agents on Temps — the overview of agent sandboxes, the gateway and skills together.

Additional Resources