compact-guard
Smart context compaction with state preservation. Saves critical files, task progress, and working state before compaction, restores after. Use before manual compact or when auto-compact triggers.
Best use case
compact-guard is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Smart context compaction with state preservation. Saves critical files, task progress, and working state before compaction, restores after. Use before manual compact or when auto-compact triggers.
Teams using compact-guard should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/compact-guard/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How compact-guard Compares
| Feature / Agent | compact-guard | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Smart context compaction with state preservation. Saves critical files, task progress, and working state before compaction, restores after. Use before manual compact or when auto-compact triggers.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
Related Guides
SKILL.md Source
# Compact Guard Protect important context through compaction cycles. Based on Claude Code internals: compaction restores max 5 files with 5K tokens each, within a 50K total budget. ## Trigger Use before `/compact` or when auto-compact warning appears. ## Key Constants (from Claude Code source) - `POST_COMPACT_MAX_FILES_TO_RESTORE = 5` — only 5 files survive - `POST_COMPACT_TOKEN_BUDGET = 50K` — total restore budget - `POST_COMPACT_MAX_TOKENS_PER_FILE = 5K` — per-file limit - Auto-compact fires at `context_window - 13K` buffer ## Pre-Compact Checklist Before compacting, save these to memory or a scratch file: 1. **Current task** — What are you working on? One sentence. 2. **Files in progress** — Which files are being edited? (max 5 — compaction only restores 5) 3. **Decisions made** — Any architectural choices made this session 4. **Blockers** — What's preventing progress? 5. **Next steps** — What to do immediately after compact ## Strategy: Microcompact First Before full compaction, try microcompact: - Large tool results (test output, grep results) can be trimmed - File reads that are no longer relevant can be dropped - Use subagents for heavy exploration to keep main context clean ## Post-Compact Recovery After compaction, immediately: 1. Re-read the top-priority file (the one you're actively editing) 2. Check task list for current progress 3. Review any scratch notes saved pre-compact 4. Resume from next steps ## Prevention Strategies | Strategy | Token Savings | When | |----------|--------------|------| | Delegate grep/search to subagent | 30-60% per search | Always for broad searches | | Read only needed lines (`offset`/`limit`) | 50-90% per read | Large files | | Compact at task boundaries | Preserves coherence | Between logical steps | | Use `/resume` for fresh start | 100% | Unrelated new task | ## Output After running compact-guard: ```text COMPACT GUARD Files to preserve: [list top 5] Task state: [one sentence] Decisions: [key choices] Next step: [immediate action after compact] Ready to compact. Run /compact now. ``` ## Rules - Always save state before compacting — never compact blind - Prioritize the file you're actively editing as #1 to restore - If auto-compact fires unexpectedly, immediately re-read your working file - Keep CLAUDE.md under 60 lines to leave room for actual context
Related Skills
wrap-up
End-of-session ritual that audits changes, runs quality checks, captures learnings, and produces a session summary. Use when saying "wrap up", "done for the day", "finish coding", or ending a coding session.
thoroughness-scoring
Score every decision point with a Thoroughness Rating (1-10). AI makes the marginal cost of doing things properly near-zero — pick the higher-rated option every time. Includes scope checks to distinguish contained vs unbounded work.
sprint-status
Track parallel work sessions and prevent confusion across multiple Claude Code instances. Every major step ends with a status line. Every question re-states project, branch, and task.
smart-commit
Run quality gates, review staged changes for issues, and create a well-crafted conventional commit. Use when saying "commit", "git commit", "save my changes", or ready to commit after making changes.
session-handoff
Generate a structured handoff document capturing current progress, open tasks, key decisions, and context needed to resume work. Use when ending a session, saying "continue later", "save progress", "session summary", or "pick up where I left off".
safe-mode
Prevent destructive operations using Claude Code hooks. Three modes — cautious (warn on dangerous commands), lockdown (restrict edits to one directory), and clear (remove restrictions). Uses PreToolUse matchers for Bash, Edit, and Write.
replay-learnings
Surface past learnings relevant to the current task before starting work. Searches correction history, recalls past mistakes, and applies prior patterns. Use when starting a task, saying "what do I know about", "previous mistakes", "lessons learned", or "remind me about".
pro-workflow
Complete AI coding workflow system. Orchestration patterns, 18 hook events, 5 agents, cross-agent support, reference guides, and searchable learnings. Works with Claude Code, Cursor, and 32+ agents.
permission-tuner
Analyze permission denial patterns and generate optimized alwaysAllow and alwaysDeny rules. Use when permission prompts are slowing you down or after sessions with many denials.
parallel-worktrees
Create and manage git worktrees for parallel coding sessions with zero dead time. Use when blocked on tests, builds, wanting to work on multiple branches, context switching, or exploring multiple approaches simultaneously.
orchestrate
Wire Commands, Agents, and Skills together for complex features. Use when building features that need research, planning, and implementation phases.
mcp-audit
Audit connected MCP servers for token overhead, redundancy, and security. Use when sessions feel slow or before adding new MCPs.