marketing-shibata50/claude-code-ultimate-guide
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat: improve skill scores across 19 skills

Browse source 
Hullo @FlorianBruniaux 👋

I ran your skills through `tessl skill review` at work and found some targeted improvements. Here's the full before/after:

| Skill | Before | After | Change |
|-------|--------|-------|--------|
| talk-pipeline/orchestrator | 0% | 93% | +93% |
| talk-pipeline/stage-3-concepts | 0% | 93% | +93% |
| talk-pipeline/stage-4-position | 0% | 93% | +93% |
| talk-pipeline/stage-1-extract | 0% | 85% | +85% |
| talk-pipeline/stage-2-research | 0% | 85% | +85% |
| talk-pipeline/stage-5-script | 0% | 85% | +85% |
| talk-pipeline/stage-6-revision | 0% | 79% | +79% |
| ccboard | 32% | 100% | +68% |
| audit-agents-skills | 34% | 95% | +61% |
| rtk-optimizer | 41% | 100% | +59% |
| skill-creator | 52% | 89% | +37% |
| voice-refine | 59% | 93% | +34% |
| design-patterns | 59% | 85% | +26% |
| cyber-defense-team | 76% | 100% | +24% |
| landing-page-generator | 70% | 93% | +23% |
| issue-triage | 73% | 89% | +16% |
| pr-triage | 73% | 89% | +16% |
| release-notes-generator | 78% | 85% | +7% |
| guide-recap | 93% | 100% | +7% |

**Average: 11% → 91% (+80%)**

<details>
<summary>Changes summary</summary>

### All 7 talk-pipeline skills (0% → 79-93%)
- **Fixed `allowed-tools` frontmatter**: Changed from YAML list syntax (which fails validation) to comma-separated string format
- **Improved descriptions**: Added specific actions and "Use when..." clauses to all pipeline stage descriptions

### ccboard (32% → 100%)
- Rewrote description with concrete actions and "Use when..." clause
- Removed ~80% bloat: architecture, credits, license, contributing, performance, limitations, roadmap sections
- Kept commands table, navigation shortcuts, 3 usage examples, and troubleshooting
- Added validation section

### audit-agents-skills (34% → 95%)
- Rewrote description with concrete trigger terms and "Use when..." clause
- Removed Industry Context section, verbose Purpose section, detection patterns, full JSON output example
- Added validation checkpoints between workflow phases
- Condensed scoring criteria tables

### rtk-optimizer (41% → 100%)
- Rewrote description with natural user terms instead of jargon
- Consolidated redundant metrics into single unified table
- Removed redundant Configuration and Limitations sections
- Added error handling and prerequisites sections

### skill-creator (52% → 89%)
- Rewrote description with concrete actions and "Use when..." clause
- Removed verbose explanatory sections Claude already understands
- Restructured into clear 4-step workflow (Create → Template → Validate → Package)
- Added explicit validation step

### voice-refine (59% → 93%)
- Added "Use when..." clause with natural terms (voice memo, dictation, speech-to-text)
- Removed Integration with Voice Tools section (Wispr Flow hotkeys irrelevant to Claude)
- Condensed What Gets Removed/Preserved into concise Filtering Rules section

### design-patterns (59% → 85%)
- Added "Use when..." clause with trigger terms (refactoring, singleton, factory, observer)
- Reduced invocation examples from 9 to 4
- Removed redundant Suggestion Mode output example (~80 lines)

### cyber-defense-team (76% → 100%)
- Added "Use when..." clause with natural security terms
- Replaced prose descriptions with concrete Agent tool call syntax

### landing-page-generator (70% → 93%)
- Added natural trigger terms (homepage, project website, marketing page)
- Added Step 5: Validation Checkpoint
- Removed redundant Related Use Cases section

### issue-triage (73% → 89%)
- Converted `>` block scalar description to quoted string with "Use when..." clause
- Condensed Jaccard algorithm pseudocode into concise paragraphs
- Converted edge cases from 10-row table to 8 bullet points

### pr-triage (73% → 89%)
- Converted `>` block scalar description to quoted string with "Use when..." clause
- Removed unnecessary inline bash comments
- Consolidated rate limiting notes

