Sentry Sdk Skill Creator

# SDK Skill Philosophy

Guide for authoring SDK skill bundles — a new pattern that ships complete, opinionated Sentry setup wizards alongside each SDK.

## The Vision

SDK skills are **living documentation bundles**. Instead of a flat SKILL.md that covers one feature, an SDK skill covers everything a project needs: error monitoring, tracing, profiling, logging, session replay, and more. The agent acts as an expert who reads the project, makes opinionated recommendations, and guides the user through each feature — loading deep-dive references as needed.

## Bundle Architecture

```
skills/
  sentry-<platform>-sdk/
    SKILL.md                    # Main wizard
    references/
      error-monitoring.md       # Deep dive: errors, panics, wrapping
      tracing.md                # Deep dive: spans, distributed tracing
      profiling.md              # Deep dive: continuous profiling
      logging.md                # Deep dive: structured logs
      metrics.md                # Deep dive: counters, gauges, distributions
      crons.md                  # Deep dive: cron job monitoring
      session-replay.md         # Deep dive: replay (frontend only)
```

The main `SKILL.md` is the wizard — it stays lean. References are loaded conditionally based on what the user wants to configure.

**Loading a reference in SKILL.md:**
```markdown
Read ${SKILL_ROOT}/references/tracing.md for detailed tracing setup steps.
```

## Feature Pillars

Each SDK supports a subset of Sentry's pillars:

| Pillar | Backend SDKs | Frontend SDKs |
|--------|-------------|---------------|
| Error Monitoring | ✅ Always | ✅ Always |
| Tracing/Performance | ✅ Common | ✅ Common |
| Profiling | ✅ Some | ✅ Some |
| Logging | ✅ Common | ✅ Common |
| Metrics | ✅ Some | ✅ Some |
| Crons | ✅ Backend only | ❌ |
| Session Replay | ❌ | ✅ Frontend only |
| AI Monitoring | ✅ Some | ✅ Some |

Only include reference files for pillars the SDK actually supports. If a feature is experimental or beta, mark it clearly in the reference header.

## The Wizard Flow

The main SKILL.md implements a four-phase wizard:

### Phase 1: Detect

Scan the project to understand the stack:

```markdown
## Phase 1: Detect

Run these commands to understand the project:
- `cat go.mod` / `cat package.json` — identify language and framework
- `grep -r "sentry" go.mod package.json 2>/dev/null` — check if Sentry is already installed
- `ls frontend/ web/ client/ 2>/dev/null` — detect companion frontend/backend
```

### Phase 2: Recommend

Present opinionated feature recommendations based on what you found. Don't ask open-ended "what do you want?" — lead with a concrete proposal:

```markdown
## Phase 2: Recommend

Based on what I found, here's what I recommend setting up:

**Recommended (core coverage):**
- ✅ Error monitoring — captures panics, exceptions, and unhandled errors
- ✅ Tracing — your app has HTTP handlers; distributed tracing will show latency across services
- ✅ Logging — you're using zap; Sentry can capture structured logs automatically

**Optional (enhanced observability):**
- ⚡ Profiling — low-overhead CPU/memory profiling in production
- ⚡ Metrics — custom counters and gauges for business KPIs
- ⚡ Crons — detect silent failures in scheduled jobs

Shall I set up everything recommended, or customize the list?
```

Recommendation logic:
- **Error monitoring**: Always recommend — this is the baseline
- **Tracing**: Recommend when HTTP handlers, APIs, gRPC, or queues are detected
- **Profiling**: Recommend for production apps where perf matters
- **Logging**: Recommend when the app already uses a logging library
- **Metrics**: Recommend for apps tracking business events or SLOs
- **Crons**: Recommend when cron/scheduler patterns are detected
- **Session Replay**: Recommend for frontend apps, never for backend

### Phase 3: Guide

#### Wizard-First for Framework SDKs

Many Sentry SDKs ship with a CLI wizard (`npx @sentry/wizard@latest -i <integration>`) that scaffolds the entire setup in one comm