Skip to content
Skills Library
AI & agents · Writing

response-compression

/response-compression

Compresses verbose responses by removing filler and framing to save 200-400 tokens. Use when responses feel bloated or context is filling fast.

Licence
MIT
Last repository change
01.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 01.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Compresses verbose responses by removing filler and framing to save 200-400 tokens. Use when responses feel bloated or context is filling fast.

Original author description

Compresses verbose responses by removing filler and framing to save 200-400 tokens. Use when responses feel bloated or context is filling fast.

How it works

  1. When To Use
  2. When NOT To Use
  3. Elimination Rules
  4. Before/After Transformations
  5. Termination Guidelines
  6. Directness Guidelines
  7. Quick Reference Checklist
  8. Token Impact
  9. Integration
  10. Exit Criteria
Original SKILL.md headings · 221 lines, 987 words
SKILL.md preview
---
name: response-compression
description: Compresses verbose responses by removing filler and framing to save 200-400 tokens. Use when responses feel bloated or context is filling fast.
alwaysApply: false
category: optimization
tags:
- tokens
- efficiency
- communication
- directness
tools: []
complexity: low
model_hint: fast
estimated_tokens: 500
---

# Response Compression

Eliminate response bloat to save 200-400 tokens per response while maintaining clarity.


## When To Use

- Reducing verbose output to save context tokens
- Providing concise answers without losing information

## When NOT To Use

- Educational explanations where detail improves understanding
- First-time setup instructions needing step-by-step clarity

## Elimination Rules

### ELIMINATE

| Category | Examples | Replacement |
|----------|----------|-------------|
| **Decorative Emojis** | `--` | (remove entirely) |
| **Filler Words** | "just", "simply", "basically", "essentially" | (remove or rephrase) |
| **Hedging Language** | "might", "could", "perhaps", "potentially", "I think" | Use factual statements |
| **Hype Words** | "powerful", "amazing", "seamless", "robust", "elegant" | Use precise descriptors |
| **Conversational Framing** | "Let's dive in", "Now that we've", "Moving forward" | Start with content |
| **Transitions** | "Furthermore", "Additionally", "In conclusion" | (remove, use structure) |
| **Call-to-Action** | "Feel free to", "Don't hesitate to", "Let me know if" | (remove from endings) |

### PRESERVE (When Appropriate)

| Category | Example | When to Use |
|----------|---------|-------------|
| **Status Indicators** | `[pass] [fail] [warn]` | In structured output, checklists |
| **Technical Precision** | Exact error messages | When debugging |
| **Safety Warnings** | Critical info about data loss | Always preserve |
| **Context Setting** | Brief necessary background | When user lacks context |

## Before/After Transformations

### Example 1: Opening Bloat

**Before** (68 tokens):
```
Great question! I'd be happy to help you understand how this works.
The bloat detector is a powerful tool that analyzes your codebase
and provides comprehensive insights into potential issues...
```

**After** (28 tokens):
```
The bloat detector analyzes codebases using three tiers: quick scan
(heuristics), static analysis (tools), and deep audit (git history).
```

### Example 2: Closing Bloat

**Before** (45 tokens):
```
I've completed the task. Here's what I did:
- Deleted 5 files
- Saved 18k tokens

Next steps:
1. Review the changes
2. Run tests
3. Commit if satisfied

Let me know if you need anything else!
```

**After** (15 tokens):
```
Done. Deleted 5 files, saved 18k tokens.
Backup: backup/unbloat-20260102
```

### Example 3: Hedging Removal

**Before**:
```
I think this might potentially be causing the issue, but I could be wrong.
Perhaps we should consider looking into it further.
```

**After**:
```
This causes the issue. Investigate the connection pool timeout setting.
```

## Termination Guidelines

### When to Stop

End response immediately after:
- Delivering requested information
- Completing requested task
- Providing necessary context

### Avoid Trailing Content

| Pattern | Action |
|---------|--------|
| "Next steps:" | Remove unless safety-critical |
| "Let me know if..." | Remove always |
| "Summary:" | Remove (user has the response) |
| "Hope this helps!" | Remove always |
| Bullet recaps | Remove (redundant) |

### Override: action-first-output

When `Skill(conserve:action-first-output)` is active, two rows above
are overridden:

