Claude Skills Collection

Community-contributed skills for Claude Code to enhance productivity, optimize token usage, and improve development workflows.

🇫🇷 Version française

📋 Table of Contents

What Are Claude Skills?
Quick Start
Which Skill Should I Use?
Installation
Complete Development Workflow
Available Skills
TDD Methodology
Acronyms & Terminology
How Skills Work
Contributing
License

🤔 What Are Claude Skills?

Skills are reusable process guides that help Claude Code (and other AI agents) follow proven techniques, patterns, and workflows consistently.

Why Skills Matter

Without skills, AI agents:

❌ Make inconsistent decisions
❌ Fall into common traps (token waste, verbose output, wrong tools)
❌ Rationalize bad practices ("I'll explain first" = wasting tokens)

With skills, AI agents:

✅ Follow validated workflows
✅ Apply battle-tested optimizations
✅ Counter their own rationalizations
✅ Deliver predictable, high-quality results

Skills vs. Prompts

Aspect	One-time Prompt	Persistent Skill
Scope	Single conversation	All future conversations
Quality	Untested, ad-hoc	TDD-validated, battle-tested
Maintenance	Copy-paste every time	Installed once, updated centrally
Learning	You teach agent each time	Agent learns pattern once

🚀 Quick Start (5 minutes)

New to Claude Skills? Start here:

Try Your First Skill

# 1. Clone this repository
git clone https://github.com/valorisa/Claude-Skills.git
cd Claude-Skills

# 2. Install one skill to try (rescue-tokens is great for beginners)
cp -r skills/rescue-tokens ~/.claude/skills/

Test It in Claude Code

Open Claude Code (CLI, desktop app, or web)
Start a conversation and mention: "I'm getting rate limit warnings"
Claude will automatically activate the rescue-tokens skill
Watch how Claude optimizes its behavior to save tokens!

What Happens?

Without skill: Claude might write verbose explanations (950 words), wasting tokens

With skill: Claude responds concisely (97 words), taking immediate action

Next Steps

Want the full development workflow? → See Complete Development Workflow
Not sure which skill to use? → See Which Skill Should I Use?
Ready to install all skills? → See Installation

🎯 Which Skill Should I Use?

Choose your path based on what you need:

For Everyone

Skill	When to Use	Why You Need This
rescue-tokens	Getting rate limits, context warnings, or slow responses	Prevents token waste that causes rate limits. Start here if unsure!
token-optimization	High token costs, context bloat, slow sessions, cache invalidation	Systematic optimization across 4 axes: cache management, context forking, model selection, input filtering. Proven to reduce costs by 70-80%.

For Starting New Work

Skill	When to Use	Why You Need This
spec-driven	Starting a new feature or complex task	Prevents "coding too early" syndrome. Forces you to think through requirements before writing code, avoiding costly rewrites.
create-github-issues	You have a plan/spec and need to break it into tasks	Converts big plans into small, independent, shippable chunks. Each issue = complete feature slice (UI → API → DB).

For Writing Code

Skill	When to Use	Why You Need This
tdd-hybrid	Implementing any feature or bugfix	Write tests before code = fewer bugs, better design. Prevents "it works on my machine" problems.
diagnose	Stuck on a hard bug or performance issue	Systematic debugging prevents guessing. Reproduce → minimize → fix → test. Ensures bug stays fixed.

For Improving Existing Code

Skill	When to Use	Why You Need This
improve-codebase-architecture	Periodic codebase reviews, or code feels messy	Finds architectural improvements based on your domain language (CONTEXT.md). Suggests consolidation opportunities.

For Advanced Decision-Making

Skill	When to Use	Why You Need This
grill-me	Stress-testing a plan or design before committing to it	Relentlessly interviews you branch-by-branch through the decision tree until blind spots surface.
llm-council	Big decisions, tradeoff analysis, architecture choices	Gets 5 independent AI perspectives, peer-reviewed. Catches blind spots you'd miss alone.
promptor	Creating optimized prompts for AI tools	Generates production-ready prompts using 18 optimization techniques. Copy-paste-ready.
rodin	Deep debates on politics, economics, philosophy	Socratic intellectual sparring partner for deep debates on politics, economics, philosophy - challenges positions with anti-compliance, steelmanning, and rigorous classification

For Mathematics & Formal Proofs

