home / skills / phrazzld / claude-config / log-production-issues

log-production-issues skill

/skills/log-production-issues

This skill runs a production health audit, parses findings by priority, and creates structured GitHub issues to track fixes.

npx playbooks add skill phrazzld/claude-config --skill log-production-issues

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

Files (1)
SKILL.md
2.9 KB
---
name: log-production-issues
description: |
  Run /check-production, then create GitHub issues for all findings.
  Issues are created with priority labels and structured format.
  Use /triage instead if you want to fix issues immediately.
effort: medium
---

# /log-production-issues

Run production health audit and create GitHub issues for all findings.

## What This Does

1. Invoke `/check-production` to audit production health
2. Parse findings by priority (P0-P3)
3. Check existing issues to avoid duplicates
4. Create GitHub issues for each finding

**This is an issue-creator.** It creates work items, not fixes. Use `/triage` to fix issues.

## Process

### 1. Run Primitive

Invoke `/check-production` skill to get structured findings.

### 2. Check Existing Issues

```bash
gh issue list --state open --label "domain/production" --limit 50
```

### 3. Create Issues

For each finding, create a GitHub issue:

```bash
gh issue create \
  --title "[P0] PaymentIntent failed - 23 users affected" \
  --body "$(cat <<'EOF'
## Problem
Sentry issue SENTRY-123 shows PaymentIntent failures affecting 23 users.

## Impact
- Users cannot complete checkout
- Revenue loss estimated at $X/hour
- First seen: 2 hours ago

## Location
`api/checkout.ts:45`

## Suggested Fix
Run `/triage investigate SENTRY-123` to diagnose and fix.

## Source
- Sentry: SENTRY-123
- Score: 147

---
Created by `/log-production-issues`
EOF
)" \
  --label "priority/p0,domain/production,type/bug"
```

### 4. Issue Format

All issues follow this structure:

**Title:** `[P{0-3}] Concise problem statement`

**Labels:**
- `priority/p0` | `priority/p1` | `priority/p2` | `priority/p3`
- `domain/production`
- `type/bug` | `type/enhancement` | `type/chore`

**Body:**
```markdown
## Problem
What's wrong (specific, measurable)

## Impact
Who/what is affected, severity

## Location
File:line or service/component

## Suggested Fix
Skill to run or action to take

## Source
Where this was detected (Sentry ID, log line, etc.)

---
Created by `/log-production-issues`
```

## Deduplication

Before creating an issue:
1. Search for existing issues with same Sentry ID or similar title
2. If found: Update existing issue with new occurrence count
3. If not found: Create new issue

```bash
# Check for existing
gh issue list --state open --search "SENTRY-123" --limit 5
```

## Priority Mapping

| Source | Priority |
|--------|----------|
| Active Sentry errors (>5 users) | P0 |
| 5xx errors in Vercel logs | P1 |
| Slow health endpoint | P1 |
| Silent failures (empty catch) | P2 |
| Missing monitoring | P3 |

## Output

After running:
```
Production Issues Created:
- P0: 1 (payment failures)
- P1: 2 (5xx errors, slow health)
- P2: 2 (silent failures)
- P3: 1 (missing monitoring)

Total: 6 issues created
View: gh issue list --label domain/production
```

## Related

- `/check-production` - The primitive (audit only)
- `/triage` - Fix production issues
- `/groom` - Full backlog grooming (runs this skill)

Overview

This skill runs a production health audit and creates GitHub issues for every finding. It classifies findings by priority, avoids duplicates, and writes structured, actionable issues so teams can triage work efficiently.

How this skill works

It invokes the /check-production primitive to collect structured findings, maps each finding to a priority (P0–P3), and checks open repository issues to avoid duplicates. For each new finding it creates a GitHub issue with a consistent title, labels, and a body containing Problem, Impact, Location, Suggested Fix, and Source sections.

When to use it

  • After running a production audit to turn findings into tracked work
  • When you need automated creation of consistent, prioritized issues
  • Before a team triage session so work is already logged
  • When you want to ensure important production signals are visible in GitHub
  • To convert alerts (Sentry, logs, monitoring) into reproducible work items

Best practices

  • Run /check-production first to get structured findings before creating issues
  • Keep suggested fixes concise and point to the /triage skill for investigation
  • Use consistent labels: priority, domain/production, and type to enable filtering
  • Deduplicate by Sentry ID or similar title; update existing issues instead of creating duplicates
  • Review P0/P1 issues immediately; assign owners and add incident context when available

Example use cases

  • Detect an active Sentry error affecting >5 users and create a P0 issue for immediate response
  • Convert recurring 5xx errors from Vercel logs into P1 issues for engineering investigation
  • Log silent failures discovered by audits as P2 issues so they don’t get ignored
  • Record missing monitoring as P3 backlog items for reliability improvements
  • Bulk-create issues after a health sweep so the oncall team can prioritize work

FAQ

Does this skill fix issues it creates?

No. This skill creates work items only. Use /triage to investigate and implement fixes.

How does it avoid duplicate issues?

It searches open issues for matching Sentry IDs or similar titles and updates existing issues with new occurrence counts instead of creating duplicates.