home / skills / laurigates / claude-plugins / changelog-review

changelog-review skill

/project-plugin/skills/changelog-review

This skill analyzes Claude Code changelog to identify breaking changes and new features that impact plugin development and improvements.

npx playbooks add skill laurigates/claude-plugins --skill changelog-review

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

Files (1)
SKILL.md
6.3 KB
---
model: haiku
name: changelog-review
description: |
  Analyze Claude Code changelog for changes that impact plugin development.
  Use when checking for new features, breaking changes, or opportunities to
  improve plugins based on Claude Code updates.
allowed-tools: Bash(git log *), Bash(git diff *), Read, Write, Edit, Glob, Grep, WebFetch, TodoWrite
created: 2026-01-14
modified: 2026-01-14
reviewed: 2026-01-14
---

# Claude Code Changelog Review

Expertise for analyzing Claude Code changelog and identifying impacts on plugin development.

## Core Purpose

Review Claude Code releases to:
- Identify breaking changes requiring plugin updates
- Discover new features plugins can leverage
- Track deprecations before they become problems
- Ensure plugins follow current best practices

## Change Categories

### High Impact (Action Required)

| Category | Example Changes | Action |
|----------|----------------|--------|
| Breaking changes | API changes, renamed tools | Update affected plugins immediately |
| Security fixes | Permission vulnerabilities | Review and update permission rules |
| Deprecations | Removed features/fields | Remove deprecated usage |
| Hook changes | New events, schema changes | Update hooks-plugin |

### Medium Impact (Review Recommended)

| Category | Example Changes | Action |
|----------|----------------|--------|
| New features | New tools, frontmatter fields | Consider plugin enhancements |
| Permission updates | New wildcard patterns | Update permission documentation |
| SDK changes | New callbacks, streaming | Update SDK-related skills |
| MCP improvements | OAuth, server configs | Update agent-patterns-plugin |

### Low Impact (Information Only)

| Category | Example Changes | Action |
|----------|----------------|--------|
| Bug fixes | UI improvements | Note in changelog |
| Performance | Startup optimizations | No action needed |
| IDE features | VS Code updates | No action needed |

## Plugin Impact Matrix

Map changelog categories to plugins:

| Claude Code Area | Affected Plugins |
|------------------|------------------|
| Hooks | hooks-plugin, configure-plugin |
| Skills/Commands | All plugins with skills/commands |
| Agents | agents-plugin, agent-patterns-plugin |
| MCP servers | agent-patterns-plugin |
| Permissions | configure-plugin, hooks-plugin |
| Git operations | git-plugin |
| Testing tools | testing-plugin |
| SDK changes | agent-patterns-plugin |

## Version Tracking

Version state stored in `.claude-code-version-check.json`:

```json
{
  "lastCheckedVersion": "2.1.7",
  "lastCheckedDate": "2026-01-14",
  "changelogUrl": "https://raw.githubusercontent.com/anthropics/claude-code/main/CHANGELOG.md",
  "reviewedChanges": [
    {
      "version": "2.1.7",
      "date": "2026-01-14",
      "relevantChanges": [],
      "actionsRequired": []
    }
  ]
}
```

## Analysis Process

### Step 1: Fetch Current State

```bash
# Read last checked version
cat .claude-code-version-check.json | jq -r '.lastCheckedVersion'
```

### Step 2: Fetch Changelog

Use WebFetch to get the current changelog from:
`https://raw.githubusercontent.com/anthropics/claude-code/main/CHANGELOG.md`

### Step 3: Identify New Versions

Compare fetched changelog versions against lastCheckedVersion.
Extract all changes since that version.

### Step 4: Categorize Changes

For each change, determine:
1. Impact level (high/medium/low)
2. Affected plugins
3. Required action

### Step 5: Generate Report

Produce a report with:
- New versions found
- High-impact changes requiring immediate action
- Medium-impact changes worth reviewing
- Suggestions for plugin improvements

### Step 6: Update Version Tracking

Update `.claude-code-version-check.json` with:
- New lastCheckedVersion
- New lastCheckedDate
- Summary of reviewed changes

## Change Detection Patterns

### Breaking Changes

Look for:
- "BREAKING" or "Breaking Change" headers
- "Removed" sections
- "Migrat" keywords
- "deprecated" becoming "removed"

### Hook System Changes

Look for:
- "hook" mentions in features
- New hook events (SessionStart, SessionEnd, SubagentStart, etc.)
- Schema changes for hook input/output
- Permission decision updates