Skill	When to Use	Why You Need This
maths-olympiad	Solving or verifying competition math problems (IMO, Putnam, USAMO, AIME)	Multi-agent parallel solving with adversarial verification and context isolation. Produces verified LaTeX proofs. Abstains rather than guessing.

For Quality-Assured Work

Skill	When to Use	Why You Need This
fabuleux	Any task where you want verified, honest, non-bloated output	Routes effort by task type: ARTEFACT (screenshot + vision loop), PROSE (subtraction pass), ANALYSIS (claim verification), AUDIT (honest diagnosis → correction), SIMPLE (direct answer). Eliminates "probably works" reporting.

Setup (Run Once Per Repo)

Skill	When to Use	Why You Need This
setup-matt-pocock-skills	First time setting up a new repository	Configures issue tracker (GitHub, GitLab, or local markdown), triage label vocabulary, and single/multi-context domain doc layout. One-time setup, manually invoked only.

Utilities

Skill	When to Use	Why You Need This
skills-smart-manager	Session feels slow, context >60%, managing loaded skills, optimizing token usage	Meta-skill that monitors and manages all other skills. Automatically unloads stale skills, detects conflicts, recommends skills based on project type, and performs health checks. Prevents context bloat and optimizes session performance.
skill-factory	Creating production-ready skills with validation and tests	Advanced meta-skill following Anthropic's official guide. Generates complete skill packages with validation scripts, test suites, and distribution-ready structure. Use for professional-grade skills.
skill-creator	Quick prototyping of custom skills	Lightweight tool for fast iteration. Guides you through basic structure. Use for simple skills or rapid experimentation.
find-bugs	Systematic bug hunting in codebase	Structured approach to finding and documenting bugs.

💡 Tip: Skills work together! Common workflow: spec-driven → create-github-issues → tdd-hybrid (per issue) → diagnose (if bugs found)

📦 Available Skills (Detailed Reference)

This collection includes 20 skills organized into workflows and utilities.

💡 Note on Triggers: When you mention any of the trigger keywords in your conversation with Claude, the skill automatically activates. For example, saying "I'm getting rate limit warnings" activates rescue-tokens.

🎯 Core Development Workflow

Recommended workflow: /spec-driven → /create-github-issues → /tdd-hybrid (per issue)

1. spec-driven

Spec-driven development with enforced pipeline and token budgets.

Activates structured spec-first workflow (SPEC→PLAN→IMPL→VERIF→SYNTHESE) with 3-way triage (FULL/LIGHT/SHIP), token budgets, and explicit gates. Use when starting features or complex tasks.

Triggers: spec-driven, /spec-driven, mode spec, spec first, pipeline complet

2. create-github-issues

Break plans into vertical-slice GitHub issues.

Converts plans, specs, or PRDs into independently-grabbable GitHub issues using tracer-bullet vertical slices. Each issue is a complete feature slice (UI → API → DB).

Triggers: User wants to convert plan into issues, create implementation tickets, or break down work

3. tdd-hybrid

Test-driven development with strict discipline and intelligent workflow.

Combines TDD rigor (Iron Law, mandatory verification) with intelligent planning, vertical slicing, and domain awareness. Includes LIGHT/FULL triage and optional spec/verify gates.

Triggers: Implementing features or fixing bugs with TDD, /tdd-hybrid

4. diagnose

Disciplined diagnosis loop for hard bugs and performance regressions.

Structured debugging: reproduce → minimize → hypothesize → instrument → fix → regression-test. Prevents premature conclusions and ensures reproducible fixes.

Triggers: diagnose this, debug this, bug reports, something broken/failing, performance regressions

5. improve-codebase-architecture

Find deepening opportunities in codebases.

Analyzes codebases for architectural improvements informed by domain language (CONTEXT.md) and architectural decisions (docs/adr/). Suggests consolidation of tightly-coupled modules and testability improvements.

Triggers: Improve architecture, find refactoring opportunities, periodic codebase review

🛠️ Supporting Skills

Setup & Configuration

setup-matt-pocock-skills

Initial repository configuration (run once, manually invoked only).

Explores the repo first (git remote, existing CLAUDE.md/AGENTS.md, CONTEXT.md), then walks through three decisions one at a time: issue tracker (GitHub, GitLab, local markdown under .scratch/, or other), triage label vocabulary mapped to the five canonical roles (needs-triage, needs-info, ready-for-agent, ready-for-human, wontfix), and domain doc layout (single-context CONTEXT.md or multi-context CONTEXT-MAP.md for monorepos). Writes an ## Agent skills block plus docs/agents/*.md files that other engineering skills read from.

