AutoGineer
Generated banner for R8 Analyzer
Generated logo for R8 Analyzer

R8 Analyzer

Android (Google)OfficialCreated by Google LLCDistributed by Android (Google)

  • Skill
  • Review and audit
  • Software development
  • Apache-2.0
  • Low risk
  • Has scripts
Download ZIP

From the author

Analyzes Android build files and R8 keep rules to identify redundancies, broad package-wide rules, and rules that subsume library consumer keep rules. Use this skill when developers want to optimize their Android app's size, remove redundant or overly broad keep rules, or troubleshoot ProGuard configurations. Don't use for general Gradle build errors, Compose UI performance, or runtime CPU profiling.
— the description by Google LLC

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The r8-analyzer skill provides a structured approach to auditing Android ProGuard and R8 keep rules. By analyzing build configurations and generating reports on rule impact, it helps developers identify redundant or overly broad rules that negatively affect app size and obfuscation efficiency. The skill supports both modern AGP 9.3+ workflows via standalone tasks and legacy configurations through temporary R8 version updates, ensuring comprehensive coverage for various project setups.

What it does

  • Identifies redundant or overly broad R8 keep rules.
  • Detects rules that subsume library consumer keep rules.
  • Generates impact metrics and scores for existing keep rules.
  • Validates build configuration settings for optimal R8 usage.
  • Provides actionable remediation guidance based on rule patterns.
  • Supports automated report generation for release build variants.

When to use it

  • When you need to reduce the final size of your Android application.
  • When troubleshooting unexpected behavior in ProGuard or R8 configurations.
  • When you suspect that your keep rules are too broad or redundant.
  • When auditing library dependencies for inefficient keep rule declarations.

Advantages

  • Provides quantitative impact metrics for specific keep rules.
  • Automates the extraction and analysis of complex R8 configuration data.
  • Offers clear, standardized reporting formats for build optimizations.
  • Helps maintain cleaner and more efficient ProGuard configuration files.

Usage examples

“Analyze my app's R8 configuration to find redundant keep rules.”
The agent will inspect your build files, run the appropriate R8 analysis task, and generate a report detailing high-impact and redundant rules.
“Why is my Android app size larger than expected? Check my keep rules.”
The agent will perform a deep dive into your R8 rules to identify if overly broad rules are preventing effective code shrinking.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/android/r8-analyzer/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip r8-analyzer.zip -d .agents/skills

Documentation by Google LLC

Step 1. Setup and configuration check

  • Inspect build.gradle, build.gradle.kts, and gradle.properties.

  • Use references/CONFIGURATION.md to identify missing optimizations.

  • AGP : If the version is lower than 9.3, suggest migration to 9.3 for the simplified optimization {} DSL and the Configuration Analyzer task.

  • Full mode : Verify android.enableR8.fullMode=false is removed from the gradle.properties file.

Step 2. Analysis path selection

  • Inspect build.gradle, build.gradle.kts, settings.gradle, settings.gradle.kts, gradle.properties, and libs.versions.toml to get the AGP and R8 versions. An R8 version pinned in settings.gradle(.kts) replaces the R8 bundled with AGP.

  • Find the app module (usually app) and a build variant with R8 enabled (usually release). The following commands use them as <module> and <Variant>, for example :app:minifyReleaseWithR8.

  • The helper scripts are in this skill's scripts/ directory. In the following commands, <skill_dir> is this skill's directory. Run every command from the project root.

  • If AGP >= 9.3.0 : Proceed to Path A (Standalone Task).

  • If AGP < 9.3.0 : Proceed to Path B (Quantitative).

Path A: Standalone Gradle task (AGP >= 9.3.0)

  • Step 1: Check requirements : Python and the protobuf package 6.33.4 or later are mandatory (used by scripts/keep_radius_pb2.py). Install it with pip install "protobuf>=6.33.4"; versions lower than 6.33.4 fail on import with a VersionError or ImportError.

  • Step 2: Run standalone task on R8-enabled build : For the module and variant you found during path selection, run ./gradlew :<module>:analyze<Variant>R8Config (for example, ./gradlew :app:analyzeReleaseR8Config). It generates the report in <module>/build/reports/r8/ (for example, app/build/reports/r8/r8-config-analyzer-release.pb). You must wait for this command to finish before proceeding.

  • Step 3: Convert to JSON : You must explicitly run the conversion script scripts/convert_pb_to_json.py as python3 <skill_dir>/scripts/convert_pb_to_json.py with arguments <module>/build/reports/r8 and tmp/keepradius/keepruleradius.json. Wait for this command to finish.

  • Step 4: Analyze : You must explicitly run the analysis script scripts/analyze.py by executing python3 <skill_dir>/scripts/analyze.py tmp/keepradius/keepruleradius.json. This outputs tmp/keepradius/analysis_result.txt. Wait for this command to finish.

Path B: Invoke R8 release build (AGP < 9.3.0)

  • Step 1: Check requirements : Python and the protobuf package 6.33.4 or later are mandatory: pip install "protobuf>=6.33.4".

  • Step 2: Generate and analyze : You must run the shell commands described in references/FULL_BUILD_CONFIG_ANALYZER.md to temporarily update the R8 version in settings.gradle(.kts) to 9.4.34 or later (so R8 generates the report), generate the proto report in tmp/r8analysis/, convert it to tmp/r8analysis/keepruleradius.json, analyze the result, and revert the temporary settings.gradle(.kts) change.

  • Step 3: Analyze : Verify that the analysis outputs tmp/r8analysis/analysis_result.txt for scores and rule impact metrics.