### Skill/Command Changes

Look for:
- "skill" or "slash command" mentions
- Frontmatter field changes
- Discovery mechanism updates
- New fields like "context: fork"

### Agent/Subagent Changes

Look for:
- "agent" or "subagent" mentions
- Task tool changes
- Agent configuration options
- New agent types

### Permission Changes

Look for:
- "permission" mentions
- Wildcard pattern updates
- Security fixes
- Bash permission changes

## Report Format

```markdown
# Claude Code Changelog Review

**Review Date**: YYYY-MM-DD
**Versions Reviewed**: X.X.X to Y.Y.Y
**Previous Check**: YYYY-MM-DD (vX.X.X)

## Summary

- **New versions**: N
- **High-impact changes**: N
- **Medium-impact changes**: N
- **Action items**: N

## High-Impact Changes

### [Version] - Change Title

**Impact**: Breaking/Security/Deprecation
**Affected plugins**: plugin1, plugin2
**Required action**: Description of what needs to be done

## Medium-Impact Changes

### [Version] - Change Title

**Impact**: New feature/Enhancement
**Opportunity**: How plugins could benefit
**Suggested plugins**: plugin1, plugin2

## Action Items

- [ ] Item 1 (high priority)
- [ ] Item 2 (medium priority)

## Next Steps

1. Create issues for high-priority items
2. Schedule review of medium-impact changes
3. Update version tracking file
```

## Automation Integration

For GitHub Actions workflow:

1. Run weekly on schedule
2. Fetch changelog and compare versions
3. If new versions found:
   - Generate analysis report
   - Create GitHub issue with findings
   - Update version tracking file
4. Label issues appropriately

## Quick Reference

### Relevant Claude Code URLs

| Resource | URL |
|----------|-----|
| Changelog | https://raw.githubusercontent.com/anthropics/claude-code/main/CHANGELOG.md |
| Documentation | https://docs.anthropic.com/en/docs/claude-code |
| GitHub | https://github.com/anthropics/claude-code |

### Version Number Format

Claude Code uses semantic versioning: `MAJOR.MINOR.PATCH`

- MAJOR: Breaking changes
- MINOR: New features
- PATCH: Bug fixes

### Issue Labels

| Label | Use For |
|-------|---------|
| `changelog-review` | All changelog-related issues |
| `breaking-change` | Breaking changes requiring updates |
| `enhancement` | New feature opportunities |
| `maintenance` | General housekeeping |

Overview

This skill reviews the Claude Code changelog and highlights changes that affect plugin development. It identifies breaking changes, security fixes, deprecations, and new features that create opportunities or require action. The goal is to produce a concise report and update version tracking so plugin maintainers can prioritize work quickly.

How this skill works

The skill reads a stored last-checked version, fetches the latest changelog from the canonical URL, and extracts all versions released since the last check. It classifies each item by impact level (high/medium/low), maps changes to affected plugins, and generates a prioritized report with concrete action items. Finally, it updates the version-tracking file with the new last-checked version and a summary of reviewed changes.

When to use it

  • Before releasing plugin updates to ensure compatibility with the latest Claude Code.
  • When evaluating whether new Claude Code features can improve plugin functionality.
  • After security or breaking-change notices to prioritize urgent fixes.
  • As part of a weekly automation or CI workflow to detect changes early.
  • When preparing roadmap work and allocating maintenance effort.

Best practices

  • Automate checks on a schedule (weekly) and create issues for high-impact items.
  • Treat any 'BREAKING' or 'Removed' notes as high priority and block releases until addressed.
  • Map each changelog entry to specific plugins using the impact matrix to avoid missed dependencies.
  • Update .claude-code-version-check.json after review and include a short summary of actions.
  • Label generated issues with consistent tags (changelog-review, breaking-change, enhancement).

Example use cases

  • Detect a renamed API endpoint in a new release and open an urgent PR to update the affected plugin.
  • Find a new hook event and plan a feature to leverage it for better lifecycle handling in hooks-plugin.
  • Spot a permission wildcard change and update permission rules in configure-plugin before deployments.
  • Identify SDK streaming callbacks added in a minor release and extend agent-patterns-plugin to support them.
  • Run automated weekly checks that create GitHub issues summarizing medium-impact opportunities for enhancements.

FAQ

What indicates a breaking change?

Look for 'BREAKING', 'Breaking Change', 'Removed', or migration notes; treat these as high-impact.

How often should I run this review?

Run it at least weekly in CI; increase frequency if you track security-sensitive plugins.