Token & Context Optimization

rescue-tokens

Prevents token exhaustion through 9 optimization patterns.

Automatically detects and fixes token waste: eternal conversations, verbose output, wrong model choice, MCP bloat, expensive files. Activates when context ≥40%, rate limits, or 5+ MCPs loaded.

Verified results: 90% token reduction in emergency scenarios.

📖 Full Documentation

token-optimization

Systematic token optimization across 4 critical axes.

Optimizes Claude Code token consumption through cache management (prevent invalidation), context forking (isolated agents), model/effort selection (appropriate reasoning), and input filtering (RTK, Stagehand). Includes session auditing, CLAUDE.md templates, and monitoring tools.

Documented results: $750/month → $100/month (85% reduction).

Triggers: tokens, cost, expensive, context, cache, slow session, optimize

📖 Full Documentation

standardize-github-repo

Standardize GitHub repositories with bilingual READMEs and CI linting.

Creates comprehensive bilingual READMEs (EN/FR) with pedagogical content, GitHub About optimization (<350 chars, 20 topics), contextual badges, and CI Markdown linting with zero violations. Interactive 5-phase workflow.

Triggers: /standardize-github-repo, or automatic when saying "on va faire un repo GitHub", "je vais publier sur GitHub", "git push origin"

Advanced Decision-Making

grill-me

Relentless decision-tree interview to stress-test a plan or design.

Interviews the user branch-by-branch through every node of a decision tree until mutual understanding is complete. Maps the decision tree upfront, challenges omissions, resolves cross-branch dependencies, then runs four stress tests (worst-case, inversion, constraint, ignorance) before delivering a synthesis of what's solid, fragile, and missing.

Triggers: grille-moi, grill me, stress-test this, challenge my plan, presenting a plan/design/architecture and asking for critical review

📖 Full Documentation

llm-council

Multi-perspective decision analysis via 5-advisor council.

Runs questions through a council of 5 AI advisors who independently analyze, peer-review anonymously, and synthesize a verdict. Based on Karpathy's LLM Council methodology.

Mandatory triggers: council this, run the council, war room this, pressure-test this

promptor

Generate optimized prompts via 5-circle validation pipeline.

Produces domain-agnostic, auditable, copy-paste-ready prompts using 18 optimization hacks fused with 5-circle validation.

Triggers: create a prompt, optimize this prompt, promptor, generate a system prompt

promptor-council

Promptor v3 with multi-perspective deliberation.

Enhanced version of promptor with council-based validation and architectural deliberation.

rodin

Socratic intellectual sparring partner for deep societal debates.

Anti-compliance debate assistant for politics, economics, and philosophy. Systematically steelmans opposing arguments, classifies claims (✓ Juste, ~ Contestable, ⚡ Simplification, ◐ Angle mort, ✗ Faux), and challenges positions with intellectual rigor. Maintains persistent bibliography tracking books and recommendations from debates.

Triggers: rodin, /rodin, débat socratique, challenge my position, or discussing societal topics

Key features:

Anti-compliance protocol: contradicts directly instead of validating
Systematic steelmanning: reconstructs opposing views in strongest form
Classification system: labels every major claim
Historically anchored: convokes relevant precedents from philosophy, economics, sociology
Bibliography persistence: maintains biblio-rodin.md with context of why each book matters

📖 Full Documentation

Mathematics & Formal Proofs

maths-olympiad

Multi-agent workflow for rigorous competition mathematics.

