mirror of https://github.com/getsentry/sentry-agent-skills.git synced 2026-09-20 14:23:25 +08:00

T

Daniel Griesser aeece801b5 feat: SDK skill bundles — opinionated, full-platform Sentry setup wizards (#8 )

* docs: add SDK skill bundle philosophy guide

Introduces docs/sdk-skill-philosophy.md — the canonical authoring guide
for SDK skill bundles, a new pattern that goes beyond single-feature skills
to provide full, opinionated Sentry setup wizards for each SDK.

The document covers:
- Bundle architecture: a lean main SKILL.md wizard (<500 lines) paired with
  a references/ directory of deep-dive files, one per feature pillar
- Feature pillars matrix showing which pillars each SDK type supports
  (error monitoring, tracing, profiling, logging, metrics, crons, session
  replay, AI monitoring)
- The four-phase wizard flow: Detect → Recommend → Guide → Cross-Link,
  with concrete implementation patterns and example markdown
- Opinionated recommendation logic — e.g. always recommend error monitoring,
  recommend tracing when HTTP handlers are detected, etc.
- The 'non-negotiable baseline' rule: error monitoring is never opt-in
- Reference file format requirements and style rules
- Naming conventions for skill directories, SKILL.md fields, and reference files
- A minimal SKILL.md scaffold authors can copy to start a new bundle
- A 'Staying Current' section covering version requirements and the
  docs-verification disclaimer pattern

Also adds an 'SDK Skill Bundles' section to AGENTS.md pointing to the new
guide, so skill authors discover it alongside the existing Setup and Workflow
categories.

* feat(go-sdk): add sentry-go-sdk main SKILL.md wizard

Introduces the primary wizard file for the sentry-go-sdk bundle, a four-phase
opinionated setup guide for integrating Sentry into Go applications.

Phase 1 (Detect) scans go.mod for the existing sentry-go dependency, the active
web framework (Gin, Echo, Fiber, FastHTTP, Iris, Negroni, net/http), logging
libraries (logrus, zap, zerolog, slog), cron scheduler patterns, OpenTelemetry
usage, and companion frontend directories — giving the agent a complete picture
before making any recommendations.

Phase 2 (Recommend) presents a concrete, opinionated proposal rather than an
open-ended question. Error monitoring is always recommended; tracing is triggered
by HTTP/gRPC/DB patterns; logging fires when a known logging library is detected;
profiling, metrics, and crons are flagged as optional enhancements.

Phase 3 (Guide) covers installation of the core SDK and the correct framework
sub-package, a full-featured recommended sentry.Init() call with build-time
release injection, a framework middleware table documenting the correct
Repanic/WaitForDelivery settings per framework (critical for Fiber/FastHTTP
which use fasthttp with no built-in recovery), and a reference dispatch table
that tells the agent which references/<feature>.md to load for each agreed
feature pillar.

Phase 4 (Cross-Link) detects companion frontend directories and maps them to
the appropriate Sentry frontend skill (sentry-react-setup, sentry-svelte-sdk, etc.).

Also includes a full ClientOptions reference table, environment variable mapping,
a verification code snippet, and a troubleshooting table covering the most common
Go-specific gotchas (os.Exit bypassing defer flush, goroutine hub cloning,
SampleRate 0.0 behaviour, fasthttp middleware options).

285 lines — well within the 500-line Agent Skills spec limit.

* feat(go-sdk): add reference deep-dives for all six feature pillars

Create six reference files in skills/sentry-go-sdk/references/ that
serve as the deep-dive documentation loaded on demand by the main
SKILL.md wizard. Each file covers one Sentry feature pillar with
working code examples, configuration tables, and troubleshooting
guides sourced from the sentry-go v0.43.0 API.

error-monitoring.md — CaptureException/Message/Event, panic recovery
  (Recover/RecoverWithContext), hub cloning for goroutines, scope
  enrichment (tags, user, context, breadcrumbs), error chain unwrapping
  (%w / errors.Join / pkg/errors), BeforeSend filtering, event
  processors, and custom fingerprinting.

tracing.md — EnableTracing configuration, TracesSampler vs
  TracesSampleRate, StartTransaction/StartSpan/StartChild patterns,
  span status and data, all five framework middleware integrations
  (sentryhttp, sentrygin, sentryecho, sentryfiber, sentryiris),
  distributed tracing header propagation (sentry-trace + baggage),
  and the OTel bridge via sentryotel.

profiling.md — Accurately documents that profiling was removed in
  v0.31.0 (ProfilesSampleRate does not exist). Includes a compile-error
  example showing the broken field, explains the history, and points to
  Go-native alternatives (pprof, Pyroscope, etc.).

logging.md — Native sentry.NewLogger(ctx) API with full Logger and
  LogEntry interfaces, EnableLogs requirement, BeforeSendLog filtering,
  auto-attached attributes, and all four library integrations: logrus
  (NewLogHook vs NewEventHook with correct level mapping and special
  field names), slog (Option struct, LevelFatal constant, level-to-
  severity mapping), zerolog (sends Events not Logs — explicitly
  documented), and zap (sentryzap.NewSentryCore, Context() helper,
  added in v0.43.0).

metrics.md — Open-beta Meter interface (Count/Gauge/Distribution only —
  Sets are not implemented in Go), MeterOption functions, all unit
  constants, BeforeSendMetric hook, trace-linked metrics via
  meter.WithCtx(), timing via time.Since()+Distribution (no built-in
  timer), and cardinality best practices.

crons.md — CheckIn/MonitorConfig structs, CrontabSchedule and
  IntervalSchedule constructors (int64 types noted), the check-in vs
  heartbeat patterns with complete before/after examples, manual
  robfig/cron integration wrapper, error-to-monitor linking via scope
  context, rate limit guidance (6/min), and nil-safety note for
  CaptureCheckIn return value.

* feat(svelte-sdk): add sentry-svelte-sdk main SKILL.md wizard

Introduces the main wizard skill for the Sentry Svelte/SvelteKit SDK
bundle, following the four-phase wizard architecture established in
docs/sdk-skill-philosophy.md.

The skill handles both Svelte (standalone/Vite) and SvelteKit projects,
with three distinct setup paths:

- Path A: SvelteKit modern (≥2.31.0) — wizard or manual; covers
  instrumentation.server.ts, hooks.client.ts, hooks.server.ts,
  svelte.config.js, and vite.config.ts for source map upload
- Path B: SvelteKit legacy (<2.31.0) — Sentry.init() in hooks.server.ts
  without the instrumentation file
- Path C: Plain Svelte — single entry point setup with optional
  component tracking via svelte.config.js preprocessor

Phase 1 detects the framework type (SvelteKit vs. plain Svelte), version,
existing Sentry presence, logging libraries, and companion backend
directories. Phase 2 gives an opinionated feature recommendation matrix
covering Error Monitoring, Tracing, Session Replay, and Logging. Phase 3
walks through each path with complete, production-ready Quick Start
configs. Phase 4 cross-links to backend SDK skills (Go, Python, Ruby,
Node) when a companion backend is detected.

Also includes: SvelteKit file summary table, adapter compatibility table,
full Sentry.init() config reference, verification steps, and a
troubleshooting table covering the most common SvelteKit-specific pitfalls
(legacy wrapLoadWithSentry, cloudflare adapter, ad-blocker tunneling).

436 lines — well within the 500-line budget. Reference deep-dives for
each feature pillar (error-monitoring.md, tracing.md, session-replay.md,
logging.md) will be added in subsequent tasks.

* feat(svelte-sdk): add reference deep-dives for all four feature pillars

Adds four reference files to skills/sentry-svelte-sdk/references/ covering
the complete Sentry feature surface for Svelte and SvelteKit:

- error-monitoring.md — automatic capture via handleErrorWithSentry() and
  sentryHandle(), manual captureException/captureMessage, context enrichment
  (user, tags, breadcrumbs, extra, initialScope), beforeSend filtering,
  Svelte component tracking with withSentryConfig(), +error.svelte integration,
  and withScope vs configureScope semantics

- tracing.md — browserTracingIntegration() for client-side page loads and
  navigations, sentryHandle() for server-side request instrumentation, custom
  spans (startSpan/startSpanManual/startInactiveSpan), sampling including
  dynamic tracesSampler, tracePropagationTargets for distributed tracing,
  SSR→client trace stitching via injected <meta> tags, load function tracing,
  Web Vitals capture, span filtering, and legacy wrapLoadWithSentry notes

- session-replay.md — replayIntegration() setup for both SvelteKit and
  standalone Svelte, sample rate guidance by traffic volume including
  errors-only strategy, privacy-first masking defaults with selector-based
  unmask/unblock and data-sentry-* HTML attributes, network capture with
  networkDetailAllowUrls, canvas recording, lazy loading, event filtering
  via beforeAddRecordingEvent, CSP requirements, and SvelteKit-specific notes

- logging.md — enableLogs configuration in both hook files, all six
  Sentry.logger levels, logger.fmt parameterized messages for searchable
  attributes, consoleLoggingIntegration and Consola reporter, scope-based
  automatic attributes (getGlobalScope/getIsolationScope for SDK ≥10.32.0),
  beforeSendLog filtering, auto-generated attribute table, trace+log
  correlation, and SvelteKit server-side logging patterns

Each reference file covers both Svelte and SvelteKit where they differ,
uses tables over prose, and includes minimum SDK version requirements at
the top for features that have a higher version floor.

* docs(readme): add sentry-go-sdk and sentry-svelte-sdk SDK bundle entries

Introduces a new top-level 'SDK Skills (Full Platform Bundles)' section in
the Available Skills table, placed above the existing Setup Skills section to
reflect their broader scope. Adds the two new skills:

- sentry-go-sdk: full wizard for Go (net/http, Gin, Echo, Fiber), covering
  error monitoring, tracing, profiling, logging, metrics, and crons
- sentry-svelte-sdk: full wizard for Svelte/SvelteKit, covering error
  monitoring, tracing, session replay, and logging

Also updates:
- Usage section: adds a parallel 'SDK Skills' subsection with trigger phrases
  for Go and SvelteKit so users know what to say to activate each skill
- Skill Format section: documents the references/ directory pattern used by
  SDK bundles to keep deep-dive content out of the main wizard prompt
- Contributing section: links to docs/sdk-skill-philosophy.md for authors
  who want to create additional full-platform SDK skill bundles

All changes are additive; no existing content was restructured.

* fix(skills): correct P0+P1 review findings across go and svelte skills

Three correctness fixes identified during code review:

**P0 — Remove profiling from sentry-go-sdk advertising**
Profiling was removed from the sentry-go SDK in v0.31.0. While
references/profiling.md correctly documents this removal, the skill
was still actively advertising and recommending profiling in:
- README.md SDK skills table description
- SKILL.md frontmatter description field
- SKILL.md 'Invoke This Skill When' trigger list
- Phase 2 optional features list and recommendation table
- Phase 2 proposal sentence

Profiling is now marked with a ⚠️ warning in the recommendation
table ('Removed in v0.31.0 — do not recommend') and removed from
all advertising copy. The references/profiling.md reference file is
retained as-is since it correctly documents the removal and offers
OpenTelemetry alternatives.

**P1 — Replace deprecated configureScope with modern scope APIs**
The error-monitoring.md reference for sentry-svelte-sdk was using
Sentry.configureScope(), deprecated since SDK v8. Replaced with the
modern Sentry.getIsolationScope() / Sentry.getGlobalScope() APIs,
which match the pattern already used in the logging reference for
the same skill. Added minimum SDK version notes (≥8.0.0 for
isolation scopes, ≥10.32.0 for getGlobalScope/getIsolationScope).
Also updated the Best Practices bullet that recommended configureScope.

**P1 — Add <svelte:boundary> error boundary coverage**
Svelte 5 introduced <svelte:boundary> for catching component-level
errors before they crash the full page. Added a dedicated 'Error
Boundaries (Svelte 5+)' section showing: basic onerror integration
with captureException, the failed snippet fallback UI pattern, and
a second example combining reset() with lastEventId() +
showReportDialog() for user feedback. Includes requirements note
(Svelte 5 + @sveltejs/kit ≥2.x) and practical tips on nesting
boundaries for widget isolation.

* feat(sdk-skill-creator): add meta-skill for creating SDK skill bundles

Add sentry-sdk-skill-creator — a process skill that codifies the full
workflow for producing research-backed SDK skill bundles for any Sentry
platform. Captures the exact methodology used to build the Go and Svelte
SDK skills.

The main SKILL.md (290 lines) walks through six phases:
1. Identify the SDK and its feature matrix
2. Research all feature pillars via parallel claude tasks with outputFile
3. Create the main wizard SKILL.md following the philosophy doc
4. Create reference deep-dive files for each feature pillar
5. Verify APIs against actual SDK source code, run reviewer
6. Register the skill in README.md and commit

Two reference files support the process:
- research-playbook.md: prompt templates for each research batch,
  execution pattern, file naming conventions, failure recovery
- quality-checklist.md: spec compliance, wizard flow requirements,
  code example quality rubric, accuracy red flags, cross-cutting
  consistency checks, and final verification commands

Also adds an 'Authoring Skills' section to README.md.

* feat(ruby-sdk): add sentry-ruby-sdk skill bundle

Full Sentry setup wizard for Ruby covering error monitoring, tracing,
logging, custom metrics (Sidekiq), and migration from AppSignal/Honeybadger.
Includes five reference deep-dives and README entries.

Co-Authored-By: Claude <noreply@anthropic.com>

* test(ruby-sdk): add three-app validation harness for sentry-ruby-sdk

Includes Rails, Sinatra, and Honeybadger migration test apps plus a
three-mode validation script (mock/spotlight/real) and a pure-Ruby
mock server for zero-dependency local testing.

Co-Authored-By: Claude <noreply@anthropic.com>

* ref(ruby-sdk): remove dashboard creation from metrics reference

Dashboard creation is better done manually via the Sentry UI. The curl
snippet was overly complex and error-prone (wrong region, API quirks).

Co-Authored-By: Claude <noreply@anthropic.com>

* ref(ruby-sdk): store pre-skill baseline in test apps

Commit pre-Sentry state so reset.sh can use git restore and git diff
shows exactly what the skill generates. rails-app and honeybadger_app
Gemfiles have no Sentry gems; sinatra_app.rb has no Sentry setup;
honeybadger_app uses Honeybadger.notify throughout.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(ruby-sdk): add competitor initializer deletion to migration docs

The migration guide and skill wizard omitted deleting the competitor's
initializer file (config/initializers/honeybadger.rb, appsignal.rb).
Leaving it in place causes startup failures because the competitor gem
is no longer installed but its initializer still runs.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(ruby-sdk): address P1/P2/P3 quality-checklist findings

- logging.md: add required `enabled_patches << :logger` prerequisite for
  std_lib_logger_filter — without it the filter proc is never called (P1)
- tracing.md: add config options table (traces_sample_rate, traces_sampler,
  trace_propagation_targets, propagate_traces) matching reference file spec (P2)
- metrics.md: tighten minimum SDK version from vague v6.x+ to v6.3.0+,
  which is when the count/gauge/distribution API replaced the beta increment (P2)
- migration.md: add missing minimum SDK version header present on all other
  reference files (P2)
- SKILL.md: add "Invoke This Skill When" section and update version note to
  v6.4.0; add Configuration Reference table with all key init options and env
  vars; add Profiling and Crons rows to Phase 2 recommend table and Phase 3
  feature reference dispatch table (P2/P3)

Co-Authored-By: Claude <noreply@anthropic.com>

* feat(ruby-sdk): add profiling and crons reference deep-dives

profiling.md: covers StackProf (sentry-ruby ≥5.9.0) and Vernier (≥5.21.0,
Ruby 3.2.1+) setup, profiles_sample_rate config, beta disclaimer, and
troubleshooting. Vernier preferred for Ruby 3.2.1+ due to lower overhead.

crons.md: covers manual capture_check_in pattern, ActiveJob mixin
(Sentry::Cron::MonitorCheckIns), Sidekiq-Cron auto-capture via
enabled_patches, MonitorConfig upsert with crontab and interval schedules,
heartbeat pattern, and troubleshooting.

Both pillars were missing from the skill bundle; SKILL.md already updated
to route to these files.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(sdk-skill-creator): correct relative path to philosophy doc

The ${SKILL_ROOT} variable resolves to skills/sentry-sdk-skill-creator/,
so two parent traversals (../../) reach the repo root where docs/ lives.
The previous path had three (../../../), which would resolve above the
repository root and fail to load the philosophy document.

* feat(python-sdk): add sentry-python-sdk main SKILL.md wizard

Introduces the four-phase setup wizard for the Sentry Python SDK skill bundle.
The wizard follows the same structural pattern as sentry-go-sdk and
sentry-svelte-sdk but is tailored to Python's broader ecosystem.

Key design decisions:

- Phase 1 scans both requirements.txt and pyproject.toml (Python has no
  single canonical dependency file like go.mod), plus detects frameworks,
  task queues, logging libs, AI libraries, and cron patterns.

- Phase 2 recommendation matrix covers all seven feature pillars:
  Error Monitoring (always), Tracing (HTTP framework detected), Profiling
  (production), Logging (always — stdlib auto-captured), Metrics, Crons
  (Celery Beat / APScheduler), and AI Monitoring (OpenAI/Anthropic/etc.
  are zero-config auto-instrumented).

- Phase 3 init placement table covers 11 frameworks including the special
  cases: Sanic (must init inside before_server_start listener), Celery
  (dual-process init via celeryd_init signal), and RQ (settings file
  loaded by worker process). Full Quick Start init enables tracing,
  continuous profiling, and structured logs with sensible defaults.

- Auto-enabled vs explicit integration table saves the agent from
  unnecessarily adding integrations=[] for frameworks that wire up
  automatically.

- Verification, configuration reference, env var table, and 14-entry
  troubleshooting table cover the most common Python gotchas (uWSGI
  threading flags, cross-request scope leaks, Sanic lifecycle init,
  RQ --sentry-dsn flag conflict).

- Phase 4 cross-links to sentry-react-setup and sentry-svelte-sdk for
  companion frontend directories.

317 lines — well under the 500-line limit.

* feat(python-sdk): add reference deep-dive files for all 7 feature pillars

Add seven reference files under skills/sentry-python-sdk/references/ covering
every major Sentry feature pillar for Python:

- error-monitoring.md — capture APIs, scope management (global/isolation/current
  scopes, new_scope()), context enrichment (tags, user, context, breadcrumbs),
  before_send hook, fingerprinting, EventScrubber PII scrubbing, Exception Groups
- tracing.md — traces_sample_rate, traces_sampler, @sentry_sdk.trace decorator,
  start_transaction/start_span, distributed tracing headers, auto-instrumented
  databases (SQLAlchemy, Redis, PyMongo), OTel bridge
- profiling.md — both APIs: transaction-based (profiles_sample_rate, SDK 1.18+)
  and continuous (profile_session_sample_rate + profile_lifecycle, SDK 2.24.1+),
  manual start/stop profiler
- logging.md — distinguishes Sentry Structured Logs (enable_logs, sentry_sdk.logger,
  SDK 2.35+) from classic LoggingIntegration breadcrumbs/events; covers Loguru,
  before_send_log, and the decision table for which system to use
- metrics.md — count/distribution/gauge/set/timing APIs, unit strings, attribute
  cardinality guidance, before_send_metric hook (SDK 2.44+, open beta)
- crons.md — @monitor decorator, capture_checkin() manual API, MonitorConfig upsert,
  MonitorStatus constants, heartbeat pattern, Celery Beat auto-discovery
- ai-monitoring.md — all 10 integrations with auto-enabled vs explicit matrix,
  PII two-layer control, gen_ai.* manual span ops, token attribute accounting,
  agent workflow hierarchy, streaming support, unsupported provider workarounds

All files follow the reference format: tables over prose, working Python code
examples, version requirements at top, troubleshooting tables.

* docs(readme): add sentry-python-sdk to SDK skills table and usage section

Registers the new sentry-python-sdk skill bundle in the Available Skills
table and the Usage quick-reference section.

- Added sentry-python-sdk row to the SDK Skills (Full Platform Bundles)
  table with description covering error monitoring, tracing, profiling,
  logging, metrics, crons, and AI monitoring across Django, Flask,
  FastAPI, Celery, Starlette, and AIOHTTP
- Added three trigger-phrase rows to the SDK Skills usage table so users
  know which natural-language prompts activate the skill (generic Python
  app, framework-specific setup, and OpenAI/LangChain AI monitoring)

* fix(python-sdk): correct P1 review findings in metrics and AI monitoring references

Remove fabricated metrics APIs (Set and Timing) that were removed in
sentry-sdk v2.41.0 — only count(), gauge(), and distribution() exist in
the current API. Update overview text to match.

Fix AI monitoring integration matrix auto-enabled status:
- Google GenAI: ⚠️ Use explicit → ✅ Yes (it is auto-enabled)
- MCP: ❌ No → ✅ Yes (auto-enabled since v2.43.0)
- Pydantic AI: ❌ No → ✅ Yes (auto-enabled since v2.43.0)

Update bold warning to reflect that only LiteLLM requires explicit
registration. Remove MCPIntegration, PydanticAIIntegration, and
GoogleGenAIIntegration from the explicit-registration code example.

Replace the misleading single-version header '2.41.0+' with a more
accurate range: '2.1.0+ (core AI spans); 2.45.0+ for auto-enabling
all integrations'.

Add '> Requires SDK ≥ 2.51.0' note to the conversation tracking
(set_conversation_id) section.

Fix the LiteLLM/MCP troubleshooting row — MCP is now auto-enabled so
the row now mentions only LiteLLM.

Fix SKILL.md enable_logs troubleshooting entry to distinguish between
direct structured logging via sentry_sdk.logger and stdlib bridging via
LoggingIntegration(sentry_logs_level=...).

* chore(ruby-sdk): remove test-apps directory from skill bundle

Skills ship as agent context, not as runnable projects. The test-apps
directory (Rails app, Sinatra app, Honeybadger migration app, mock
server, and validation scripts) adds 27 files of application code that
doesn't belong in a skill bundle. No skill or reference file references
these files — they were used during development only.

---------

Co-authored-by: Johannes Daxböck <johannes.daxboeck@sentry.io>
Co-authored-by: Claude <noreply@anthropic.com>

2026-02-26 18:20:00 +01:00

.github/workflows

fix: Update release workflow with renamed skills

2026-01-13 23:17:56 -08:00

docs

feat: SDK skill bundles — opinionated, full-platform Sentry setup wizards (#8 )

2026-02-26 18:20:00 +01:00

skills

feat: SDK skill bundles — opinionated, full-platform Sentry setup wizards (#8 )

2026-02-26 18:20:00 +01:00

AGENTS.md

feat: SDK skill bundles — opinionated, full-platform Sentry setup wizards (#8 )

2026-02-26 18:20:00 +01:00

README.md

feat: SDK skill bundles — opinionated, full-platform Sentry setup wizards (#8 )

2026-02-26 18:20:00 +01:00

README.md

Sentry Agent Skills

Official agent skills for integrating Sentry into your projects. These skills provide AI coding assistants with the knowledge to set up Sentry, debug production issues, and leverage Sentry's full observability platform.

Available Skills

SDK Skills (Full Platform Bundles)

Skill	Description	Platforms	Docs
`sentry-go-sdk`	Full Sentry setup wizard for Go — error monitoring, tracing, logging, metrics, crons	Go (net/http, Gin, Echo, Fiber)	Go Guide
`sentry-python-sdk`	Full Sentry setup wizard for Python — error monitoring, tracing, profiling, logging, metrics, crons, AI monitoring	Python (Django, Flask, FastAPI, Celery, Starlette, AIOHTTP)	Python Guide
`sentry-svelte-sdk`	Full Sentry setup wizard for Svelte/SvelteKit — error monitoring, tracing, session replay, logging	Svelte, SvelteKit	SvelteKit Guide
`sentry-ruby-sdk`	Full Sentry setup wizard for Ruby — error monitoring, tracing, logging, Sidekiq metrics + dashboard, migration from AppSignal/Honeybadger	Ruby, Rails, Sinatra, Rack, Sidekiq	Ruby Guide

Setup Skills

Skill	Description	Platforms	Docs
`sentry-react-setup`	Setup Sentry in React apps	React	React Guide
`sentry-react-native-setup`	Setup Sentry in React Native using the wizard CLI	React Native, Expo	React Native Guide
`sentry-python-setup`	Setup Sentry in Python apps	Python (Django, Flask, FastAPI)	Python Guide
`sentry-ruby-setup`	Setup Sentry in Ruby apps	Ruby (Rails)	Ruby Guide
`sentry-ios-swift-setup`	Setup Sentry in iOS/Swift apps	iOS (Swift, UIKit, SwiftUI)	Apple Guide
`sentry-setup-tracing`	Setup Sentry Tracing (Performance Monitoring)	JS, Python, Ruby	Tracing
`sentry-setup-logging`	Setup Sentry Logging	JS, Python, Ruby	Logs
`sentry-setup-metrics`	Setup Sentry Metrics	JS, Python	Metrics
`sentry-setup-ai-monitoring`	Setup Sentry AI Agent Monitoring	JS, Python	AI Monitoring

Workflow Skills

Skill	Description	Requirements	Docs
`sentry-fix-issues`	Find and fix issues from Sentry using MCP	Sentry MCP	Issues
`sentry-pr-code-review`	Review a project's PRs to check for issues detected in code review by Seer Bug Prediction	GitHub CLI	Seer
`sentry-create-alert`	Create Sentry alerts using the workflow engine API	`curl`, auth token	Alerts

Authoring Skills

Skill	Description	Requirements
`sentry-sdk-skill-creator`	Create a complete SDK skill bundle for any new platform — research, write, verify, and register	Web search, `claude` tool

Installation

Quick Install (Recommended)

Install all skills using the skills CLI:

npx skills add https://github.com/getsentry/sentry-agent-skills

Or install a specific skill:

npx skills add https://github.com/getsentry/sentry-agent-skills --skill sentry-fix-issues

Browse available skills at skills.sh/getsentry/sentry-agent-skills.

Manual Installation

Choose your AI coding assistant below and run the appropriate command.

Claude Code

User-level (applies to all projects):

git clone https://github.com/getsentry/sentry-agent-skills.git /tmp/sentry-skills && \
  mkdir -p ~/.claude/skills && \
  cp -r /tmp/sentry-skills/skills/* ~/.claude/skills/ && \
  rm -rf /tmp/sentry-skills

Project-level (single repository):

git clone https://github.com/getsentry/sentry-agent-skills.git /tmp/sentry-skills && \
  mkdir -p .claude/skills && \
  cp -r /tmp/sentry-skills/skills/* .claude/skills/ && \
  rm -rf /tmp/sentry-skills

Directory structure

~/.claude/skills/              # User-level
.claude/skills/                # Project-level

# Each skill:
sentry-setup-tracing/
  SKILL.md

OpenAI Codex

User-level (applies to all projects):

git clone https://github.com/getsentry/sentry-agent-skills.git /tmp/sentry-skills && \
  mkdir -p ~/.codex/skills && \
  cp -r /tmp/sentry-skills/skills/* ~/.codex/skills/ && \
  rm -rf /tmp/sentry-skills

Project-level (single repository):

git clone https://github.com/getsentry/sentry-agent-skills.git /tmp/sentry-skills && \
  mkdir -p .codex/skills && \
  cp -r /tmp/sentry-skills/skills/* .codex/skills/ && \
  rm -rf /tmp/sentry-skills

Directory structure

~/.codex/skills/               # User-level
.codex/skills/                 # Project-level

# Each skill:
sentry-setup-tracing/
  SKILL.md

GitHub Copilot

User-level (applies to all projects):

git clone https://github.com/getsentry/sentry-agent-skills.git /tmp/sentry-skills && \
  mkdir -p ~/.copilot/skills && \
  cp -r /tmp/sentry-skills/skills/* ~/.copilot/skills/ && \
  rm -rf /tmp/sentry-skills

Project-level (single repository):

git clone https://github.com/getsentry/sentry-agent-skills.git /tmp/sentry-skills && \
  mkdir -p .github/skills && \
  cp -r /tmp/sentry-skills/skills/* .github/skills/ && \
  rm -rf /tmp/sentry-skills

Directory structure

~/.copilot/skills/             # User-level
.github/skills/                # Project-level

# Each skill:
sentry-setup-tracing/
  SKILL.md

Cursor

Note: Agent skills require Cursor Nightly. Enable via: Cursor Settings > Rules > Import Settings > Agent Skills

User-level (applies to all projects):

git clone https://github.com/getsentry/sentry-agent-skills.git /tmp/sentry-skills && \
  mkdir -p ~/.cursor/skills && \
  cp -r /tmp/sentry-skills/skills/* ~/.cursor/skills/ && \
  rm -rf /tmp/sentry-skills

Project-level (single repository):

git clone https://github.com/getsentry/sentry-agent-skills.git /tmp/sentry-skills && \
  mkdir -p .cursor/skills && \
  cp -r /tmp/sentry-skills/skills/* .cursor/skills/ && \
  rm -rf /tmp/sentry-skills

Directory structure

~/.cursor/skills/              # User-level
.cursor/skills/                # Project-level

# Each skill:
sentry-setup-tracing/
  SKILL.md

OpenCode

User-level (applies to all projects):

git clone https://github.com/getsentry/sentry-agent-skills.git /tmp/sentry-skills && \
  mkdir -p ~/.config/opencode/skill && \
  cp -r /tmp/sentry-skills/skills/* ~/.config/opencode/skill/ && \
  rm -rf /tmp/sentry-skills

Project-level (single repository):

git clone https://github.com/getsentry/sentry-agent-skills.git /tmp/sentry-skills && \
  mkdir -p .opencode/skill && \
  cp -r /tmp/sentry-skills/skills/* .opencode/skill/ && \
  rm -rf /tmp/sentry-skills

Directory structure

~/.config/opencode/skill/      # User-level
.opencode/skill/               # Project-level

# Also supports Claude-compatible paths:
~/.claude/skills/              # User-level (alternative)
.claude/skills/                # Project-level (alternative)

# Each skill:
sentry-setup-tracing/
  SKILL.md

AmpCode (Sourcegraph Amp)

User-level (applies to all projects):

git clone https://github.com/getsentry/sentry-agent-skills.git /tmp/sentry-skills && \
  mkdir -p ~/.config/agents/skills && \
  cp -r /tmp/sentry-skills/skills/* ~/.config/agents/skills/ && \
  rm -rf /tmp/sentry-skills

Project-level (single repository):

git clone https://github.com/getsentry/sentry-agent-skills.git /tmp/sentry-skills && \
  mkdir -p .agents/skills && \
  cp -r /tmp/sentry-skills/skills/* .agents/skills/ && \
  rm -rf /tmp/sentry-skills

Directory structure

~/.config/agents/skills/       # User-level
.agents/skills/                # Project-level

# Also supports Claude-compatible paths:
~/.claude/skills/              # User-level (alternative)
.claude/skills/                # Project-level (alternative)

# Each skill:
sentry-setup-tracing/
  SKILL.md

Quick Reference

Client	User-Level Path	Project-Level Path
Claude Code	`~/.claude/skills/`	`.claude/skills/`
Codex	`~/.codex/skills/`	`.codex/skills/`
Copilot	`~/.copilot/skills/`	`.github/skills/`
Cursor	`~/.cursor/skills/`	`.cursor/skills/`
OpenCode	`~/.config/opencode/skill/`	`.opencode/skill/`
AmpCode	`~/.config/agents/skills/`	`.agents/skills/`

Usage

Once installed, your AI assistant will automatically discover the skills. Simply ask:

SDK Skills (Full Platform Bundles)

What to Say	Skill Used
"Add Sentry to my Go app"	`sentry-go-sdk`
"Set up Sentry in my Gin/Echo/Fiber project"	`sentry-go-sdk`
"Add Sentry to my Python app"	`sentry-python-sdk`
"Set up Sentry in my Django/Flask/FastAPI project"	`sentry-python-sdk`
"Monitor my OpenAI/LangChain calls in Python"	`sentry-python-sdk`
"Add Sentry to my SvelteKit app"	`sentry-svelte-sdk`
"Set up Sentry in Svelte"	`sentry-svelte-sdk`
"Add Sentry to my Ruby/Rails app"	`sentry-ruby-sdk`
"Set up Sentry metrics for Puma/Sidekiq"	`sentry-ruby-sdk`
"Migrate from AppSignal to Sentry"	`sentry-ruby-sdk`
"Replace Honeybadger with Sentry"	`sentry-ruby-sdk`

Setup

What to Say	Skill Used
"Add Sentry to my React app"	`sentry-react-setup`
"Add Sentry to my iOS/Swift app"	`sentry-ios-swift-setup`
"Set up Sentry in React Native"	`sentry-react-native-setup`
"Add Sentry to my Python/Django/Flask app"	`sentry-python-setup`
"Set up Sentry in my Ruby/Rails app (quick)"	`sentry-ruby-setup`
"Add performance monitoring to my app"	`sentry-setup-tracing`
"Enable Sentry logging"	`sentry-setup-logging`
"Track custom metrics with Sentry"	`sentry-setup-metrics`
"Monitor my OpenAI/LangChain calls"	`sentry-setup-ai-monitoring`

Debugging & Workflow

What to Say	Skill Used
"Fix the recent Sentry errors"	`sentry-fix-issues`
"Debug the production TypeError"	`sentry-fix-issues`
"Work through my Sentry backlog"	`sentry-fix-issues`
"Review Sentry comments on PR #123"	`sentry-pr-code-review`
"Fix the issues Sentry found in my PR"	`sentry-pr-code-review`
"Create an alert that emails me when a high priority issue de-escalates"	`sentry-create-alert`
"Set up a Slack notification for new Sentry issues"	`sentry-create-alert`
`/sentry-create-alert`	`sentry-create-alert`

The assistant will load the appropriate skill and guide you through the process.

Skill Format

These skills follow the Agent Skills specification. Each skill contains:

skill-name/
  SKILL.md        # Required: YAML frontmatter + markdown instructions

SKILL.md structure:

---
name: skill-name
description: Description of what this skill does and when to use it
---

# Skill Title

Instructions for the AI assistant...

SDK skill bundles use a references/ directory for feature-specific deep dives:

sentry-go-sdk/
  SKILL.md           # Main wizard
  references/
    error-monitoring.md
    tracing.md
    ...

Contributing

Contributions are welcome! Please ensure any new skills:

Follow the Agent Skills specification
Have a valid name (lowercase letters, numbers, hyphens, 1-64 chars, no consecutive hyphens, must not start or end with hyphen)
Include a clear description (1-1024 chars)
Keep skills concise - use tables over prose, avoid obvious information
Include an "Invoke This Skill When" section with trigger phrases
Verify technical details against Sentry docs

For full-platform SDK skills (covering all Sentry features for one language/framework), see docs/sdk-skill-philosophy.md for the bundle architecture pattern.

Style Guidelines

Prefer tables over paragraphs for reference information
Use phases/steps for multi-stage workflows
Include version requirements where applicable
Add troubleshooting tables for common issues
Target ~100-200 lines per skill to minimize token usage

License

Apache-2.0