
Strategic Compact
- 1.4k installs
- 238k repo stars
- Updated August 5, 2026
- affaan-m/ecc
This is a copy of strategic-compact by affaan-m - installs and ranking accrue to the original listing.
strategic-compact is an agent skill that recommends manual `/compact` at natural workflow boundaries for developers who need to preserve critical context through long, multi-phase coding sessions.
About
strategic-compact is an ECC agent skill that coaches when to run Claude Code's manual `/compact` command at logical workflow boundaries instead of relying on automatic compaction. The skill activates when sessions approach context limits above 200K tokens, when switching between unrelated tasks, or after major milestones like finishing research before implementation. It maps compaction points to multi-phase work—research, plan, implement, test—so developers retain decisions, file paths, and constraints that arbitrary auto-compaction would drop. Developers reach for strategic-compact when responses slow down, coherence drops, or they notice the model forgetting earlier agreements mid-session. The workflow is advisory: identify boundary, compact, then continue with a cleaner context window.
- Suggests manual /compact at logical task boundaries rather than arbitrary auto-compaction
- Triggers on PreToolUse by combining context size and milestone detection
- Preserves key context across research → plan → implement → test phases
- Activates at 200K+ tokens, after milestones, or before major context shifts
- Reduces incoherent responses caused by mid-task context pressure
Strategic Compact by the numbers
- 1,444 all-time installs (skills.sh)
- +93 installs in the week ending Aug 5, 2026 (Skillselion tracking)
- Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/affaan-m/ecc --skill strategic-compactAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 1.4k |
|---|---|
| repo stars | ★ 238k |
| Last updated | August 5, 2026 |
| Repository | affaan-m/ecc ↗ |
When should you manually compact Claude Code context?
Receive intelligent suggestions for when to manually compact context at natural workflow boundaries instead of letting the model lose critical details through automatic
Who is it for?
Developers running long Claude Code sessions across research, planning, implementation, and testing who hit context pressure before finishing.
Skip if: Developers on short single-task sessions where context limits are nowhere near exhaustion and auto-compaction is sufficient.
When should I use this skill?
The user reports slow responses, forgotten prior decisions, or asks when to `/compact` during a long multi-phase agent session.
What you get
A phased `/compact` plan tied to workflow milestones and preserved session-critical decisions.
- Compaction timing recommendations
- Phase-boundary context preservation plan
By the numbers
- Activates when sessions approach 200K+ token context limits
Files
Strategic Compact Skill
Suggests manual /compact at strategic points in your workflow rather than relying on arbitrary auto-compaction.
When to Activate
- Running long sessions that approach context limits (200K+ tokens)
- Working on multi-phase tasks (research → plan → implement → test)
- Switching between unrelated tasks within the same session
- After completing a major milestone and starting new work
- When responses slow down or become less coherent (context pressure)
Why Strategic Compaction?
Auto-compaction triggers at arbitrary points:
- Often mid-task, losing important context
- No awareness of logical task boundaries
- Can interrupt complex multi-step operations
Strategic compaction at logical boundaries:
- After exploration, before execution — Compact research context, keep implementation plan
- After completing a milestone — Fresh start for next phase
- Before major context shifts — Clear exploration context before different task
How It Works
The suggest-compact.js script runs on PreToolUse (Edit/Write) and combines two signals:
1. Context size (primary) — Reads the latest usage record from the session transcript (transcript_path in the hook payload) and sums input_tokens + cache_read_input_tokens + cache_creation_input_tokens (the true context size of the turn). Suggests /compact at a window-scaled threshold — 160k tokens on a 200k window, 250k on a 1M window (detected from a [1m] model marker, or inferred when observed tokens already exceed 200k) — and re-reminds after every additional 60k tokens of context growth 2. Tool-call count (secondary) — Counts tool invocations in session; suggests at a configurable threshold (default: 50 calls), then every 25 calls after
Hook Setup
Add to your ~/.claude/settings.json:
{
"hooks": {
"PreToolUse": [
{
"matcher": "Edit",
"hooks": [{ "type": "command", "command": "node ~/.claude/skills/strategic-compact/suggest-compact.js" }]
},
{
"matcher": "Write",
"hooks": [{ "type": "command", "command": "node ~/.claude/skills/strategic-compact/suggest-compact.js" }]
}
]
}
}Configuration
Environment variables:
COMPACT_THRESHOLD— Tool calls before first suggestion (default: 50)COMPACT_CONTEXT_THRESHOLD— Context tokens before the context-size suggestion (default: 160000 on a 200k window, 250000 on a 1M window;0disables the context signal)COMPACT_CONTEXT_INTERVAL— Additional context tokens before the suggestion repeats (default: 60000)
Compaction Decision Guide
Use this table to decide when to compact:
| Phase Transition | Compact? | Why |
|---|---|---|
| Research → Planning | Yes | Research context is bulky; plan is the distilled output |
| Planning → Implementation | Yes | Plan is in TodoWrite or a file; free up context for code |
| Implementation → Testing | Maybe | Keep if tests reference recent code; compact if switching focus |
| Debugging → Next feature | Yes | Debug traces pollute context for unrelated work |
| Mid-implementation | No | Losing variable names, file paths, and partial state is costly |
| After a failed approach | Yes | Clear the dead-end reasoning before trying a new approach |
What Survives Compaction
Understanding what persists helps you compact with confidence:
| Persists | Lost |
|---|---|
| CLAUDE.md instructions | Intermediate reasoning and analysis |
| TodoWrite task list | File contents you previously read |
Memory files (~/.claude/memory/) | Multi-step conversation context |
| Git state (commits, branches) | Tool call history and counts |
| Files on disk | Nuanced user preferences stated verbally |
Best Practices
1. Compact after planning — Once plan is finalized in TodoWrite, compact to start fresh 2. Compact after debugging — Clear error-resolution context before continuing 3. Don't compact mid-implementation — Preserve context for related changes 4. Read the suggestion — The hook tells you when, you decide if 5. Write before compacting — Save important context to files or memory before compacting 6. Use `/compact` with a summary — Add a custom message: /compact Focus on implementing auth middleware next
Related
- The Longform Guide — Token optimization section
- Memory persistence hooks — For state that survives compaction
continuous-learningskill — Extracts patterns before session ends
interface:
display_name: "Strategic Compact"
short_description: "Context management via strategic compaction"
brand_color: "#14B8A6"
default_prompt: "Use $strategic-compact to choose a useful context compaction boundary."
policy:
allow_implicit_invocation: true
Related skills
How it compares
Pick strategic-compact over generic session tips when you need boundary-aware `/compact` timing for multi-phase Claude Code work.
FAQ
What triggers strategic-compact?
strategic-compact activates on long sessions nearing 200K+ tokens, multi-phase tasks, task switches, completed milestones, or when responses slow and lose coherence from context pressure.
How is strategic-compact different from auto-compaction?
strategic-compact recommends manual `/compact` at logical workflow boundaries—after research, planning, or implementation—so developers choose what survives compaction instead of arbitrary automatic truncation.