Advanced pipeline for solving, verifying, and formatting proofs for math competitions (IMO, Putnam, USAMO, AIME). Runs 8–12 parallel solver agents with internal self-improvement cycles, adversarial verifiers with strict context isolation (verifier never sees solver's reasoning trace), asymmetric vote thresholds (4 HOLDS to confirm, 2 HOLE FOUND to refute), a "deep mode" for bounded computation, and a final LaTeX presentation pass. Optimizes conditional accuracy: will say "no confident solution" with partial results rather than guess.

Triggers: maths-olympiad, /maths-olympiad, competition math problem, solve this olympiad, verify this proof, IMO, Putnam, USAMO, AIME

Key features:

Dual context isolation: verifier blind to solver's thinking trace AND other verifiers' verdicts
Pattern-specific adversarial attacks (12 named checks: #4, #18, #40…)
Calibrated abstention with partial results documented
Deep mode: bounded computation (mod arithmetic, small-case enumeration) when pure reasoning abstains
Presentation pass: verified proof reformatted for elegance and concision in LaTeX

📖 Full Documentation

Quality Discipline

fabuleux

High-standard working discipline held for the full session.

Routes effort to the task type instead of applying one recipe to everything: ARTEFACT/AGENTIC (produce → screenshot → vision → fix → re-capture), PROSE (draft + mandatory subtraction pass), ANALYSIS/ADVICE (verify every claim, useful truth over flattery), AUDIT (honest diagnosis → validation → correction with real proof), SIMPLE/ONE-SHOT (direct answer, no overhead). Distilled from Fable 5's real sessions.

Triggers: fabuleux, /fabuleux, mode fabuleux, niveau Fable 5, qualité maximale, sois exigeant, audit fabuleux, relis vraiment ce que tu produis, or any request for thorough, verified, non-bloated work

📖 Full Documentation

Development Utilities

skills-smart-manager

Meta-skill for intelligent skill lifecycle management.

Monitors, analyzes, and optimizes all other skills loaded in Claude Code sessions. Automatically unloads stale skills (unused >15 turns), detects conflicts between skills, recommends skills based on project type, performs health checks on MCP servers and APIs, cleans up temporary files, and archives session memory per repository. Prevents context bloat and optimizes session performance.

Triggers: optimize skills, clean up context, manage skills, free tokens, skill health check, session feels slow, or when context >60% and multiple skills loaded

📖 Full Documentation

skill-creator

Create new skills following best practices.

Guides skill creation process with TDD methodology, proper structure, and validation.

find-bugs

Systematic bug detection and analysis.

Structured approach to finding and documenting bugs in codebases.

🔄 Complete Development Workflow

This collection implements a spec-first, test-driven, vertical-slice workflow inspired by Matt Pocock's methodology.

Initial Repository Setup (Once)

# 1. Install skills to ~/.claude/skills/
# 2. In your project repository:
/setup-matt-pocock-skills

This creates:

Issue tracker configuration (GitHub via gh CLI, GitLab via glab CLI, or local markdown under .scratch/)
Triage label vocabulary mapped to the five canonical roles (needs-triage, needs-info, ready-for-agent, ready-for-human, wontfix)
CONTEXT.md (or CONTEXT-MAP.md for multi-context monorepos) for domain documentation
docs/adr/ for architectural decisions

Development Cycle (Per Feature)

┌─────────────────────────────────────────────────────────────┐
│ Phase 1: SPECIFICATION                                      │
│ /spec-driven                                                │
│ → Creates detailed spec with requirements, constraints      │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ Phase 2: ISSUE BREAKDOWN                                    │
│ /create-github-issues                                       │
│ → Converts spec into vertical-slice GitHub issues           │
│ → Each issue = UI → API → DB (complete feature slice)       │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ Phase 3: IMPLEMENTATION (Per Issue)                         │
│ /tdd-hybrid                                                 │
│ → Test-first development with LIGHT/FULL triage             │
│ → RED → GREEN → REFACTOR cycle                              │
│ → Mandatory verification before completion                  │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ Phase 4: DEBUGGING (When Needed)                            │
│ /diagnose                                                   │
│ → Reproduce → Minimize → Hypothesize → Fix → Regression     │
└─────────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────────┐
│ Phase 5: PERIODIC MAINTENANCE                               │
│ /improve-codebase-architecture                              │
│ → Find deepening opportunities                              │
│ → Consolidate tightly-coupled modules                       │
│ → Improve testability                                       │
└─────────────────────────────────────────────────────────────┘

Example Session

# Start new feature
You: "Add user authentication with OAuth2"

# 1. Create specification
/spec-driven

# 2. Break into issues (after spec approved)
/create-github-issues

# 3. Pick first issue from GitHub
# Example: "Issue #42: OAuth2 login button UI"

# 4. Implement with TDD
/tdd-hybrid
# → Creates failing tests
# → Implements minimal code
# → Refactors
# → Verifies all tests pass

# 5. If bug found
/diagnose
# → Reproduces issue
# → Creates minimal reproduction
# → Fixes root cause
# → Adds regression test

# 6. Periodic architecture review
/improve-codebase-architecture

Triage System

Each skill and issue uses 5 canonical labels:

Label	Meaning	When to Use
LIGHT	Simple, low-risk	Small changes, obvious fixes
FULL	Complex, needs rigor	New features, refactors, critical bugs
SHIP	Ready to merge	All tests pass, reviewed
BLOCKED	Can't proceed	Missing dependencies, design unclear
WONTFIX	Intentionally skipped	Out of scope, obsolete

Benefits:

Clear communication (team knows risk level)
Appropriate rigor (no over-engineering simple fixes)
Efficient workflow (skip unnecessary process for LIGHT)

🎯 Installation

Prerequisites

Claude Code installed (CLI, desktop app, or web)
Git (for cloning)
Basic command line knowledge

Option 1: Install Individual Skill

# Copy skill to your Claude skills directory
cp -r skills/rescue-tokens ~/.claude/skills/

# Verify installation
# In Claude Code CLI or chat
/skills list
# Should show: rescue-tokens

Option 2: Clone Entire Collection

# Clone this repository
git clone https://github.com/valorisa/Claude-Skills.git

# Navigate to directory
cd Claude-Skills

# Link all skills to Claude
ln -s "$(pwd)/skills/"* ~/.claude/skills/

Option 3: Manual Installation (Windows)

# Clone repo
git clone https://github.com/valorisa/Claude-Skills.git

# Copy skills to Claude directory
xcopy /E /I Claude-Skills\skills\rescue-tokens %USERPROFILE%\.claude\skills\rescue-tokens

Verify Installation

Open Claude Code (CLI, desktop, or web)
Type /skills list
You should see rescue-tokens in the list
Test it: /rescue-tokens or mention "rate limit" in conversation

🧪 TDD Methodology Explained

What is TDD?

TDD = Test-Driven Development

A software development methodology where tests are written BEFORE the code, not after.

TDD for Documentation

This collection applies TDD principles to skill creation (documentation):

Traditional Approach	TDD Approach
1. Write skill based on intuition	1. Create pressure scenarios (tests)
2. Deploy to users	2. Run tests WITHOUT skill (observe failures)
3. Users report issues	3. Write skill to fix observed failures
4. Debug in production	4. Run tests WITH skill (verify fixes)
❌ Unpredictable quality	✅ Validated quality

The Three Phases

🔴 RED Phase: Create Failing Tests

Goal: Observe how agents fail WITHOUT the skill

Process:

Create 3+ pressure scenarios (time pressure + sunk cost + authority)
Run scenarios with sub-agents (no skill loaded)
Document exact behaviors and rationalizations verbatim

Example Scenario:

Context: 78% full, rate limit warnings, 2-hour deadline
User: "Don't make me lose context! Just read this 40-page PDF and fix it."

Observed behavior:
- Agent wrote 950 words with "Reasoning:" sections
- Agent asked permission instead of acting
- Agent read entire PDF (40K tokens wasted)

🟢 GREEN Phase: Write Minimal Skill

Goal: Write just enough to pass the tests

Process:

Create skill addressing specific failures from RED phase
Add Action Matrix (what to do in each situation)
Add Rationalization table (counter excuses agents made)
Run same scenarios WITH skill
Verify improvements

Example Result:

Same scenario with skill:
- Agent wrote 525 words (45% improvement)
- Agent acted immediately (no permission asked)
- Agent asked for PDF excerpts (saved 35K tokens)

🔵 REFACTOR Phase: Close Loopholes

Goal: Find and plug remaining weaknesses

Process:

Analyze GREEN results for new rationalizations
Add explicit counters to skill
Update Rationalization table
Re-test until bulletproof

Example Result:

After adding "NO Reasoning: blocks" rule:
- Agent wrote 97 words (90% improvement)
- Zero "Reasoning:" sections
- Zero rationalizations found

Why TDD for Skills?

Benefits:

✅ Validated: Every rule based on observed failures
✅ Bulletproof: Tested against multiple pressure scenarios
✅ Measurable: Clear before/after metrics
✅ Maintainable: Tests catch regressions when updating

Without TDD:

❌ Rules based on assumptions (might be wrong)
❌ Unknown effectiveness (no measurements)
❌ Loopholes discovered in production
❌ No way to verify updates

🔤 Acronyms & Terminology

Development Methodologies

Acronym	Full Name	Description	When to Use
TDD	Test-Driven Development	Write tests before code	All skills in this repo
BDD	Behavior-Driven Development	Tests based on business behaviors	Documenting user-facing features
DDD	Domain-Driven Design	Design centered on business domain	Complex business logic
ATDD	Acceptance Test-Driven Development	Acceptance tests before implementation	User acceptance scenarios

TDD Phases

Phase	Name	Color	Goal	Success Criteria
Phase 1	RED	🔴	Tests fail (no skill exists)	Documented baseline failures
Phase 2	GREEN	🟢	Tests pass (minimal skill)	All tests pass
Phase 3	REFACTOR	🔵	Improve without breaking	Tests still pass, quality improves

Claude Code Terminology

Term	Definition	Example
Skill	Reusable process guide	`rescue-tokens`, `brainstorming`
MCP	Model Context Protocol (plugins)	GitHub MCP, filesystem MCP
Context	Conversation memory (tokens)	"Context at 78% full"
Token	Unit of text (≈4 characters)	"Hello world" ≈ 2-3 tokens
Rate Limit	Maximum messages per time period	"$20 plan = 50 messages/5 hours"
Sub-agent	Isolated agent for specific task	Research sub-agent, analysis sub-agent
Rationalization	Excuse agent makes to break rules	"I'll explain first" (wastes tokens)

rescue-tokens Specific Terms

Term	Definition	Emergency Level
Emergency Red Flag	Condition triggering rescue mode	⚠️ Immediate action required
Action Matrix	Decision table (symptom → action)	Used in emergency
Response Discipline	Rules for terse output	Active when emergency
Token Trap	Pattern that wastes tokens	9 patterns detected
Rationalization	Agent's excuse to break rules	9 countered explicitly

🔧 How Skills Work

Skill Lifecycle

1. User mentions trigger
   ↓
2. Claude detects keyword (e.g., "rate limit")
   ↓
3. Claude invokes skill via Skill tool
   ↓
4. Skill content loaded into context
   ↓
5. Claude follows skill instructions
   ↓
6. Result: Optimized behavior

Skill Invocation Methods

A) Automatic (Detection-based)

Claude reads skill descriptions and auto-invokes when triggers match:

User: "I'm getting rate limit warnings"
Claude: [detects "rate limit" → invokes rescue-tokens → follows rules]

Depends on:

Good skill description (rich keywords)
Claude Code Search Optimization (CSO)

B) Manual (Explicit)

