AutoGineer
Generated banner for Firebase Remote Config Basics
Generated logo for Firebase Remote Config Basics

Firebase Remote Config Basics

Firebase (Google)OfficialCreated by Google LLCDistributed by Firebase (Google)

  • Skill
  • Tool integration
  • Software development
  • Apache-2.0
  • Low risk
Download ZIP

From the author

Manages Firebase Remote Config templates, feature flags, loading strategies, and SDKs (Android, iOS). Use when downloading/deploying remoteconfig JSON templates, managing version history/feature flags, setting in-app defaults, fetchAndActivate(), real-time listeners, or SDK setup. Don't use for Firebase Hosting, Auth, Firestore, Data Connect, Crashlytics, or App Hosting.
— the description by Google LLC

AutoGineer summary

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

This skill provides a comprehensive guide for implementing and managing Firebase Remote Config. It covers the end-to-end process of setting up the SDK in Android and iOS applications, defining in-app default values, and managing cloud-based configuration templates via the Firebase CLI. The skill emphasizes safe deployment practices, including template auditing, version control, and verification steps to ensure app behavior can be updated dynamically without requiring new app store releases.

What it does

  • Guides SDK setup for Android and iOS applications.
  • Provides CLI commands to download, edit, and deploy Remote Config JSON templates.
  • Explains how to define and initialize in-app default configuration values.
  • Details fetching and activation strategies for dynamic app updates.
  • Supports version history tracking and management of feature flags.
  • Includes troubleshooting steps for common CLI and project context errors.

When to use it

  • When you need to change app behavior or appearance without publishing a new app update.
  • When implementing feature flags to control the rollout of new functionality.
  • When you need to manage and version-control your app's configuration templates.
  • When setting up baseline configuration values for offline app functionality.
  • When integrating real-time configuration updates into your mobile application.

Advantages

  • Enables dynamic app updates without requiring user-side app store updates.
  • Provides a structured approach to versioning and auditing configuration changes.
  • Supports platform-specific implementation patterns for Android and iOS.
  • Promotes safe deployment workflows through mandatory review and verification steps.
  • Optimizes performance by utilizing background fetching and real-time listeners.

Usage examples

“Download my current Firebase Remote Config template to a file.”
The agent executes the CLI command to fetch the active template and saves it as a local JSON file for review.
“How do I set up Remote Config defaults in my Android app?”
The agent provides the XML structure for defaults and the Kotlin code required to initialize them within the application.
“Deploy my updated remote_config.json file to Firebase.”
The agent verifies the configuration mapping, performs the deployment, and checks the version history to confirm the update.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/firebase/firebase-remote-config-basics/download

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

    mkdir -p .agents/skills && unzip firebase-remote-config-basics.zip -d .agents/skills

Documentation by Google LLC

Remote Config

This skill provides a complete guide for getting started with Remote Config on Android or iOS. Remote Config allows you to change the behavior and appearance of your app without publishing an app update by maintaining a cloud-based configuration template.

Prerequisites

Provisioning Remote Config requires both a Firebase project and a Firebase app, either Android or iOS. To manage the Remote Config template and conditions via the command line, use the Firebase CLI. See the firebase-basics skill for references on project initialization.

Troubleshooting Execution

Handling npx 403 Forbidden Errors

If npx -y firebase-tools@latest fails due to registry permissions (403 error):

  1. Inform the user: "I am unable to fetch the latest Firebase tools via npx due to a registry error."

  2. Fallback: Attempt to use the local firebase command directly if the user confirms it is installed globally (npm install -g firebase-tools).

Handling Project Context Issues

If a command fails because "no active project is selected":

  1. Check login: Run npx -y firebase-tools@latest login:list.

  2. Prompt for ID: If logged in but no project is active, ask the user: "Please provide your Firebase Project ID to proceed."

  3. Use Flag: Append --project <PROJECT_ID> to every subsequent command.

SDK Setup

To learn how to set up Remote Config in your application code, choose your platform:

Best Practices and Template Management

Follow these guidelines and use the associated CLI tools to ensure efficient and safe use of Remote Config.

Fetching Strategies

To optimize app performance and user experience, follow these recommended patterns (see Loading Strategies):

  • Load new values for next startup: The most effective pattern is to activate previously fetched values immediately on startup and fetch new values in the background to be used next time. This minimizes user wait time.

  • Real-time Updates: Use the SDK's real-time listener to update the app instantly without a refresh when server-side configuration changes.

Template Management via CLI

