How to use the Android AppFunctions Builder agent skill

What is an agent skill and what does this one do?

An agent skill is a folder of instructions and reference files that an AI agent loads when your request matches the skill's purpose. This skill is published by Google LLC under the Apache-2.0 licence, and its entry point is a SKILL.md file.

The skill works through four steps. It discovers candidate workflows in your codebase, generates Kotlin implementations with the androidx.appfunctions library, refines the KDoc and app description so agents know when to call each function, and gives you ADB commands to test and debug the functions on a device.

• Discovery: finds user workflows worth exposing, and explains why an AI assistant would add value.
• Implementation and configuration: writes Kotlin AppFunctions and sets up build dependencies.
• KDoc refinement: rewrites function documentation and the app description for agents.
• Testing and debugging: lists, invokes and verifies registered functions over ADB.

Install the appfunctions skill

Download the skill ZIP from this page and unzip it. To make it available to every project on your machine, place the folder in ~/.claude/skills/. To limit it to one project, place it in that project's .claude/skills/ folder.

You can also upload the skill in the Claude apps. Open Settings, go to Capabilities, then choose Skills and upload the ZIP.

• Personal install: ~/.claude/skills/
• Project install: .claude/skills/ inside your Android project
• Claude apps: Settings → Capabilities → Skills

Check your app meets the requirements

AppFunctions is part of the Android platform API from Android 16 onwards, so your app must target targetSdk 36 or newer and compile against compileSdk 37 or newer. The skill always uses the Jetpack library, because it handles backward compatibility.

You need the androidx.appfunctions:appfunctions library and the androidx.appfunctions:appfunctions-compiler KSP compiler at version 1.0.0-beta01 or later. Your build must use Gradle with the KSP compiler plugin. For testing you need an Android device or emulator with ADB available.

• targetSdk 36 or newer
• compileSdk 37 or newer
• androidx.appfunctions:appfunctions and androidx.appfunctions:appfunctions-compiler, 1.0.0-beta01 or later
• Gradle with the KSP compiler plugin
• Android device or emulator with ADB

Trigger the skill with natural requests

You do not need special syntax. Describe what you want in plain language and mention your app. The skill is designed to respond to requests such as discovering, implementing, documenting, testing or upgrading AppFunctions.

If you want only part of the work, ask for that step. The skill then runs the steps you asked for, plus any step the critical constraints require, and lists the skipped steps and asks whether to run them.

• "Discover AppFunctions in my app" or "find features for AI" runs discovery.
• "Implement AppFunctions for note creation" runs implementation and configuration.
• "Write KDoc for my AppFunctions" or "optimize for MCP" runs KDoc refinement.
• "List app functions on my device" or "invoke an app function" runs testing with ADB.
• "Migrate my AppFunctions to 1.0.0-beta01" loads the migration reference.

Test and debug functions with ADB

To see which app functions are registered on a connected device or emulator, list them in JSON format. To narrow the output to one app, pipe it to grep with your package name. Before invoking any function, the agent reads its description field, because it often contains usage constraints and ordering rules.

• List all functions: adb shell cmd app_function list-app-functions
• Filter by package: pipe the output to grep and use your package_name

Migrate older AppFunctions code

If your project uses AppFunctions 1.0.0-alpha09 or lower, or legacy @AppFunction annotations, AppFunctionConfiguration.Provider implementations or appfn:description attributes, the migration reference moves it to the AppFunctionServiceEntryPoint architecture from 1.0.0-alpha10 and upgrades it to 1.0.0-beta01. The skill asks you before it migrates legacy code.

• Legacy manual provider API: alpha09 and earlier, with AppFunctionConfiguration.Provider on the Application class.
• Modern API: @AppFunctionServiceEntryPoint on a wrapper service that extends AppFunctionService.

Safety notes: scripts and network

This skill does not run scripts and does not use the network, according to its listing. The skill sets its own limits: it exposes only safe, non-destructive tasks that the app's UI already offers on that form factor, and it never asks for or returns passwords, financial details, private keys or other highly sensitive personal information.

Review the generated Kotlin before you ship it. The skill is limited to app-side exposure, so it does not build an agent that calls AppFunctions, and it does not cover remote MCP servers.

• Runs scripts: no
• Uses network: no
• Excluded: payments, passwords, account deletion and other destructive or sensitive actions
• Excluded: building agents that call AppFunctions