# Mobile Compaction > Context compaction strategies for large Android codebases. Optimize token usage while preserving critical context. Use when this capability is needed. - Skill: `tomevault-io/mobile-compaction` (Agent Skill, multi-file: 2 files) - Install (CLI): `npx skillmds@latest add tomevault-io/mobile-compaction` - Raw SKILL.md: https://api.skillmd.com/api/skills/tomevault-io/mobile-compaction/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Coding & Dev Tools - Author: tomevault-io (https://skillmd.com/u/tomevault-io) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/tomevault-io/mobile-compaction --- # Mobile Compaction Skill Strategic context compaction for large Android projects to optimize token usage while preserving critical information. ## When to Compact Compact context when: - Token usage exceeds 100,000 - Working on large refactors spanning many files - Switching between unrelated features - Session becomes unfocused - Context contains resolved discussions ## Compaction Strategies ### 1. Module-Level Compaction Focus on a single Android module: ```bash /compact --module=feature:auth ``` **What happens:** - Retain: All files in feature:auth module - Summarize: Other modules to high-level description - Drop: Resolved discussions about other modules **Use when**: Deep work on a specific feature ### 2. Layer-Based Compaction Focus on architecture layer: ```bash /compact --layer=ui /compact --layer=data /compact --layer=domain ``` **What happens:** | Layer | Retain | Summarize | |-------|--------|-----------| | UI | Composables, ViewModels, navigation | Repository details, data models | | Data | Repositories, data sources, models | Compose code, UI state | | Domain | Use cases, domain models | Implementation details | **Use when**: Working on cross-cutting concerns in a layer ### 3. Build Variant Focus Narrow to specific build variant: ```bash /compact --variant=debug ``` **What happens:** - Retain: Debug-specific configurations, test code - Summarize: Release configurations, ProGuard rules **Use when**: Debugging or test development ### 4. Test Isolation Compact around failing tests: ```bash /compact --test=AuthViewModelTest /compact --test-failing ``` **What happens:** - Retain: Test file, related source files - Summarize: Unrelated test discussions - Drop: Resolved test fix discussions **Use when**: Fixing specific test failures ### 5. Pattern-Based Compaction Compact based on architectural patterns: ```bash /compact --pattern=compose /compact --pattern=mvi /compact --pattern=koin ``` **What happens:** - Retain: Files matching the pattern - Summarize: Non-matching files to pattern names only **Use when**: Pattern-specific work (e.g., Compose optimization) ## Compaction Levels | Level | Retention | Token Savings | Use Case | |-------|-----------|---------------|----------| | **Lite** | Current task only | 70-80% | Deep focus work | | **Medium** | Current + related | 50-60% | Feature development | | **Standard** | Project summary | 30-40% | Default compaction | | **Minimal** | Essential only | 80-90% | Context at limit | ## What Gets Preserved ### Always Preserve (Critical) - Active task context (what we're doing now) - Recent code changes (last 5-10 files) - Current errors/failures - Mobile memory context - High-confidence instincts (>0.7) - Unresolved questions ### Usually Preserve (Important) - Architecture decisions - Recent discussions (last 50 messages) - Related file contents - Test states ### Summarize (Compressible) - Completed features - Resolved bugs - Working code explanations - Background discussions ### Drop (Disposable) - Successful build outputs - Trivial operations - Duplicated information - Off-topic discussions ## Compaction Commands ### Basic Compaction ```bash /compact # Auto-select strategy /compact --level=medium # Specify level /compact --focus=compose # Focus on specific area ``` ### Smart Compaction ```bash /compact --smart # AI chooses strategy /compact --adaptive # Adjusts based on usage ``` ### Manual Compaction ```bash /compact --keep=file1.kt,file2.kt # Keep specific files /compact --drop=discussion-1 # Drop specific discussion /compact --summarize=feature-x # Summarize specific topic ``` ## Compaction Workflow ### Before Compaction ```bash 1. /memory-save all # Save current state to memory 2. /mobile-checkpoint save pre-compact # Optional checkpoint 3. /compact --strategy=module --focus=feature:auth ``` ### After Compaction ```bash 1. /memory-summary # Verify memory preserved 2. /instinct-status # Verify instincts preserved 3. Continue work... ``` ## Integration ### With Checkpoints ```bash # Pre-compact hook automatically saves checkpoint # Restore to recover if compaction removes needed context ``` ### With Memory ```bash # Memory survives compaction # Query memory to recover details: /memory-query "What was the auth flow architecture?" ``` ### With Instincts ```bash # Instincts survive compaction # High-confidence instincts always retained # Low-confidence may be summarized ``` ## Anti-Patterns ### Don't Compact When: - In the middle of debugging - Unresolved errors exist - Active discussion ongoing - Task almost complete ### Do Compact When: - Starting new task - Switching context - Token limit approaching - Task completed, keeping summary ## Recovery If compaction removed needed context: ```bash 1. /memory-query # Query memory 2. /mobile-checkpoint list # Check for checkpoints 3. /mobile-checkpoint restore # Restore if needed 4. Git history for file diffs ``` ## Examples ### Example 1: Feature Development ``` Context: Working on auth feature, context contains old home feature discussions Action: /compact --module=feature:auth Result: Retains auth files, summarizes home feature ``` ### Example 2: Test Fixing ``` Context: Many files, focus on fixing LoginTest Action: /compact --test=LoginTest Result: Retains LoginTest, related auth files, summarizes rest ``` ### Example 3: Compose Optimization ``` Context: Large project, optimizing Compose performance Action: /compact --pattern=compose --level=medium Result: Retains Compose files, summaries of data/network layers ``` --- **Remember**: Compaction is reversible via checkpoints and memory. When in doubt, checkpoint first. --- > Converted and distributed by [TomeVault](https://tomevault.io/claim/ahmed3elshaer) — claim your Tome and manage your conversions.