
cc-version-updater
Notify and explain changelog on new version release
- version
- 0.0.1
Install
/plugin install cc-version-updater@hiraoku-factoryRun it inside Claude Code after adding the marketplace with /plugin marketplace add s-hiraoku/harnesses-factory.
Contents
Discovered from sourceSkills 3
These are instructions for creating design philosophies - aesthetic movements that are then EXPRESSED VISUALLY. Output only .md files, .pdf files, and .png files.
Complete this in two steps:
- Design Philosophy Creation (.md file)
- Express by creating it on a canvas (.pdf file or .png file)
First, undertake this task:
DESIGN PHILOSOPHY CREATION
To begin, create a VISUAL PHILOSOPHY (not layouts or templates) that will be interpreted through:
- Form, space, color, composition
- Images, graphics, shapes, patterns
- Minimal text as visual accent
THE CRITICAL UNDERSTANDING
- What is received: Some subtle input or instructions by the user that should be taken into account, but used as a foundation; it should not constrain creative freedom.
- What is created: A design philosophy/aesthetic movement.
- What happens next: Then, the same version receives the philosophy and EXPRESSES IT VISUALLY - creating artifacts that are 90% visual design, 10% essential text.
Consider this approach:
- Write a manifesto for an art movement
- The next phase involves making the artwork
The philosophy must emphasize: Visual expression. Spatial communication. Artistic interpretation. Minimal words.
HOW TO GENERATE A VISUAL PHILOSOPHY
Name the movement (1-2 words): "Brutalist Joy" / "Chromatic Silence" / "Metabolist Dreams"
Articulate the philosophy (4-6 paragraphs - concise but complete):
To capture the VISUAL essence, express how the philosophy manifests through:
- Space and form
- Color and material
- Scale and rhythm
- Composition and balance
- Visual hierarchy
CRITICAL GUIDELINES:
- Avoid redundancy: Each design aspect should be mentioned once. Avoid repeating points about color theory, spatial relationships, or typographic principles unless adding new depth.
- Emphasize craftsmanship REPEATEDLY: The philosophy MUST stress multiple times that the final work should appear as though it took countless hours to create, was labored over with care, and comes from someone at the absolute top of their field. This framing is essential - repeat phrases like "meticulously crafted," "the product of deep expertise," "painstaking attention," "master-level execution."
- Leave creative space: Remain specific about the aesthetic direction, but concise enough that the next Claude has room to make interpretive choices also at a extremely high level of craftmanship.
The philosophy must guide the next version to express ideas VISUALLY, not through text. Information lives in design, not paragraphs.
PHILOSOPHY EXAMPLES
"Concrete Poetry" Philosophy: Communication through monumental form and bold geometry. Visual expression: Massive color blocks, sculptural typography (huge single words, tiny labels), Brutalist spatial divisions, Polish poster energy meets Le Corbusier. Ideas expressed through visual weight and spatial tension, not explanation. Text as rare, powerful gesture - never paragraphs, only essential words integrated into the visual architecture. Every element placed with the precision of a master craftsman.
"Chromatic Language" Philosophy: Color as the primary information system. Visual expression: Geometric precision where color zones create meaning. Typography minimal - small sans-serif labels letting chromatic fields communicate. Think Josef Albers' interaction meets data visualization. Information encoded spatially and chromatically. Words only to anchor what color already shows. The result of painstaking chromatic calibration.
"Analog Meditation" Philosophy: Quiet visual contemplation through texture and breathing room. Visual expression: Paper grain, ink bleeds, vast negative space. Photography and illustration dominate. Typography whispered (small, restrained, serving the visual). Japanese photobook aesthetic. Images breathe across pages. Text appears sparingly - short phrases, never explanatory blocks. Each composition balanced with the care of a meditation practice.
"Organic Systems" Philosophy: Natural clustering and modular growth patterns. Visual expression: Rounded forms, organic arrangements, color from nature through architecture. Information shown through visual diagrams, spatial relationships, iconography. Text only for key labels floating in space. The composition tells the story through expert spatial orchestration.
"Geometric Silence" Philosophy: Pure order and restraint. Visual expression: Grid-based precision, bold photography or stark graphics, dramatic negative space. Typography precise but minimal - small essential text, large quiet zones. Swiss formalism meets Brutalist material honesty. Structure communicates, not words. Every alignment the work of countless refinements.
These are condensed examples. The actual design philosophy should be 4-6 substantial paragraphs.
ESSENTIAL PRINCIPLES
- VISUAL PHILOSOPHY: Create an aesthetic worldview to be expressed through design
- MINIMAL TEXT: Always emphasize that text is sparse, essential-only, integrated as visual element - never lengthy
- SPATIAL EXPRESSION: Ideas communicate through space, form, color, composition - not paragraphs
- ARTISTIC FREEDOM: The next Claude interprets the philosophy visually - provide creative room
- PURE DESIGN: This is about making ART OBJECTS, not documents with decoration
- EXPERT CRAFTSMANSHIP: Repeatedly emphasize the final work must look meticulously crafted, labored over with care, the product of countless hours by someone at the top of their field
The design philosophy should be 4-6 paragraphs long. Fill it with poetic design philosophy that brings together the core vision. Avoid repeating the same points. Keep the design philosophy generic without mentioning the intention of the art, as if it can be used wherever. Output the design philosophy as a .md file.
DEDUCING THE SUBTLE REFERENCE
CRITICAL STEP: Before creating the canvas, identify the subtle conceptual thread from the original request.
THE ESSENTIAL PRINCIPLE: The topic is a subtle, niche reference embedded within the art itself - not always literal, always sophisticated. Someone familiar with the subject should feel it intuitively, while others simply experience a masterful abstract composition. The design philosophy provides the aesthetic language. The deduced topic provides the soul - the quiet conceptual DNA woven invisibly into form, color, and composition.
This is VERY IMPORTANT: The reference must be refined so it enhances the work's depth without announcing itself. Think like a jazz musician quoting another song - only those who know will catch it, but everyone appreciates the music.
CANVAS CREATION
With both the philosophy and the conceptual framework established, express it on a canvas. Take a moment to gather thoughts and clear the mind. Use the design philosophy created and the instructions below to craft a masterpiece, embodying all aspects of the philosophy with expert craftsmanship.
IMPORTANT: For any type of content, even if the user requests something for a movie/game/book, the approach should still be sophisticated. Never lose sight of the idea that this should be art, not something that's cartoony or amateur.
To create museum or magazine quality work, use the design philosophy as the foundation. Create one single page, highly visual, design-forward PDF or PNG output (unless asked for more pages). Generally use repeating patterns and perfect shapes. Treat the abstract philosophical design as if it were a scientific bible, borrowing the visual language of systematic observation—dense accumulation of marks, repeated elements, or layered patterns that build meaning through patient repetition and reward sustained viewing. Add sparse, clinical typography and systematic reference markers that suggest this could be a diagram from an imaginary discipline, treating the invisible subject with the same reverence typically reserved for documenting observable phenomena. Anchor the piece with simple phrase(s) or details positioned subtly, using a limited color palette that feels intentional and cohesive. Embrace the paradox of using analytical visual language to express ideas about human experience: the result should feel like an artifact that proves something ephemeral can be studied, mapped, and understood through careful attention. This is true art.
Text as a contextual element: Text is always minimal and visualramics studio identity. Most of the time, font should be thin. All use of fonts must be design-forward and prioritize visual communication. Regardless of text scale, nothing falls off the page and nothing overlaps. Every element must be contained within the canvas boundaries with proper margins. Check carefully that all text, graphics, and visual elements have breathing room and clear separation. This is non-negotiable for professional execution. IMPORTANT: Use different fonts if writing text. Search the ./canvas-fonts directory. Regardless of approach, sophistication is non-negotiable.
Download and use whatever fonts are needed to make this a reality. Get creative by making the typography actually part of the art itself -- if the art is abstract, bring the font onto the canvas, not typeset digitally.
To push boundaries, follow design instinct/intuition while using the philosophy as a guiding principle. Embrace ultimate design freedom and choice. Push aesthetics and design to the frontier.
CRITICAL: To achieve human-crafted quality (not AI-generated), create work that looks like it took countless hours. Make it appear as though someone at the absolute top of their field labored over every detail with painstaking care. Ensure the composition, spacing, color choices, typography - everything screams expert-level craftsmanship. Double-check that nothing overlaps, formatting is flawless, every detail perfect. Create something that could be shown to people to prove expertise and rank as undeniably impressive.
Output the final result as a single, downloadable .pdf or .png file, alongside the design philosophy used as a .md file.
FINAL STEP
IMPORTANT: The user ALREADY said "It isn't perfect enough. It must be pristine, a masterpiece if craftsmanship, as if it were about to be displayed in a museum."
CRITICAL: To refine the work, avoid adding more graphics; instead refine what has been created and make it extremely crisp, respecting the design philosophy and the principles of minimalism entirely. Rather than adding a fun filter or refactoring a font, consider how to make the existing composition more cohesive with the art. If the instinct is to call a new function or draw a new shape, STOP and instead ask: "How can I make what's already here more of a piece of art?"
Take a second pass. Go back to the code and refine/polish further to make this a philosophically designed masterpiece.
MULTI-PAGE OPTION
To create additional pages when requested, create more creative pages along the same lines as the design philosophy but distinctly different as well. Bundle those pages in the same .pdf or many .pngs. Treat the first page as just a single page in a whole coffee table book waiting to be filled. Make the next pages unique twists and memories of the original. Have them almost tell a story in a very tasteful way. Exercise full creative freedom.
Changelog Infographic Skill
This skill transforms changelog summaries into visually stunning infographic PNG images. It receives structured changelog information from the changelog-interpreter skill and produces museum-quality visual artifacts.
When to Use
- After
changelog-interpreterhas generated a summary - When user requests a visual representation of changes
- When user asks "Create an infographic" or "Visualize the changelog"
- When sharing changelog updates externally
Input
Structured changelog summary from changelog-interpreter:
{
"previousVersion": "2.0.74",
"latestVersion": "2.0.76",
"summary": "...",
"features": [
{
"name": "LSP Tool",
"description": "Jump to definitions and search references",
"usage": "Show me the definition of this function",
"useCases": ["Navigating large codebases", "Understanding impact of changes"]
}
],
"improvements": ["Faster startup", "Memory leak fix"],
"generatedAt": "2025-12-23T12:00:00Z"
}
If receiving the raw markdown summary, extract structured data before visualization.
Output
- PNG infographic saved to cache directory
- Clickable file path link for user to open
DESIGN PHILOSOPHY: "Technical Clarity"
The Vision
Technical Clarity is a design philosophy that bridges the precision of software engineering with the warmth of visual communication. It treats version updates not as sterile changelogs, but as moments of progress worth celebrating—each feature a small victory, each improvement a step forward.
Form and Space
The canvas breathes with intentional negative space. Information clusters organically into digestible zones: a prominent header anchoring the version transition, feature cards arranged in a grid or flowing column, and a footer grounding the composition. White space is not emptiness but punctuation—giving the eye permission to rest and the mind permission to absorb.
Color and Material
A restrained palette speaks of professionalism while accent colors inject energy. The primary scheme draws from Claude's brand identity: warm neutrals, sophisticated blues, and purposeful highlights. Feature types receive distinct but harmonious color coding—new features in vibrant accent, improvements in muted success tones, fixes in subtle neutral. Every color choice appears deliberate, the product of countless refinements.
Typography and Hierarchy
Typography serves information, never competes with it. Version numbers command attention through scale and weight. Feature names balance prominence with restraint. Descriptions whisper in supporting sizes. The typographic hierarchy guides the eye naturally from most important to supporting details, each level of information clearly differentiated yet cohesively unified.
Iconography and Visual Language
Simple, geometric icons punctuate each feature category—a spark for new features, a wrench for improvements, a check for fixes. These visual anchors accelerate comprehension while adding personality. Icons are restrained, never decorative clutter, always functional visual shorthand crafted with meticulous attention to detail.
Craftsmanship
Every pixel placement reflects master-level execution. Alignment is obsessive. Spacing is mathematical. The final artifact should appear as though someone at the absolute top of their field labored over every detail with painstaking care—because that is exactly what happens. This is not a template filled in; this is a designed artifact.
CANVAS CREATION PROCESS
Step 1: Parse Input Data
Extract from the changelog summary:
previousVersion→latestVersion(version transition)- Feature list with names, descriptions, usage examples
- Improvements and fixes
- Generation timestamp
Step 2: Establish Layout
Create a canvas with these specifications:
| Property | Value |
|---|---|
| Width | 1200px |
| Height | Dynamic (800-1600px based on content) |
| Background | #FAFAFA (light) or #1A1A1A (dark variant) |
| Margins | 60px all sides |
| Grid | 12-column with 24px gutters |
Step 3: Header Zone
The header establishes context and celebrates the update:
┌────────────────────────────────────────────────────────┐
│ │
│ [Claude Logo/Icon] │
│ │
│ v2.0.74 ────────────────► v2.0.76 │
│ │
│ Claude Code Update │
│ │
└────────────────────────────────────────────────────────┘
- Version transition: Large, bold typography with arrow indicating progression
- Subtle gradient or accent line separating header from content
- Date stamp in small, muted text
Step 4: Feature Cards
Each feature becomes a self-contained card:
┌─────────────────────────────────────┐
│ ✨ [Feature Name] │
│ │
│ [2-3 line description] │
│ │
│ 💡 [Usage example in code block] │
│ │
│ 📋 Use cases: │
│ • [Case 1] │
│ • [Case 2] │
└─────────────────────────────────────┘
Card specifications:
- Background: White (#FFFFFF) with subtle shadow
- Border-radius: 12px
- Padding: 24px
- Icon/emoji for category identification
- Clear typographic hierarchy within card
Step 5: Improvements & Fixes Section
A compact, list-style section:
┌────────────────────────────────────────────────────────┐
│ 🔧 Improvements & Fixes │
│ │
│ • Improved startup performance │
│ • Fixed memory leak in long sessions │
│ • Enhanced error messages │
└────────────────────────────────────────────────────────┘
Step 6: Footer
Ground the composition with metadata:
┌────────────────────────────────────────────────────────┐
│ Generated by cc-version-updater │ Dec 2025 │
└────────────────────────────────────────────────────────┘
IMPLEMENTATION
CRITICAL: Use Python + Pillow (PIL) to programmatically draw the infographic. This is NOT AI image generation - it's code-based drawing.
Prerequisites
Ensure Pillow is installed:
pip install pillow
Font Requirements
IMPORTANT: Use Unicode-compatible fonts to avoid garbled characters (文字化け).
| OS | Recommended Font | Path |
|---|---|---|
| macOS | Hiragino Sans | /System/Library/Fonts/ヒラギノ角ゴシック W3.ttc |
| macOS (fallback) | Arial Unicode | /System/Library/Fonts/Supplemental/Arial Unicode.ttf |
| Linux | Noto Sans CJK | /usr/share/fonts/noto-cjk/NotoSansCJK-Regular.ttc |
| Windows | Yu Gothic | C:/Windows/Fonts/yugothic.ttf |
Avoid emoji: Most fonts don't render emoji. Use text symbols instead:
- Instead of ✨ → use
[NEW]or* - Instead of 💡 → use
TIP:or> - Instead of 🔧 → use
[FIX]or- - Instead of 📦 → use
[1],[2], etc.
Drawing with Pillow
Create a Python script that draws the infographic:
from PIL import Image, ImageDraw, ImageFont
import os
import platform
def get_font(size):
"""Get a Unicode-compatible font for the current platform."""
font_paths = []
if platform.system() == "Darwin": # macOS
font_paths = [
"/System/Library/Fonts/ヒラギノ角ゴシック W3.ttc",
"/System/Library/Fonts/Hiragino Sans GB.ttc",
"/System/Library/Fonts/Supplemental/Arial Unicode.ttf",
"/System/Library/Fonts/Helvetica.ttc",
]
elif platform.system() == "Linux":
font_paths = [
"/usr/share/fonts/noto-cjk/NotoSansCJK-Regular.ttc",
"/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
]
elif platform.system() == "Windows":
font_paths = [
"C:/Windows/Fonts/yugothic.ttf",
"C:/Windows/Fonts/meiryo.ttc",
"C:/Windows/Fonts/arial.ttf",
]
for path in font_paths:
try:
return ImageFont.truetype(path, size)
except:
continue
return ImageFont.load_default()
def create_changelog_infographic(data, output_path):
"""
Generate changelog infographic PNG using Pillow.
Args:
data: dict with previousVersion, latestVersion, features, improvements
output_path: where to save the PNG
"""
# Canvas setup
width = 1200
height = 900 # Adjust based on content
bg_color = "#FAFAFA"
img = Image.new("RGB", (width, height), bg_color)
draw = ImageDraw.Draw(img)
# Colors
primary = "#1a1a2e" # Dark text
accent = "#4a90d9" # Claude blue
success = "#10b981" # Green for improvements
card_bg = "#ffffff" # White cards
# Load Unicode-compatible fonts
font_large = get_font(48)
font_medium = get_font(24)
font_small = get_font(16)
margin = 60
y_cursor = margin
# === Header ===
draw.rectangle([margin, y_cursor, width - margin, y_cursor + 4], fill=accent)
y_cursor += 30
# Version transition (use ASCII arrow for compatibility)
version_text = f"v{data['previousVersion']} --> v{data['latestVersion']}"
draw.text((margin, y_cursor), version_text, font=font_large, fill=primary)
y_cursor += 70
# Title
draw.text((margin, y_cursor), "Claude Code Update", font=font_medium, fill=accent)
y_cursor += 60
# === Feature Cards ===
for i, feature in enumerate(data.get('features', []), 1):
# Card background
card_rect = [margin, y_cursor, width - margin, y_cursor + 150]
draw.rounded_rectangle(card_rect, radius=12, fill=card_bg)
# Feature name (use text marker instead of emoji)
draw.text((margin + 24, y_cursor + 20),
f"[{i}] {feature['name']}", font=font_medium, fill=primary)
# Description
draw.text((margin + 24, y_cursor + 60),
feature['description'][:80], font=font_small, fill=primary)
# Usage (use text marker instead of emoji)
draw.text((margin + 24, y_cursor + 100),
f"> {feature.get('usage', '')[:60]}", font=font_small, fill="#666666")
y_cursor += 170
# === Improvements Section ===
draw.text((margin, y_cursor), "[FIX] Improvements & Fixes", font=font_medium, fill=success)
y_cursor += 40
for improvement in data.get('improvements', []):
draw.text((margin + 20, y_cursor), f"- {improvement}", font=font_small, fill=primary)
y_cursor += 30
# === Footer ===
y_cursor = height - 50
draw.text((margin, y_cursor), "Generated by cc-version-updater", font=font_small, fill="#999999")
# Save
os.makedirs(os.path.dirname(output_path), exist_ok=True)
img.save(output_path, "PNG")
return output_path
Execution Steps
- Parse changelog data from the interpreter output
- Write Python script with the drawing code above
- Execute the script:
python3 generate_infographic.py - Verify output exists at the expected path
Cache Directory
Save generated infographics to:
plugins/cc-version-updater/.cache/infographics/
├── changelog-2.0.74-to-2.0.76.png
├── changelog-2.0.76-to-2.0.77.png
└── ...
Filename pattern: changelog-{prevVersion}-to-{newVersion}.png
Output Format
After generating the infographic, output:
## Infographic Generated
Your changelog infographic has been created:
📁 **File**: `~/.claude-plugins/cc-version-updater/.cache/infographics/changelog-2.0.74-to-2.0.76.png`
👆 Click to open, or run:
```bash
open ~/.claude-plugins/cc-version-updater/.cache/infographics/changelog-2.0.74-to-2.0.76.png
---
## QUALITY STANDARDS
### Visual Checklist
Before finalizing, verify:
- [ ] All text is legible and properly sized
- [ ] No elements overlap or clip
- [ ] Consistent spacing throughout
- [ ] Color contrast meets accessibility standards
- [ ] Icons are crisp and aligned
- [ ] Version numbers are prominently displayed
- [ ] Feature cards are evenly spaced
- [ ] Footer is properly positioned
### Refinement Pass
After initial generation, review and refine:
1. **Spacing**: Ensure mathematical consistency
2. **Alignment**: Verify all elements align to grid
3. **Typography**: Check hierarchy is clear
4. **Color**: Confirm palette cohesion
5. **Balance**: Assess overall visual weight distribution
The goal: An artifact that could be displayed in a design portfolio, shared on social media, or printed as documentation. Museum quality, every time.
---
## EXAMPLE OUTPUT
For input:
```json
{
"previousVersion": "2.0.74",
"latestVersion": "2.0.76",
"features": [
{
"name": "LSP Tool",
"description": "Jump to definitions and search for references within your code.",
"usage": "Show me the definition of this function",
"useCases": ["Navigating large codebases", "Understanding impact before refactoring"]
}
],
"improvements": ["Faster startup", "Memory leak fix"]
}
Generate a 1200x900px PNG with:
- Header showing "v2.0.74 → v2.0.76"
- One feature card for "LSP Tool"
- Compact improvements section
- Footer with generation info
Save to: .cache/infographics/changelog-2.0.74-to-2.0.76.png
Output clickable path for user.
Changelog Interpreter Skill
This skill interprets Claude Code changelogs (release notes) and generates user-friendly "usage guides" that help users understand and adopt new features.
When to Use
- After running
/update-claudecommand, to summarize the changelog - When user asks "What's new?" or "Tell me about recent changes"
- When changelog information is available in the session context
Input
Changelog (Markdown release notes) and version information:
previousVersion: Version before upgradelatestVersion: Target versionchangelogs: Array of version changes (each withversionandchangelogfields)
Example structure:
{
"previousVersion": "2.0.74",
"latestVersion": "2.0.76",
"changelogs": [
{"version": "2.0.76", "changelog": "..."},
{"version": "2.0.75", "changelog": "..."}
]
}
Information Gathering (REQUIRED)
IMPORTANT: Before generating the summary, you MUST use WebSearch to gather accurate information from official sources.
Step 1: Search Official Sources
Use WebSearch with these queries (in order of priority):
For each version in the changelogs array:
1. "Claude Code v{version}" site:anthropic.com
2. "Claude Code v{version}" site:docs.anthropic.com
3. "Claude Code {version}" release notes
4. "Claude Code" new features {version}
Note: If upgrading multiple versions (e.g., 2.0.74 → 2.0.76), search for each intermediate version.
Step 2: Fetch Documentation
Use WebFetch to get detailed information from:
| Source | URL | Purpose |
|---|---|---|
| Official Docs | https://docs.anthropic.com/en/docs/claude-code | Feature documentation |
| Blog | https://www.anthropic.com/news | Announcements |
| GitHub Releases | https://github.com/anthropics/claude-code/releases | Detailed changelog |
Step 3: Cross-reference
Compare the changelog input with official sources to:
- Verify feature descriptions are accurate
- Get official feature names and terminology
- Find usage examples from documentation
- Understand the full context of changes
Priority of Information Sources
- Anthropic official docs (highest priority) - Use official terminology
- Anthropic blog posts - For context and use cases
- GitHub releases - For technical details
- Changelog input - As baseline reference
Multilingual Support
IMPORTANT: Generate output in the user's language. Detect from:
- User's message language
LANGenvironment variable (ja*, zh*, ko*, etc.)- Default to English if unclear
Generation Guidelines
1. Structure
Multi-version structure for readability:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🎉 Welcome to Claude Code v{newVersion}!
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
## 📋 Update Summary
Key changes from v{prevVersion} → v{newVersion}:
• {Feature 1 name} - {Brief description}
• {Feature 2 name} - {Brief description}
• {Improvement} - {Brief description}
• {Bug fix} - {Brief description}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
## 🆕 New Features in Detail
### v{version1} Changes
#### 1. {Feature name}
{2-3 sentences explaining the feature in detail}
**💡 How to use**
{Specific command or instruction example 1}
{Specific command or instruction example 2}
**📋 Use cases**
• {When this is helpful 1}
• {When this is helpful 2}
---
### v{version2} Changes (if multiple versions)
#### 1. {Feature name}
{Description}
**💡 How to use**
{Example}
**📋 Use cases**
• {Scenario}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
## 🔧 Improvements & Fixes
• {Improvement 1}
• {Improvement 2}
• {Bug fix}
Note: When only one version is upgraded, the "v{version} Changes" header can be omitted for a cleaner output.
2. Feature Selection
- Priority: Focus on features that impact daily workflow
- Count: Limit to 2-3 (too many won't be read)
- Selection criteria:
- New commands or tools
- Major improvements to existing features
- Performance or stability enhancements
3. Usage Examples
Provide concrete, immediately actionable examples:
Good examples:
💡 How to use: "Show me the definition of this function" or "Find references to getUser"
💡 How to use: Run /terminal-setup
💡 How to use: Resume previous session with claude --resume
Bad examples:
💡 How to use: Use the LSP feature (too vague)
4. Use Cases
Connect to user's actual work scenarios:
Good examples:
📋 Use cases:
- When you need to quickly find function definitions in a large codebase
- When you want to understand the impact of changes before refactoring
Bad examples:
📋 Use cases:
- When reading code (lacks specificity)
5. Tone
- Welcoming and friendly atmosphere
- Technically accurate but avoid jargon
- Use emojis moderately for visual clarity
6. Color Output (ANSI Escape Sequences)
Use colors that work well in both Light/Dark modes. Include these ANSI color codes in output:
# Light/Dark compatible colors
\033[1;36m - Cyan (bold): Titles, headings
\033[0;36m - Cyan: Section names
\033[1;35m - Magenta (bold): Important feature names
\033[0;33m - Yellow: Usage hints (💡)
\033[0;32m - Green: Success messages, improvements
\033[0m - Reset
Example output format (with colors):
\033[1;36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\033[0m
\033[1;36m🎉 Welcome to Claude Code v2.0.75!\033[0m
\033[1;36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\033[0m
\033[0;36m## 🆕 Notable New Features\033[0m
\033[1;35m### LSP Tool\033[0m
Jump to definitions and search for references within your code.
\033[0;33m💡 How to use:\033[0m "Show me the definition of this function" or "Find references to getUser"
\033[0;36m📋 Use cases:\033[0m
- Quickly find function definitions in large codebases
- Understand impact of changes before refactoring
\033[0;32m## 🔧 Improvements & Fixes\033[0m
- Improved startup performance
- Fixed memory leak in long sessions
Notes:
- Reset with
\033[0mat the end of each colored section - When saving to JSON, escape as
\\033
Output Format
The generated summary should be savable in this JSON format:
{
"previousVersion": "2.0.74",
"latestVersion": "2.0.75",
"summary": "🎉 Welcome to Claude Code v2.0.75!\n\n## 🆕 Notable New Features\n...",
"generatedAt": "2025-12-23T12:00:00Z"
}
Example: Input and Output
Input (multi-version changelogs)
{
"previousVersion": "2.0.74",
"latestVersion": "2.0.76",
"changelogs": [
{
"version": "2.0.76",
"changelog": "## What's Changed\n- feat: add LSP tool for code navigation\n- fix: memory leak in long sessions"
},
{
"version": "2.0.75",
"changelog": "## What's Changed\n- feat: add /terminal-setup for Kitty, Alacritty\n- perf: faster startup time"
}
]
}
Output (generated summary - with colors)
\033[1;36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\033[0m
\033[1;36m🎉 Welcome to Claude Code v2.0.76!\033[0m
\033[1;36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\033[0m
\033[0;36m## 📋 Update Summary\033[0m
Key changes from v2.0.74 → v2.0.76 (2 versions):
• \033[1;35mLSP Tool\033[0m - Jump to definitions and search references in code
• \033[1;35m/terminal-setup expansion\033[0m - Now supports Kitty, Alacritty
• \033[0;32mFaster startup\033[0m
• \033[0;32mMemory leak fix\033[0m
\033[1;36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\033[0m
\033[0;36m## 🆕 New Features in Detail\033[0m
\033[1;35m### v2.0.76 Changes\033[0m
\033[1;35m#### 1. LSP Tool\033[0m
Jump to definitions and search for references within your code.
Experience IDE-like code navigation right in Claude Code!
\033[0;33m**💡 How to use**\033[0m
"Show me the definition of this function"
"Find references to getUser"
\033[0;36m**📋 Use cases**\033[0m
• When you need to quickly find function definitions in a large codebase
• When you want to understand the impact of changes before refactoring
---
\033[1;35m### v2.0.75 Changes\033[0m
\033[1;35m#### 1. /terminal-setup Expansion\033[0m
Now supports Kitty, Alacritty, and other terminals.
\033[0;33m**💡 How to use**\033[0m
Run /terminal-setup and select your terminal
\033[0;36m**📋 Use cases**\033[0m
• If you use a terminal other than iTerm2
\033[1;36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\033[0m
\033[0;32m## 🔧 Improvements & Fixes\033[0m
• Improved startup performance (v2.0.75)
• Fixed memory leak in long sessions (v2.0.76)
Commands 1
Claude Code Upgrade
Execute the Claude Code upgrade process.
Steps
1. Check Upgrade Info
First, check if pre-generated summary exists (prepared-upgrade.json), otherwise fall back to pending-upgrade.json:
cat "${CLAUDE_PLUGIN_ROOT}/.cache/prepared-upgrade.json" 2>/dev/null || \
cat "${CLAUDE_PLUGIN_ROOT}/.cache/pending-upgrade.json" 2>/dev/null || \
echo "{}"
Important: If prepared-upgrade.json exists with readyForUpgrade: true:
- The summary and infographic have been pre-generated at session start
- You can skip Steps 5-7 after upgrade and directly use the prepared content
Language Detection: Automatically detect the user's language from their messages in this conversation. Use that language for all output.
2. Confirm with User
Use AskUserQuestion tool to confirm:
- Question: "Upgrade Claude Code from v{previousVersion} to v{latestVersion}?" (include version count if multiple: "... (N versions)")
- Options: Yes / No
Note: The changelogs field contains an array of all versions between current and latest.
3. Detect Installation Method
node "${CLAUDE_PLUGIN_ROOT}/scripts/detect-install-method.js"
4. Execute Upgrade
Based on the detected installation method, run the appropriate upgrade command:
Native (default):
curl -fsSL https://claude.ai/install.sh | bash
Homebrew:
brew upgrade --cask claude-code
npm:
npm install -g @anthropic-ai/claude-code@latest
Display the upgrade output to the user.
5. Finalize Summary
If prepared-upgrade.json exists with readyForUpgrade: true:
Simply copy the prepared data to changelog-summary.json:
cp "${CLAUDE_PLUGIN_ROOT}/.cache/prepared-upgrade.json" "${CLAUDE_PLUGIN_ROOT}/.cache/changelog-summary.json"
rm -f "${CLAUDE_PLUGIN_ROOT}/.cache/pending-upgrade.json"
rm -f "${CLAUDE_PLUGIN_ROOT}/.cache/prepared-upgrade.json"
Skip to Step 8.
If NO pre-generated content exists, follow Steps 5.1-5.3 below:
Step 5.1: Read the Skill
cat "${CLAUDE_PLUGIN_ROOT}/skills/changelog-interpreter/SKILL.md"
Step 5.2: Gather Information (REQUIRED)
Use WebSearch to get accurate information:
For each version in the changelogs array, search:
- Search:
"Claude Code v{version}" site:anthropic.com - Search:
"Claude Code v{version}" release notes
Then use WebFetch on:
https://github.com/anthropics/claude-code/releaseshttps://docs.anthropic.com/en/docs/claude-code
Step 5.3: Generate Formatted Summary
Create the summary following the skill's exact format:
- Use the user's language (detected from their messages in this conversation)
- Use ANSI color codes (e.g.,
\033[1;36mfor cyan) - Include decorative header with
━━━lines - Structure: Update Summary -> New Features in Detail (per version) -> Improvements & Fixes
- For each feature: Include "How to use" and "Use cases"
- Escape for JSON: Use
\\033instead of\033
6. Save Summary (Only if not pre-generated)
Save the generated summary as JSON:
jq -n \
--arg prev "{previousVersion}" \
--arg latest "{latestVersion}" \
--arg summary "{generatedSummary}" \
'{
previousVersion: $prev,
latestVersion: $latest,
summary: $summary,
generatedAt: (now | todate)
}' > "${CLAUDE_PLUGIN_ROOT}/.cache/changelog-summary.json"
rm -f "${CLAUDE_PLUGIN_ROOT}/.cache/pending-upgrade.json"
7. Generate Infographic (Only if not pre-generated)
Skip this step if using pre-generated content from prepared-upgrade.json.
If you need to generate manually:
python3 "${CLAUDE_PLUGIN_ROOT}/scripts/generate-infographic.py" \
"${CLAUDE_PLUGIN_ROOT}/.cache/pending-upgrade.json" \
"{lang}" \
"${CLAUDE_PLUGIN_ROOT}/.cache/infographics/changelog-{prevVersion}-to-{newVersion}.png"
Update the summary JSON with infographic path:
jq --arg path "${CLAUDE_PLUGIN_ROOT}/.cache/infographics/changelog-{prevVersion}-to-{newVersion}.png" \
'.infographicPath = $path' \
"${CLAUDE_PLUGIN_ROOT}/.cache/changelog-summary.json" > tmp.json && \
mv tmp.json "${CLAUDE_PLUGIN_ROOT}/.cache/changelog-summary.json"
8. Prompt Restart
Display success message:
Upgrade complete!
Please restart Claude Code:
1. Exit this session (exit or Ctrl+C)
2. Run `claude` again
The new features guide will be displayed on next startup.
If infographic was generated, also display the path prominently:
Infographic: {infographicPath}
Run: open "{infographicPath}"
9. On Cancel
Abort the process.
Hooks 1
Sponsors
Details
- Marketplace
- s-hiraoku/harnesses-factory
- Source
- plugins/cc-version-updater
- Category
- Community