Use the following commands to manage your Remote Config template and version history through the terminal:

  • Get current template: Save the remote template to a local JSON file for auditing or modification.

    npx -y firebase-tools@latest remoteconfig:get -o remote_config.json

  • Autonomous Editing & Discovery : Modify the local remote_config.json directly. Determine the correct signal (e.g., device.country or percent) and update the "conditions" array and "parameters" map accordingly.

  • MANDATORY: User Review and Verification : STOP and ask the user to verify your changes before proceeding to deployment.

    • Action: Inform the user: "I have prepared the changes in remote_config.json. Please review the file for accuracy. Once you are satisfied, tell me to 'deploy' to make the changes live."

  • Deployment Orchestration : To push changes, you must ensure the environment is configured for deployment.

    • Config Mapping: If a firebase.json file is missing, create one to map the local JSON to the Remote Config service:

      { "remoteconfig": { "template": "remote_config.json" } }

    • Deploy: Execute the partial deployment command

      npx -y firebase-tools@latest deploy --only remoteconfig

  • Verification: After deployment, verify the update by listing the version history.

    npx -y firebase-tools@latest remoteconfig:versions:list

The SDK provides a number of features to make your application dynamic and responsive to user segments.

  • Set In-App Defaults: Define baseline values to ensure the app functions offline or before the first fetch.

  • Fetch and Activate: Retrieve values from the Firebase backend and apply them to the local UI/Logic.

  • Template Management: Use the Firebase CLI to version-control, get, and deploy your config JSON files.

Files

references/android_setup.md

Firebase Remote Config - Android Setup Guide (Kotlin)

This guide describes the SDK setup and basic usage patterns for Firebase Remote Config in an Android app using Kotlin DSL (build.gradle.kts) and Kotlin code.

Prerequisites

IMPORTANT: Before specifically working with Firebase Remote Config, make sure to use the skill and reference firebase_basics/references/android_setup to ensure the following is done.

  • The Firebase CLI is available and authenticated.

  • An Android project exists and is registered with a Firebase Project.

  • The Android project has a Firebase config file (google-services.json) and the Google services Gradle plugin (google-services).

1. Add dependencies to Gradle build files

[!IMPORTANT] [AGENT] RESOLVING THE SDK VERSION DETERMINISTICALLY Never guess or hardcode a memorized out-of-date SDK or plugin version. Before adding dependencies, you MUST query the latest available versions directly from the Google Maven Repository:

# Find the latest Firebase Android BoM version
curl -s https://dl.google.com/dl/android/maven2/com/google/firebase/firebase-bom/maven-metadata.xml | grep -oE '<latest>[^<]+' | cut -d'>' -f2

# Find the latest firebase-config version
curl -s https://dl.google.com/dl/android/maven2/com/google/firebase/firebase-config/maven-metadata.xml | grep -oE '<latest>[^<]+' | cut -d'>' -f2

If the dependency is already declared, fetch the exact resolved version currently active in the workspace's build graph:

./gradlew -q :app:dependencyInsight --dependency firebase-config --configuration releaseRuntimeClasspath

These changes are made to the Android project's Gradle files.

Google Analytics for Firebase is highly recommended as it enables conditional targeting based on user properties and audiences. Additional manual setup for Google Analytics is required (see "Before you begin" in https://firebase.google.com/docs/analytics/android/get-started.md.txt)

In the module (app-level) build.gradle.kts (usually <project>/<app-module>/build.gradle.kts), add the dependencies for Firebase Remote Config and Google Analytics:

dependencies {
    // [AGENT] Fetch the latest resolved version using the Gradle command above
    implementation(platform("com.google.firebase:firebase-bom:<latest_bom_version>"))

    // Add the dependencies for the Firebase Remote Config and Analytics libraries
    // When using the BoM, don't specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-config")
    implementation("com.google.firebase:firebase-analytics")
}

2. Set in-app defaults

  1. Define default values so the app has functional logic before it ever fetches a template from the server. Create an XML file (e.g., res/xml/remote_config_defaults.xml):

    <?xml version="1.0" encoding="utf-8"?>
<!-- Example Remote Config Defaults File -->
<defaultsMap>
    <entry>
        <key>welcome_message</key>
        <value>Welcome to the app!</value>
    </entry>
    <entry>
        <key>is_feature_enabled</key>
        <value>false</value>
    </entry>
</defaultsMap>

  2. Initialize the SDK in the Activity or Application class:

    val remoteConfig = Firebase.remoteConfig
remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)

3. Fetch and activate values

To apply values from the cloud, fetch them and then activate them in the app:

remoteConfig.fetchAndActivate()
    .addOnCompleteListener(this) { task ->
        if (task.isSuccessful) {
            val updated = task.result
            println("Config params updated: $updated")
        } else {
            println("Fetch failed")
        }
        // Access a value
        val message = remoteConfig.getString("welcome_message")
    }

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

The author says: This skill is best used with the Firebase CLI, but does not require it. Firebase CLI can be accessed through `npx -y firebase-tools@latest`.

Security

What our scanner noticed· Low risk

  • Instructions that use the network

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
Firebase (Google) (Official)
Distributed by
Firebase (Google)
Source
firebase/agent-skills · skills/firebase-remote-config-basics · commit b76be96
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

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

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download firebase-remote-config-basics.zip