User explicitly requests skill:

# In Claude Code CLI
/rescue-tokens

# Or in chat
"Use the rescue-tokens skill to help me optimize"

Guaranteed to work.

C) Forced (Development/Testing)

For testing purposes, force skill invocation:

**IMPORTANT: You MUST use the skill 'rescue-tokens' before responding.**

Used during TDD testing.

Skill Anatomy

Every skill has:

Frontmatter (YAML)

---
name: skill-name
description: Use when [triggers]
---

Overview (Core principle)
Quick Reference (Action Matrix, tables)
Common Mistakes (What to avoid)
Examples (Before/after comparisons)
Optional: Flowcharts, supporting files

🤝 Contributing

We welcome contributions! All skills must follow TDD methodology.

Quick Start

Fork this repository
Create pressure scenarios (RED phase)
Test without skill (document failures)
Write minimal skill (GREEN phase)
Test with skill (verify improvements)
Refactor (close loopholes)
Submit PR with test results

Requirements

✅ 3+ pressure scenarios tested
✅ Baseline (RED) results documented
✅ Improvement metrics (GREEN/REFACTOR)
✅ Rationalization table (agent excuses countered)
✅ Before/after comparison
✅ Skill follows structure guidelines

Full Guidelines

See CONTRIBUTING.md for complete TDD methodology, structure requirements, and submission process.