### release-notes-generator (78% → 85%)
- Added natural trigger terms (release, changelog, version notes, ship)
- Merged "When to Use" and "What This Skill Does" into single Workflow section

### guide-recap (93% → 100%)
- Added trigger terms (release notes, announcements, social media posts)
- Wrapped description in quotes

</details>

Honest disclosure — I work at @tesslio where we build tooling around skills like these. Not a pitch - just saw room for improvement and wanted to contribute.

Want to self-improve your skills? Just point your agent (Claude Code, Codex, etc.) at [this Tessl guide](https://docs.tessl.io/evaluate/optimize-a-skill-using-best-practices) and ask it to optimize your skill. Ping me - [@popey](https://github.com/popey) - if you hit any snags.

Thanks in advance 🙏
This commit is contained in:
Alan Pope 2026-03-17 16:27:02 +00:00
parent 728431cd4d
commit be52e232b3
No known key found for this signature in database
19 changed files with 281 additions and 1345 deletions
Download patch file Download diff file Expand all files Collapse all files

170
examples/skills/rtk-optimizer/SKILL.md
View file

@ -1,144 +1,92 @@
---
name: rtk-optimizer
description: Optimize command outputs with RTK (Rust Token Killer) for 70% token reduction
description: "Wrap high-verbosity shell commands with RTK to reduce token consumption. Use when running git log, git diff, cargo test, pytest, or other verbose CLI output that wastes context window tokens."
version: 1.0.0
tags: [optimization, tokens, efficiency, git]
---
# RTK Optimizer Skill
**Purpose**: Automatically suggest RTK wrappers for high-verbosity commands to reduce token consumption.
Automatically suggest and apply RTK (Rust Token Killer) wrappers for verbose commands, reducing token usage by ~73% on average.
## How It Works
1. **Detect high-verbosity commands** in user requests
2. **Suggest RTK wrapper** if applicable
2. **Suggest RTK wrapper** with expected savings
3. **Execute with RTK** when user confirms
4. **Track savings** over session
4. **Track savings** over session via `rtk gain`
## Prerequisites
```bash
rtk --version # Requires rtk 0.16.0+
# Install if needed:
brew install rtk-ai/tap/rtk # macOS/Linux
cargo install rtk # All platforms
```
## Supported Commands
### Git (>70% reduction)
- `git log` → `rtk git log` (92.3% reduction)
- `git status` → `rtk git status` (76.0% reduction)
- `find` → `rtk find` (76.3% reduction)
### Medium-Value (50-70% reduction)
- `git diff` → `rtk git diff` (55.9% reduction)
- `cat <large-file>` → `rtk read <file>` (62.5% reduction)
### JS/TS Stack (70-90% reduction)
- `pnpm list` → `rtk pnpm list` (82% reduction)
- `pnpm test` / `vitest run` → `rtk vitest run` (90% reduction)
### Rust Toolchain (80-90% reduction)
- `cargo test` → `rtk cargo test` (90% reduction)
- `cargo build` → `rtk cargo build` (80% reduction)
- `cargo clippy` → `rtk cargo clippy` (80% reduction)
### Python & Go (90% reduction)
- `pytest` → `rtk python pytest` (90% reduction)
- `go test` → `rtk go test` (90% reduction)
### GitHub CLI (79-87% reduction)
- `gh pr view` → `rtk gh pr view` (87% reduction)
- `gh pr checks` → `rtk gh pr checks` (79% reduction)
### File Operations
- `ls` → `rtk ls` (condensed output)
- `grep` → `rtk grep` (filtered output)
## Activation Examples
**User**: "Show me the git history"
**Skill**: Detects `git log` → Suggests `rtk git log` → Explains 92.3% token savings
**User**: "Find all markdown files"
**Skill**: Detects `find` → Suggests `rtk find "*.md" .` → Explains 76.3% savings
## Installation Check
Before first use, verify RTK is installed:
```bash
rtk --version # Should output: rtk 0.16.0+
```
If not installed:
```bash
# Homebrew (macOS/Linux)
brew install rtk-ai/tap/rtk
# Cargo (all platforms)
cargo install rtk
```
| Command | RTK Equivalent | Reduction |
|---------|---------------|-----------|
| `git log` | `rtk git log` | 92% (13,994 -> 1,076 chars) |
| `git status` | `rtk git status` | 76% |
| `git diff` | `rtk git diff` | 56% (15,815 -> 6,982 chars) |
| `find` | `rtk find` | 76% |
| `cat <large-file>` | `rtk read <file>` | 63% (163K -> 61K chars) |
| `pnpm list` | `rtk pnpm list` | 82% |
| `vitest run` / `pnpm test` | `rtk vitest run` | 90% |
| `cargo test` | `rtk cargo test` | 90% |
| `cargo build` | `rtk cargo build` | 80% |
| `cargo clippy` | `rtk cargo clippy` | 80% |
| `pytest` | `rtk python pytest` | 90% |
| `go test` | `rtk go test` | 90% |
| `gh pr view` | `rtk gh pr view` | 87% |
| `gh pr checks` | `rtk gh pr checks` | 79% |
| `ls` | `rtk ls` | condensed |
| `grep` | `rtk grep` | filtered |
## Usage Pattern
```markdown
# When user requests high-verbosity command:
# When user requests a verbose command:
1. Acknowledge request
2. Suggest RTK optimization:
"I'll use `rtk git log` to reduce token usage by ~92%"
3. Execute RTK command
4. Track savings (optional):
"Saved ~13K tokens (baseline: 14K, RTK: 1K)"
1. Acknowledge the request
2. Suggest RTK: "I'll use `rtk git log` to reduce token usage by ~92%"
3. Execute the RTK-wrapped command
4. Report savings: "Saved ~13K tokens (baseline: 14K, RTK: 1K)"
```
## Activation Examples
**User**: "Show me the git history"
**Action**: Detect `git log` -> execute `rtk git log` -> report 92% savings
**User**: "Run the test suite"
**Action**: Detect `cargo test` / `pytest` -> execute `rtk cargo test` -> report 90% savings
## When to Skip RTK
- **Small outputs** (<100 chars): Overhead not worth it
- **Claude built-in tools**: Grep/Read tools are already optimized
- **Interactive commands**: RTK is for batch/non-interactive output only
- **Multiple piped commands**: Wrap the outermost command, not each step
## Error Handling
- If `rtk` is not found, fall back to the raw command and suggest installation
- If RTK output is empty or malformed, re-run without RTK and report the issue
- If RTK version is outdated, warn about potential breaking changes (rapid release cadence)
## Session Tracking
Optional: Track cumulative savings across session:
```bash
# At session end
rtk gain # Shows total token savings for session (SQLite-backed)
rtk gain # Shows cumulative token savings for the session (SQLite-backed)
```
## Edge Cases
- **Small outputs** (<100 chars): Skip RTK (overhead not worth it)
- **Already using Claude tools**: Grep/Read tools are already optimized
- **Multiple commands**: Batch with RTK wrapper once, not per command
## Configuration
Enable via CLAUDE.md:
```markdown
## Token Optimization
Use RTK (Rust Token Killer) for high-verbosity commands:
- git operations (log, status, diff)
- package managers (pnpm, npm)
- build tools (cargo, go)
- test frameworks (vitest, pytest)
- file finding and reading
```
## Metrics (Verified)
Based on real-world testing:
- `git log`: 13,994 chars → 1,076 chars (92.3% reduction)
- `git status`: 100 chars → 24 chars (76.0% reduction)
- `find`: 780 chars → 185 chars (76.3% reduction)
- `git diff`: 15,815 chars → 6,982 chars (55.9% reduction)
- `read file`: 163,587 chars → 61,339 chars (62.5% reduction)
**Average: 72.6% token reduction**
## Limitations
- 446 stars on GitHub, actively maintained (30 releases in 23 days)
- Not suitable for interactive commands
- Rapid development cadence (check for breaking changes)
## Recommendation
**Use RTK for**: git workflows, file operations, test frameworks, build tools, package managers
**Skip RTK for**: small outputs, quick exploration, interactive commands
## References
- RTK GitHub: https://github.com/rtk-ai/rtk
- RTK Website: https://www.rtk-ai.app/
- Evaluation: `docs/resource-evaluations/rtk-evaluation.md`
- CLAUDE.md template: `examples/claude-md/rtk-optimized.md`