Step 3. Report generation

  • Format : Follow references/REPORT_FORMAT.md strictly.

  • Redundant rules : Check keep rules against references/INSPECT-RULES.md. If a keep rule matches a pattern in references/INSPECT-RULES.md, include the guidance and remediation from that reference alongside the impact metrics.

  • Input : Extract metrics (Scores, Impacts, Example Classes, rule origins) directly from the generated file tmp/keepradius/analysis_result.txt if using Path A, or tmp/r8analysis/analysis_result.txt if using Path B.

  • Output : Short progress updates are fine while Gradle runs; the final message is the report only. Output only the raw Markdown report in the chat. Do not output conversational filler (for example, "Here is your report..."). Do not provide recommendations, next steps, or any other text outside of the sections defined in references/REPORT_FORMAT.md. Do not mention the path used for analysis of the configuration.

Constraints

  • Strict output limit: The final output must strictly be the Markdown report and nothing else.

  • No code changes : Research and suggest only; do not modify project files. Create files only under tmp/ (analysis output, the settings backup, and any scratch scripts), and never write the report to a file. The one exception is the temporary R8 classpath in settings.gradle(.kts) that Path B needs when the project doesn't already pin R8 9.4.34 or later: ask the user first when running interactively, and revert it after the analysis (see references/FULL_BUILD_CONFIG_ANALYZER.md). If that change is needed but the user says no, or asks you not to edit build files, report rule-level and build file findings without scores and say why.

  • No placeholder scores : Never print N/A% as a score.

  • No redundancy: Do not explain R8 benefits or reference skill internal files in the report.

  • Focus: Omit sections (for example, Subsumed Rules, Configuration) if no issues or items are found.

Files

references/REPORT_FORMAT.md

1. Configuration

(Optional section for the report, omit if no relevant findings are present.)

  • AGP version: [Current] -> Upgrade to 9.3.

  • Full mode : Not enabled. Remove android.enableR8.fullMode=false from gradle.properties.

  • Optimized resource shrinking : If AGP is 8.12 or 8.13, add android.r8.optimizedResourceShrinking=true to gradle.properties. From AGP 9.0 it's on by default.

  • Default ProGuard file : Use getDefaultProguardFile("proguard-android-optimize.txt") instead of proguard-android.txt.

2. Global disable rules

(Optional section for the report, omit if no relevant findings are present.)

  • [Rule]: Disables R8 globally. Action : Remove. If the rule has in_app_files: false in globals in analysis_result.txt, use the library action from Section 4 instead.

If there is -dontobfuscate, -dontoptimize, -dontshrink, or a negated keep rule using the ! inversion operator (for example, -keep class !com.example.** { *; }, which matches every class except that package across the app and libraries) in the codebase, mention in this section or Section 4 and recommend removing the rule or replacing it with narrow rules for specific classes.

3. Optimization summary

  • Optimization score: [X]% code is available for R8 optimizations (for example, inlining, merging). [100-X]% of codebase can't be optimized by R8.

  • Shrinking score: [X]% of code will be optimized by R8 by removing unused classes, fields, and methods. [100-X]% of codebase contains redundant classes, fields, and methods that can't be removed by R8.

  • Obfuscation score: [X]% of the codebase is available for R8 to obfuscate.

Increasing these scores increases the codebase available to R8 for optimizations.

If the scores couldn't be measured (for example, the user declined the temporary settings.gradle(.kts) change), replace this section with one line that says so and why. Never print N/A% as a score.

4. Keep rules evaluation

[Rule text]

  • Source : [file:line for a rule in the app's own files; otherwise the from value in analysis_result.txt (library or AGP defaults)]

  • Keeps: [X] items or [X] % of the codebase from optimization. Classes: [X], Fields: [X], Methods: [X] are prevented from optimization due to this keep rule.

  • Kept items summary: [Provide a brief summary or description of the items being kept, for example, "Models and DTOs in the network layer" instead of just listing raw class names]

  • Guidance : (Include if the rule matches a pattern in references/INSPECT-RULES.md) [Explanation and remediation from references/INSPECT-RULES.md]

  • Action : For a rule in the app's own files (in_app_files: true in analysis_result.txt): Remove (Library or default config bundles rules, or negated ! rule) OR Refine (Too broad, replace with narrow rules for specific classes: [Surgical Rule]). For any other rule (in_app_files: false; from names the library, AGP defaults, or build-generated rules): From [library] / AGP defaults. Not editable in this project; to reduce this rule's impact, report it to the library owner with these numbers.

5. Subsumed keep rules

(Optional section for the report, omit if no relevant findings are present.)

[Redundant rules]

  • Subsumed by: [Broader Rule]

  • Action : Remove if Section 4 keeps [Broader Rule] as is. If Section 4 recommends removing or refining [Broader Rule], write instead: Covered only while [Broader Rule] stays.

List only subsumed rules in the app's own files (in_app_files: true); leave out library and AGP default rules. Suggest removing a subsumed rule only if the rule that subsumes it stays as is.

Rules in identical_rules keep exactly the same items as the rules in their identical_to. Label them Identical to [rule], not Subsumed by. If one of the identical rules comes from a library or AGP defaults, it stays, so recommend removing the app's copy; if all of them are in the app's own files, keep one and remove the others.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python

Security

What our scanner noticed· Low risk

  • Instructions that use the network
  • Scripts that your agent may run

This skill includes scripts that your agent may run. Read them before you use it.

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Google LLC
Publisher
Android (Google) (Official)
Distributed by
Android (Google)
Source
android/skills · performance/r8-analyzer · commit bf68e2d
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE.txt)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Google LLC or Android (Google).

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download r8-analyzer.zip