ahmed3elshaer/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:

/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:

/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:

/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:

/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:

/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

/compact                      # Auto-select strategy
/compact --level=medium       # Specify level
/compact --focus=compose      # Focus on specific area

Smart Compaction

/compact --smart              # AI chooses strategy
/compact --adaptive           # Adjusts based on usage

Manual Compaction

/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

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

1. /memory-summary              # Verify memory preserved
2. /instinct-status             # Verify instincts preserved
3. Continue work...

Integration

With Checkpoints

# Pre-compact hook automatically saves checkpoint
# Restore to recover if compaction removes needed context

With Memory

# Memory survives compaction
# Query memory to recover details:
/memory-query "What was the auth flow architecture?"

With Instincts

# 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:

1. /memory-query <topic>        # Query memory
2. /mobile-checkpoint list      # Check for checkpoints
3. /mobile-checkpoint restore <name>  # 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.