- **"Next steps:"**: one single-line next action is required, not
  removed. The ban still holds for multi-item "Next steps:" blocks.
- **Bullet recaps**: a position marker ("step 3 of 5 done") is
  required every turn. The ban still holds for recapping content the
  reader just read.

See the Precedence table in that skill for the full resolution.

### Exceptions (When Summaries Help)

- Multi-part tasks with many changes
- User explicitly requests summary
- Critical rollback/backup information
- Complex debugging with multiple findings

## Directness Guidelines

### Direct =/= Rude

**Goal**: Information density, not coldness.

| Eliminate | Preserve |
|-----------|----------|
| Unnecessary encouragement | Technical context |
| Rapport-building filler | Safety warnings |
| Hedging without reason | Necessary explanations |
| Positive padding | Factual uncertainty markers |

### Encouragement Bloat

**Eliminate**:
- "Great question!"
- "Excellent point!"
- "Good thinking!"
- "That's a great approach!"

**Replace with**: Direct answers to the question.

### Rapport-Building Filler

**Eliminate**:
- "I'd be happy to help you..."
- "Feel free to ask if..."
- "I hope this helps!"
- "Let me know if you need..."

**Replace with**: Useful information or nothing.

### Preserve Helpful Directness

The following are NOT bloat:
- Brief context when user needs it
- Clarifying questions when ambiguity affects correctness
- Warnings about destructive operations
- Error explanations that help debugging

## Quick Reference Checklist

Before finalizing response:

- [ ] No decorative emojis (status indicators OK)
- [ ] No filler words (just, simply, basically)
- [ ] No hedging without technical uncertainty
- [ ] No hype words (powerful, amazing, robust)
- [ ] No conversational framing at start
- [ ] No unnecessary transitions
- [ ] No "let me know" or "feel free" closings
- [ ] No summary of what was just said
- [ ] No "next steps" unless safety-critical
- [ ] Ends after delivering value

## Token Impact

| Pattern | Typical Savings |
|---------|-----------------|
| Eliminating opening bloat | 30-50 tokens |
| Removing closing fluff | 20-40 tokens |
| Cutting filler words | 10-20 tokens |
| Removing emoji | 5-15 tokens |
| Direct answers | 50-100 tokens |
| **Total per response** | **150-350 tokens** |

Over 1000 responses: 150k-350k tokens saved.

## Integration

This skill works with:
- `conserve:token-conservation` - Budget tracking
- `conserve:context-optimization` - MECW management
- `sanctum:pr-review` - Review feedback

## Exit Criteria

- [ ] Response contains none of the banned openers: "Great question!",
  "I'd be happy to help", "Let's dive in", "Furthermore",
  "Additionally", "In conclusion"
- [ ] Response contains no trailing filler: "Let me know if...",
  "Feel free to...", "Hope this helps!", "Next steps:" (unless
  safety-critical)
- [ ] Token count of final response is 150-400 tokens lower than a
  naive version of the same content would be, verified by comparing
  before/after examples when token impact is measurable
- [ ] Safety warnings, technical precision, and factual uncertainty
  markers are preserved intact; only decorative and conversational
  content is removed

Versions

The database has no other skills named response-compression.

Database snapshot: 13.11.2026 · package version ab0ec85be1e5 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100context-minimization
    Use when a task runs long and the context window is filling -- large files are being read whole, command output is flooding the transcript, or responses are getting verbose and slow.
  • 100context-compression
    Use when conversation context is bloated, constraints are being forgotten, or a compact handoff is needed before continuing work.
  • 100input-token-overheads
    Use when context window is filling up too fast or input token cost is too high. Audits overhead sources.
  • 100doncheli-context-health
    Report the current state of the context window and recommend compression or cleanup actions. Activate when user mentions "context health", "context window", "how much context", "context full", "running out of context", "compress context".
  • 100compression
    Use when the user asks to reduce token output, compress responses, switch to terse mode, or invokes /siftcoder:compress. Wraps the optional sift-compress companion plugin if installed; otherwise defines the rule directly.
  • 100context-weaving
    Use when spawning 4+ agents, when "Prompt is too long" errors appear, when sessions exceed 50 messages, or when context feels degraded. Prevents overflow before agent summoning, compresses long sessions, and offloads verbose content to filesystem. Keywords: context overflow,…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.