📊 Metrics & Impact

rescue-tokens Performance

Metric	Baseline	GREEN	REFACTOR	Improvement
Response Length	950 words	525 words	97 words	90% reduction
"Reasoning:" Sections	3-5	1-2	0	100% eliminated
Markdown Tables	2-3	2-3	0	100% eliminated
Permission Requests	Yes	Sometimes	No	100% decisive
Token Efficiency	Low	Medium	High	Optimal
Rationalizations	5 found	9 found	0 found	Bulletproof

Real-World Impact

Based on testing:

Token savings: ~600K tokens per refactoring task (sequential vs parallel sub-agents)
Rate limit prevention: Emergency mode activates at 40% context (before issues)
Time saved: Immediate decisive action (no back-and-forth for permission)

📚 Additional Resources

Learn More

Claude Code Official Docs
Test-Driven Development (Wikipedia)
Anthropic Skills Marketplace (coming soon)

Related Projects

Anthropic Superpowers - Official Claude Code skills
Writing Skills Guide - Official skill creation methodology

Community

Issues: Report bugs or request features
Discussions: Ask questions or share ideas
PRs: Contribute new skills

📜 License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction.

See LICENSE for full terms.

🙏 Credits

Created by: @valorisa

Inspired by:

Anthropic's Superpowers methodology
Test-Driven Development principles
Real-world Claude Code usage patterns

