mobile-compaction

Original：🇺🇸 English

Translated

Context compaction strategies for large Android codebases. Optimize token usage while preserving critical context.

1installs

Sourceahmed3elshaer/everything-claude-code-mobile

Added on2026-02-21

NPX Install

npx skill4agent add ahmed3elshaer/everything-claude-code-mobile mobile-compaction

SKILL.md Content

View Translation Comparison →

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 <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.

mobile-compaction

NPX Install

Tags

SKILL.md Content

Mobile Compaction Skill

When to Compact

Compaction Strategies

1. Module-Level Compaction

2. Layer-Based Compaction

3. Build Variant Focus

4. Test Isolation

5. Pattern-Based Compaction

Compaction Levels

What Gets Preserved

Always Preserve (Critical)

Usually Preserve (Important)

Summarize (Compressible)

Drop (Disposable)

Compaction Commands

Basic Compaction

Smart Compaction

Manual Compaction

Compaction Workflow

Before Compaction

After Compaction

Integration

With Checkpoints

With Memory

With Instincts

Anti-Patterns

Don't Compact When:

Do Compact When:

Recovery

Examples

Example 1: Feature Development

Example 2: Test Fixing

Example 3: Compose Optimization