diff --git a/tools/aconfig/aconfig/src/codegen/rust.rs b/tools/aconfig/aconfig/src/codegen/rust.rs
index 569a34b..82a6ebc 100644
--- a/tools/aconfig/aconfig/src/codegen/rust.rs
+++ b/tools/aconfig/aconfig/src/codegen/rust.rs
@@ -259,10 +259,6 @@
 /// flag provider
 pub struct FlagProvider;
 
-static READ_FROM_NEW_STORAGE: LazyLock<bool> = LazyLock::new(|| unsafe {
-    Path::new("/metadata/aconfig/boot/enable_only_new_storage").exists()
-});
-
 static PACKAGE_OFFSET: LazyLock<Result<Option<u32>, AconfigStorageError>> = LazyLock::new(|| unsafe {
     get_mapped_storage_file("system", StorageFileType::PackageMap)
     .and_then(|package_map| get_package_read_context(&package_map, "com.android.aconfig.test"))
@@ -275,54 +271,46 @@
 
 /// flag value cache for disabled_rw
 static CACHED_disabled_rw: LazyLock<bool> = LazyLock::new(|| {
-    if *READ_FROM_NEW_STORAGE {
-        // This will be called multiple times. Subsequent calls after the first are noops.
-        logger::init(
-            logger::Config::default()
-                .with_tag_on_device("aconfig_rust_codegen")
-                .with_max_level(LevelFilter::Info));
+    // This will be called multiple times. Subsequent calls after the first are noops.
+    logger::init(
+        logger::Config::default()
+            .with_tag_on_device("aconfig_rust_codegen")
+            .with_max_level(LevelFilter::Info));
 
-        let flag_value_result = FLAG_VAL_MAP
-            .as_ref()
-            .map_err(|err| format!("failed to get flag val map: {err}"))
-            .and_then(|flag_val_map| {
-                PACKAGE_OFFSET
-                    .as_ref()
-                    .map_err(|err| format!("failed to get package read offset: {err}"))
-                    .and_then(|package_offset| {
-                        match package_offset {
-                            Some(offset) => {
-                                get_boolean_flag_value(&flag_val_map, offset + 1)
-                                    .map_err(|err| format!("failed to get flag: {err}"))
-                            },
-                            None => {
-                                log!(Level::Error, "no context found for package com.android.aconfig.test");
-                                Err(format!("failed to flag package com.android.aconfig.test"))
-                            }
-                        }
-                    })
-                });
+    let flag_value_result = FLAG_VAL_MAP
+        .as_ref()
+        .map_err(|err| format!("failed to get flag val map: {err}"))
+        .and_then(|flag_val_map| {
+            PACKAGE_OFFSET
+               .as_ref()
+               .map_err(|err| format!("failed to get package read offset: {err}"))
+               .and_then(|package_offset| {
+                   match package_offset {
+                       Some(offset) => {
+                           get_boolean_flag_value(&flag_val_map, offset + 1)
+                               .map_err(|err| format!("failed to get flag: {err}"))
+                       },
+                       None => {
+                           log!(Level::Error, "no context found for package com.android.aconfig.test");
+                           Err(format!("failed to flag package com.android.aconfig.test"))
+                       }
+                    }
+                })
+            });
 
-        match flag_value_result {
-            Ok(flag_value) => {
-                 return flag_value;
-            },
-            Err(err) => {
-                log!(Level::Error, "aconfig_rust_codegen: error: {err}");
-                return false;
-            }
+    match flag_value_result {
+        Ok(flag_value) => {
+            return flag_value;
+        },
+        Err(err) => {
+            log!(Level::Error, "aconfig_rust_codegen: error: {err}");
+            return false;
         }
-    } else {
-        flags_rust::GetServerConfigurableFlag(
-            "aconfig_flags.aconfig_test",
-            "com.android.aconfig.test.disabled_rw",
-            "false") == "true"
     }
 });
 
 /// flag value cache for disabled_rw_exported
 static CACHED_disabled_rw_exported: LazyLock<bool> = LazyLock::new(|| {
-    if *READ_FROM_NEW_STORAGE {
         // This will be called multiple times. Subsequent calls after the first are noops.
         logger::init(
             logger::Config::default()
@@ -359,17 +347,10 @@
                 return false;
             }
         }
-    } else {
-        flags_rust::GetServerConfigurableFlag(
-            "aconfig_flags.aconfig_test",
-            "com.android.aconfig.test.disabled_rw_exported",
-            "false") == "true"
-    }
 });
 
 /// flag value cache for disabled_rw_in_other_namespace
 static CACHED_disabled_rw_in_other_namespace: LazyLock<bool> = LazyLock::new(|| {
-    if *READ_FROM_NEW_STORAGE {
         // This will be called multiple times. Subsequent calls after the first are noops.
         logger::init(
             logger::Config::default()
@@ -406,18 +387,11 @@
                 return false;
             }
         }
-    } else {
-        flags_rust::GetServerConfigurableFlag(
-            "aconfig_flags.other_namespace",
-            "com.android.aconfig.test.disabled_rw_in_other_namespace",
-            "false") == "true"
-    }
 });
 
 
 /// flag value cache for enabled_rw
 static CACHED_enabled_rw: LazyLock<bool> = LazyLock::new(|| {
-    if *READ_FROM_NEW_STORAGE {
         // This will be called multiple times. Subsequent calls after the first are noops.
         logger::init(
             logger::Config::default()
@@ -454,12 +428,6 @@
                 return true;
             }
         }
-    } else {
-        flags_rust::GetServerConfigurableFlag(
-            "aconfig_flags.aconfig_test",
-            "com.android.aconfig.test.enabled_rw",
-            "true") == "true"
-    }
 });
 
 impl FlagProvider {
diff --git a/tools/aconfig/aconfig/templates/cpp_source_file.template b/tools/aconfig/aconfig/templates/cpp_source_file.template
index df3b10d..9be59e0 100644
--- a/tools/aconfig/aconfig/templates/cpp_source_file.template
+++ b/tools/aconfig/aconfig/templates/cpp_source_file.template
@@ -76,17 +76,8 @@
             : boolean_start_index_()
             {{ -endif }}
             , flag_value_file_(nullptr)
-            , read_from_new_storage_(false)
             , package_exists_in_storage_(true) \{
 
-            if (access("/metadata/aconfig/boot/enable_only_new_storage", F_OK) == 0) \{
-               read_from_new_storage_ = true;
-            }
-
-            if (!read_from_new_storage_) \{
-               return;
-            }
-
             auto package_map_file = aconfig_storage::get_mapped_file(
                  "{container}",
                  aconfig_storage::StorageFileType::package_map);
@@ -137,26 +128,19 @@
             {{ -if item.readwrite }}
             if (cache_[{item.readwrite_idx}] == -1) \{
             {{ if allow_instrumentation- }}
-                if (read_from_new_storage_) \{
-                    if (!package_exists_in_storage_) \{
-                       return {item.default_value};
-                    }
-
-                    auto value = aconfig_storage::get_boolean_flag_value(
-                        *flag_value_file_,
-                        boolean_start_index_ + {item.flag_offset});
-
-                    if (!value.ok()) \{
-                        ALOGE("error: failed to read flag value: %s", value.error().c_str());
-                    }
-
-                    cache_[{item.readwrite_idx}] = *value;
-                } else \{
-                    cache_[{item.readwrite_idx}] = server_configurable_flags::GetServerConfigurableFlag(
-                        "aconfig_flags.{item.device_config_namespace}",
-                        "{item.device_config_flag}",
-                        "{item.default_value}") == "true";
+                if (!package_exists_in_storage_) \{
+                    return {item.default_value};
                 }
+
+                auto value = aconfig_storage::get_boolean_flag_value(
+                    *flag_value_file_,
+                    boolean_start_index_ + {item.flag_offset});
+
+                if (!value.ok()) \{
+                    ALOGE("error: failed to read flag value: %s", value.error().c_str());
+                }
+
+                cache_[{item.readwrite_idx}] = *value;
             {{ -else- }}
                 cache_[{item.readwrite_idx}] = server_configurable_flags::GetServerConfigurableFlag(
                     "aconfig_flags.{item.device_config_namespace}",
@@ -183,8 +167,6 @@
 
         std::unique_ptr<aconfig_storage::MappedStorageFile> flag_value_file_;
 
-        bool read_from_new_storage_;
-
         bool package_exists_in_storage_;
     {{ -endif }}
     {{ -endif }}
diff --git a/tools/aconfig/aconfig/templates/rust.template b/tools/aconfig/aconfig/templates/rust.template
index d0079d4..e9e1032 100644
--- a/tools/aconfig/aconfig/templates/rust.template
+++ b/tools/aconfig/aconfig/templates/rust.template
@@ -10,10 +10,6 @@
 
 {{ if has_readwrite- }}
 {{ if allow_instrumentation }}
-static READ_FROM_NEW_STORAGE: LazyLock<bool> = LazyLock::new(|| unsafe \{
-    Path::new("/metadata/aconfig/boot/enable_only_new_storage").exists()
-});
-
 static PACKAGE_OFFSET: LazyLock<Result<Option<u32>, AconfigStorageError>> = LazyLock::new(|| unsafe \{
     get_mapped_storage_file("{container}", StorageFileType::PackageMap)
     .and_then(|package_map| get_package_read_context(&package_map, "{package}"))
@@ -31,48 +27,41 @@
 {{ if allow_instrumentation }}
 static CACHED_{flag.name}: LazyLock<bool> = LazyLock::new(|| \{
 
-    if *READ_FROM_NEW_STORAGE \{
-        // This will be called multiple times. Subsequent calls after the first are noops.
-        logger::init(
-            logger::Config::default()
-                .with_tag_on_device("aconfig_rust_codegen")
-                .with_max_level(LevelFilter::Info));
+    // This will be called multiple times. Subsequent calls after the first are noops.
+    logger::init(
+        logger::Config::default()
+            .with_tag_on_device("aconfig_rust_codegen")
+            .with_max_level(LevelFilter::Info));
 
-        let flag_value_result = FLAG_VAL_MAP
-            .as_ref()
-            .map_err(|err| format!("failed to get flag val map: \{err}"))
-            .and_then(|flag_val_map| \{
-                PACKAGE_OFFSET
-                    .as_ref()
-                    .map_err(|err| format!("failed to get package read offset: \{err}"))
-                    .and_then(|package_offset| \{
-                        match package_offset \{
-                            Some(offset) => \{
-                                get_boolean_flag_value(&flag_val_map, offset + {flag.flag_offset})
-                                    .map_err(|err| format!("failed to get flag: \{err}"))
-                            },
-                            None => \{
-                                 log!(Level::Error, "no context found for package {package}");
-                                 Err(format!("failed to flag package {package}"))
-                            }
+    let flag_value_result = FLAG_VAL_MAP
+        .as_ref()
+        .map_err(|err| format!("failed to get flag val map: \{err}"))
+        .and_then(|flag_val_map| \{
+            PACKAGE_OFFSET
+                .as_ref()
+                .map_err(|err| format!("failed to get package read offset: \{err}"))
+                .and_then(|package_offset| \{
+                    match package_offset \{
+                        Some(offset) => \{
+                            get_boolean_flag_value(&flag_val_map, offset + {flag.flag_offset})
+                                .map_err(|err| format!("failed to get flag: \{err}"))
+                        },
+                        None => \{
+                            log!(Level::Error, "no context found for package {package}");
+                            Err(format!("failed to flag package {package}"))
                         }
-                    })
-                });
+                    }
+                })
+            });
 
-        match flag_value_result \{
-            Ok(flag_value) => \{
-                return flag_value;
-            },
-            Err(err) => \{
-                log!(Level::Error, "aconfig_rust_codegen: error: \{err}");
-                return {flag.default_value};
-            }
+    match flag_value_result \{
+        Ok(flag_value) => \{
+            return flag_value;
+        },
+        Err(err) => \{
+            log!(Level::Error, "aconfig_rust_codegen: error: \{err}");
+            return {flag.default_value};
         }
-    } else \{
-        flags_rust::GetServerConfigurableFlag(
-            "aconfig_flags.{flag.device_config_namespace}",
-            "{flag.device_config_flag}",
-            "{flag.default_value}") == "true"
     }
 
 });