
Response Compression
- 115 installs
- 325 repo stars
- Updated August 2, 2026
- athola/claude-night-market
Response Compression is an agent skill that removes filler and framing from agent replies—usable whenever a solo builder needs to save context tokens before committing to more tool calls or code.
About
Response Compression is a journey-wide agent skill from Claude Night Market that instructs agents to remove verbose framing, filler, hedging, and hype so answers stay direct and cheaper in tokens. It documents elimination rules, before/after examples, termination and directness guidelines, and a quick reference checklist, with stated impact of 200–400 tokens saved per response. Frontmatter sets `alwaysApply: true`, so it is meant to run whenever replies feel bloated or context is filling fast—not only during coding. Skip it when you are teaching novices step-by-step or when educational depth is the goal (the skill lists those as explicit anti-patterns). Ideal for solo builders running long Claude Code or Cursor sessions on tight context budgets. It is procedural communication policy packaged as SKILL.md, not a linter or formatter on your repository.
- Targets 200–400 tokens saved per response while preserving clarity
- Elimination rules for filler, hedging, hype words, and decorative emojis
- Before/after transformations and a quick-reference checklist
- Documented `alwaysApply: true` for persistent terse output
- Estimated skill footprint ~500 tokens; complexity tagged low in SKILL.md
Response Compression by the numbers
- 115 all-time installs (skills.sh)
- Ranked #1,314 of 3,282 Productivity & Planning skills by installs in the Skillselion catalog
- Security screen: MEDIUM risk (skills.sh audit)
- Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/athola/claude-night-market --skill response-compressionAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 115 |
|---|---|
| repo stars | ★ 325 |
| Security audit | 3 / 3 scanners passed |
| Last updated | August 2, 2026 |
| Repository | athola/claude-night-market ↗ |
What it does
Strip filler, hedging, and decorative bloat from agent replies to reclaim roughly 200–400 tokens per turn when context window pressure slows shipping.
Who is it for?
Power users in long agent sessions who already understand the task and want terse, checklist-friendly answers.
Skip if: First-time setup walkthroughs, teaching explanations, or stakeholders who need narrative context and reassurance language.
When should I use this skill?
Use when responses feel bloated or context is filling fast; compress verbose output per elimination rules.
What you get
Replies stay dense and factual with less decorative language, freeing hundreds of tokens per turn for code and commands.
- Shorter agent replies following elimination and directness guidelines
- Checklist-aligned answers without removed informational content
By the numbers
- Documented savings: 200–400 tokens per response
- Estimated skill size: ~500 tokens
- Frontmatter: alwaysApply true
Files
Table of Contents
- Elimination Rules
- Before/After Transformations
- Termination Guidelines
- Directness Guidelines
- Quick Reference Checklist
- Token Impact
- Integration
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-20260102Example 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) |
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 trackingconserve:context-optimization- MECW managementsanctum:code-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
Related skills
How it compares
Behavioral response policy skill—not a code formatter, test runner, or RAG compression tool.
FAQ
Who is response-compression for?
Developers and developers using Claude Code, Cursor, or similar agents who hit context limits because replies are unnecessarily verbose.
When should I use response-compression?
Across Idea research summaries, Validate scoping threads, Build implementation, Ship review notes, Launch copy drafts, Grow analytics Q&A, and Operate incident triage—whenever `alwaysApply` terse output helps and detailed pedagogy is not required.
Is response-compression safe to install?
It is instructions-only with no tools listed in frontmatter; still review the Security Audits panel on this Prism page before enabling `alwaysApply` in production workflows.