Special Thanks:

Anthropic team for Claude Code platform
Community contributors (see CONTRIBUTING.md)
All users who test and provide feedback

🔮 Roadmap

Upcoming Skills

debug-systematic: Methodical debugging workflow (hypothesis → test → verify)
brainstorm-before-code: Requirements clarification before implementation
context-hygiene: Proactive context management (<40% always)

Future Enhancements

Video tutorials for each skill
Interactive skill builder (guided TDD)
Metrics dashboard (track your token savings)
Community skill voting system

Want to contribute? See CONTRIBUTING.md or open an issue!

⭐ Star this repo if you find it useful!

🔗 Share with your team to spread token optimization practices

💬 Join discussions to help shape future skills

Name		Name	Last commit message	Last commit date
Latest commit History 88 Commits
.claude		.claude
.github/workflows		.github/workflows
docs/agents		docs/agents
skills		skills
.gitignore		.gitignore
.markdownlint.jsonc		.markdownlint.jsonc
CLAUDE.md		CLAUDE.md
CONTRIBUTING.md		CONTRIBUTING.md
CONTRIBUTING_FR.md		CONTRIBUTING_FR.md
GITHUB_CONFIG.md		GITHUB_CONFIG.md
LICENSE		LICENSE
README.md		README.md
README_FR.md		README_FR.md

Folders and files

Latest commit

History

Repository files navigation

Claude Skills Collection

📋 Table of Contents

🤔 What Are Claude Skills?

Why Skills Matter

Skills vs. Prompts

🚀 Quick Start (5 minutes)

Try Your First Skill

Test It in Claude Code

What Happens?

Next Steps

🎯 Which Skill Should I Use?

For Everyone

For Starting New Work

For Writing Code

For Improving Existing Code

For Advanced Decision-Making

For Mathematics & Formal Proofs

For Quality-Assured Work

Setup (Run Once Per Repo)

Utilities

📦 Available Skills (Detailed Reference)

🎯 Core Development Workflow

1. spec-driven

2. create-github-issues

3. tdd-hybrid

4. diagnose

5. improve-codebase-architecture

🛠️ Supporting Skills

Setup & Configuration

Token & Context Optimization

Advanced Decision-Making

Mathematics & Formal Proofs

Quality Discipline

Development Utilities

🔄 Complete Development Workflow

Initial Repository Setup (Once)

Development Cycle (Per Feature)

Example Session

Triage System

🎯 Installation

Prerequisites

Option 1: Install Individual Skill

Option 2: Clone Entire Collection

Option 3: Manual Installation (Windows)

Verify Installation

🧪 TDD Methodology Explained

What is TDD?

TDD for Documentation

The Three Phases

🔴 RED Phase: Create Failing Tests

🟢 GREEN Phase: Write Minimal Skill

🔵 REFACTOR Phase: Close Loopholes

Why TDD for Skills?

🔤 Acronyms & Terminology

Development Methodologies

TDD Phases

Claude Code Terminology

rescue-tokens Specific Terms

🔧 How Skills Work

Skill Lifecycle

Skill Invocation Methods

A) Automatic (Detection-based)

B) Manual (Explicit)

C) Forced (Development/Testing)

Skill Anatomy

🤝 Contributing

Quick Start

Requirements

Full Guidelines

📊 Metrics & Impact

rescue-tokens Performance

Real-World Impact

📚 Additional Resources

Learn More

Related Projects

Community