diff --git a/CUSTOMIZATION_GUIDE.md b/CUSTOMIZATION_GUIDE.md
index 8e86881e7..9d2b4d16e 100644
--- a/CUSTOMIZATION_GUIDE.md
+++ b/CUSTOMIZATION_GUIDE.md
@@ -38,11 +38,7 @@ This document provides essential information on **configuring the rendering mode
   - When set to `false` or omitted, the default template is used.
   - The **default is `false`**.
 
-### 🔹 7. Updating Rendering Mode
-- Switching to `"standard"` **only updates the `rendering_mode`**.
-- All other fields remain unchanged.
-
-### 🔹 8. Partial Updates
+### 🔹 7. Partial Updates
 - Only **explicitly declared fields** are updated.
 - **Unspecified fields remain as they are**.
 
@@ -109,7 +105,6 @@ This document provides essential information on **configuring the rendering mode
 - **Use `"standard"` mode for creating a consistent, branded experience for users. Choosing Standard mode will open a webpage
   within your browser where you can edit and preview your branding changes.For a comprehensive list of editable parameters and their values
 - **Ensure `head_tags` includes at least one `<script>` tag** for proper functionality.
-- **When switching to `"standard"`, only update `rendering_mode`**—all other fields should remain unchanged.
 - **Use `context_configuration` values carefully** to avoid exposing sensitive data.
 - **Always validate your JSON** before applying changes to prevent syntax errors and unexpected behavior.
 
diff --git a/docs/auth0_acul.md b/docs/auth0_acul.md
new file mode 100644
index 000000000..c45bb9e92
--- /dev/null
+++ b/docs/auth0_acul.md
@@ -0,0 +1,16 @@
+---
+layout: default
+has_toc: false
+has_children: true
+---
+# auth0 acul
+
+Customize the Universal Login experience. This requires a custom domain to be configured for the tenant.
+
+## Commands
+
+- [auth0 acul config](auth0_acul_config.md) - Configure Advanced Customizations for Universal Login screens.
+- [auth0 acul dev](auth0_acul_dev.md) - Start development mode for ACUL project with automatic building and asset watching.
+- [auth0 acul init](auth0_acul_init.md) - Generate a new ACUL project from a template
+- [auth0 acul screen](auth0_acul_screen.md) - Manage individual screens for Advanced Customizations for Universal Login.
+
diff --git a/docs/auth0_acul_config.md b/docs/auth0_acul_config.md
new file mode 100644
index 000000000..a8e07fad5
--- /dev/null
+++ b/docs/auth0_acul_config.md
@@ -0,0 +1,17 @@
+---
+layout: default
+has_toc: false
+has_children: true
+---
+# auth0 acul config
+
+Manage screen-level configuration for Auth0 Universal Login using ACUL (Advanced Customizations).
+
+## Commands
+
+- [auth0 acul config docs](auth0_acul_config_docs.md) - Open the ACUL configuration documentation
+- [auth0 acul config generate](auth0_acul_config_generate.md) - Generate a stub config file for a Universal Login screen.
+- [auth0 acul config get](auth0_acul_config_get.md) - Get the current rendering settings for a specific screen
+- [auth0 acul config list](auth0_acul_config_list.md) - List Universal Login rendering configurations
+- [auth0 acul config set](auth0_acul_config_set.md) - Set the rendering settings for a specific screen
+
diff --git a/docs/auth0_acul_config_docs.md b/docs/auth0_acul_config_docs.md
new file mode 100644
index 000000000..1a7052803
--- /dev/null
+++ b/docs/auth0_acul_config_docs.md
@@ -0,0 +1,42 @@
+---
+layout: default
+parent: auth0 acul config
+has_toc: false
+---
+# auth0 acul config docs
+
+Open the documentation for configuring Advanced Customizations for Universal Login screens.
+
+## Usage
+```
+auth0 acul config docs [flags]
+```
+
+## Examples
+
+```
+  auth0 acul config docs
+```
+
+
+
+
+## Inherited Flags
+
+```
+      --debug           Enable debug mode.
+      --no-color        Disable colors.
+      --no-input        Disable interactivity.
+      --tenant string   Specific tenant to use.
+```
+
+
+## Related Commands
+
+- [auth0 acul config docs](auth0_acul_config_docs.md) - Open the ACUL configuration documentation
+- [auth0 acul config generate](auth0_acul_config_generate.md) - Generate a stub config file for a Universal Login screen.
+- [auth0 acul config get](auth0_acul_config_get.md) - Get the current rendering settings for a specific screen
+- [auth0 acul config list](auth0_acul_config_list.md) - List Universal Login rendering configurations
+- [auth0 acul config set](auth0_acul_config_set.md) - Set the rendering settings for a specific screen
+
+
diff --git a/docs/auth0_acul_config_generate.md b/docs/auth0_acul_config_generate.md
new file mode 100644
index 000000000..4b582e9a3
--- /dev/null
+++ b/docs/auth0_acul_config_generate.md
@@ -0,0 +1,51 @@
+---
+layout: default
+parent: auth0 acul config
+has_toc: false
+---
+# auth0 acul config generate
+
+Generate a stub config file for a Universal Login screen and save it to a file.
+If fileName is not provided, it will default to <screen-name>.json in the current directory.
+
+## Usage
+```
+auth0 acul config generate [flags]
+```
+
+## Examples
+
+```
+  auth0 acul config generate <screen-name>
+  auth0 acul config generate <screen-name> --file settings.json
+  auth0 acul config generate signup-id
+  auth0 acul config generate login-id --file login-settings.json
+```
+
+
+## Flags
+
+```
+  -f, --file string   File to save the rendering configs to.
+```
+
+
+## Inherited Flags
+
+```
+      --debug           Enable debug mode.
+      --no-color        Disable colors.
+      --no-input        Disable interactivity.
+      --tenant string   Specific tenant to use.
+```
+
+
+## Related Commands
+
+- [auth0 acul config docs](auth0_acul_config_docs.md) - Open the ACUL configuration documentation
+- [auth0 acul config generate](auth0_acul_config_generate.md) - Generate a stub config file for a Universal Login screen.
+- [auth0 acul config get](auth0_acul_config_get.md) - Get the current rendering settings for a specific screen
+- [auth0 acul config list](auth0_acul_config_list.md) - List Universal Login rendering configurations
+- [auth0 acul config set](auth0_acul_config_set.md) - Set the rendering settings for a specific screen
+
+
diff --git a/docs/auth0_acul_config_get.md b/docs/auth0_acul_config_get.md
new file mode 100644
index 000000000..8ee5c30af
--- /dev/null
+++ b/docs/auth0_acul_config_get.md
@@ -0,0 +1,50 @@
+---
+layout: default
+parent: auth0 acul config
+has_toc: false
+---
+# auth0 acul config get
+
+Get the current rendering settings for a specific screen.
+
+## Usage
+```
+auth0 acul config get [flags]
+```
+
+## Examples
+
+```
+  auth0 acul config get <screen-name>
+  auth0 acul config get <screen-name> --file settings.json
+  auth0 acul config get signup-id
+  auth0 acul config get login-id -f ./acul_config/login-id.json
+```
+
+
+## Flags
+
+```
+  -f, --file string   File to save the rendering configs to.
+```
+
+
+## Inherited Flags
+
+```
+      --debug           Enable debug mode.
+      --no-color        Disable colors.
+      --no-input        Disable interactivity.
+      --tenant string   Specific tenant to use.
+```
+
+
+## Related Commands
+
+- [auth0 acul config docs](auth0_acul_config_docs.md) - Open the ACUL configuration documentation
+- [auth0 acul config generate](auth0_acul_config_generate.md) - Generate a stub config file for a Universal Login screen.
+- [auth0 acul config get](auth0_acul_config_get.md) - Get the current rendering settings for a specific screen
+- [auth0 acul config list](auth0_acul_config_list.md) - List Universal Login rendering configurations
+- [auth0 acul config set](auth0_acul_config_set.md) - Set the rendering settings for a specific screen
+
+
diff --git a/docs/auth0_acul_config_list.md b/docs/auth0_acul_config_list.md
new file mode 100644
index 000000000..06c2387ca
--- /dev/null
+++ b/docs/auth0_acul_config_list.md
@@ -0,0 +1,58 @@
+---
+layout: default
+parent: auth0 acul config
+has_toc: false
+---
+# auth0 acul config list
+
+List Universal Login rendering configurations with optional filters and pagination.
+
+## Usage
+```
+auth0 acul config list [flags]
+```
+
+## Examples
+
+```
+  auth0 acul config list --prompt reset-password
+  auth0 acul config list --rendering-mode advanced --include-fields true --fields head_tags,context_configuration
+```
+
+
+## Flags
+
+```
+      --fields string           Comma-separated list of fields to include or exclude in the result (based on value provided for include_fields) 
+      --include-fields          Whether specified fields are to be included (true) or excluded (false). (default true)
+      --include-totals          Return results inside an object that contains the total result count (true) or as a direct array of results (false).
+      --json                    Output in json format.
+      --json-compact            Output in compact json format.
+      --page int                Page index of the results to return. First page is 0.
+      --per-page int            Number of results per page. Default value is 50, maximum value is 100. (default 50)
+      --prompt string           Filter by the Universal Login prompt.
+  -q, --query string            Advanced query.
+      --rendering-mode string   Filter by the rendering mode (advanced or standard).
+      --screen string           Filter by the Universal Login screen.
+```
+
+
+## Inherited Flags
+
+```
+      --debug           Enable debug mode.
+      --no-color        Disable colors.
+      --no-input        Disable interactivity.
+      --tenant string   Specific tenant to use.
+```
+
+
+## Related Commands
+
+- [auth0 acul config docs](auth0_acul_config_docs.md) - Open the ACUL configuration documentation
+- [auth0 acul config generate](auth0_acul_config_generate.md) - Generate a stub config file for a Universal Login screen.
+- [auth0 acul config get](auth0_acul_config_get.md) - Get the current rendering settings for a specific screen
+- [auth0 acul config list](auth0_acul_config_list.md) - List Universal Login rendering configurations
+- [auth0 acul config set](auth0_acul_config_set.md) - Set the rendering settings for a specific screen
+
+
diff --git a/docs/auth0_acul_config_set.md b/docs/auth0_acul_config_set.md
new file mode 100644
index 000000000..2d7a25e8b
--- /dev/null
+++ b/docs/auth0_acul_config_set.md
@@ -0,0 +1,50 @@
+---
+layout: default
+parent: auth0 acul config
+has_toc: false
+---
+# auth0 acul config set
+
+Set the rendering settings for a specific screen.
+
+## Usage
+```
+auth0 acul config set [flags]
+```
+
+## Examples
+
+```
+  auth0 acul config set <screen-name>
+  auth0 acul config set <screen-name> --file settings.json
+  auth0 acul config set signup-id --file settings.json
+  auth0 acul config set login-id
+```
+
+
+## Flags
+
+```
+  -f, --file string   File to save the rendering configs to.
+```
+
+
+## Inherited Flags
+
+```
+      --debug           Enable debug mode.
+      --no-color        Disable colors.
+      --no-input        Disable interactivity.
+      --tenant string   Specific tenant to use.
+```
+
+
+## Related Commands
+
+- [auth0 acul config docs](auth0_acul_config_docs.md) - Open the ACUL configuration documentation
+- [auth0 acul config generate](auth0_acul_config_generate.md) - Generate a stub config file for a Universal Login screen.
+- [auth0 acul config get](auth0_acul_config_get.md) - Get the current rendering settings for a specific screen
+- [auth0 acul config list](auth0_acul_config_list.md) - List Universal Login rendering configurations
+- [auth0 acul config set](auth0_acul_config_set.md) - Set the rendering settings for a specific screen
+
+
diff --git a/docs/auth0_acul_dev.md b/docs/auth0_acul_dev.md
new file mode 100644
index 000000000..51805520e
--- /dev/null
+++ b/docs/auth0_acul_dev.md
@@ -0,0 +1,78 @@
+---
+layout: default
+parent: auth0 acul
+has_toc: false
+---
+# auth0 acul dev
+
+Start development mode for an ACUL project. This command:
+- Runs 'npm run build' to build the project initially
+- Watches the dist directory for asset changes
+- Automatically patches screen assets when new builds are created
+- Supports both single screen development and all screens
+
+The project directory must contain package.json with a build script.
+
+DEV MODE (default):
+- Requires: --port flag for the local development server
+- Runs your build process (e.g., npm run screen <name>) for HMR development
+
+CONNECTED MODE (--connected):
+- Requires: --screens flag to specify screens to patch in Auth0 tenant  
+- Updates advance rendering settings of the chosen screens in your Auth0 tenant
+- Runs initial build and expects you to host assets locally
+- Optionally runs build:watch in the background for continuous asset updates
+- Watches and patches assets automatically when changes are detected
+
+⚠️  Connected mode should only be used on stage/dev tenants, not production!
+
+## Usage
+```
+auth0 acul dev [flags]
+```
+
+## Examples
+
+```
+  # Dev mode
+  auth0 acul dev --port 55444
+  auth0 acul dev -p 55444 --dir ./my_project
+  
+  # Connected mode
+  auth0 acul dev --connected
+  auth0 acul dev --connected --debug --dir ./my_project
+  auth0 acul dev --connected --screens all
+  auth0 acul dev -c --dir ./my_project
+  auth0 acul dev --connected --screens login-id
+  auth0 acul dev -c -s login-id,signup
+```
+
+
+## Flags
+
+```
+  -c, --connected         Enable connected mode to update advance rendering settings of Auth0 tenant. Use only on stage/dev tenants.
+  -d, --dir string        Path to the ACUL project directory (must contain package.json).
+  -p, --port string       Port for the local development server.
+  -s, --screens strings   Specific screens to develop and watch.
+```
+
+
+## Inherited Flags
+
+```
+      --debug           Enable debug mode.
+      --no-color        Disable colors.
+      --no-input        Disable interactivity.
+      --tenant string   Specific tenant to use.
+```
+
+
+## Related Commands
+
+- [auth0 acul config](auth0_acul_config.md) - Configure Advanced Customizations for Universal Login screens.
+- [auth0 acul dev](auth0_acul_dev.md) - Start development mode for ACUL project with automatic building and asset watching.
+- [auth0 acul init](auth0_acul_init.md) - Generate a new ACUL project from a template
+- [auth0 acul screen](auth0_acul_screen.md) - Manage individual screens for Advanced Customizations for Universal Login.
+
+
diff --git a/docs/auth0_acul_init.md b/docs/auth0_acul_init.md
new file mode 100644
index 000000000..875260f42
--- /dev/null
+++ b/docs/auth0_acul_init.md
@@ -0,0 +1,52 @@
+---
+layout: default
+parent: auth0 acul
+has_toc: false
+---
+# auth0 acul init
+
+Generate a new Advanced Customizations for Universal Login (ACUL) project from a template.
+This command creates a new project with your choice of framework and authentication screens (login, signup, mfa, etc.). 
+The generated project includes all necessary configuration and boilerplate code to get started with ACUL customizations.
+
+## Usage
+```
+auth0 acul init [flags]
+```
+
+## Examples
+
+```
+  auth0 acul init <app_name>
+  auth0 acul init acul-sample-app
+  auth0 acul init acul-sample-app --template react --screens login,signup
+  auth0 acul init acul-sample-app -t react -s login,mfa,signup
+```
+
+
+## Flags
+
+```
+  -s, --screens strings   Comma-separated list of screens to include in your ACUL project.
+  -t, --template string   Template framework to use for your ACUL project.
+```
+
+
+## Inherited Flags
+
+```
+      --debug           Enable debug mode.
+      --no-color        Disable colors.
+      --no-input        Disable interactivity.
+      --tenant string   Specific tenant to use.
+```
+
+
+## Related Commands
+
+- [auth0 acul config](auth0_acul_config.md) - Configure Advanced Customizations for Universal Login screens.
+- [auth0 acul dev](auth0_acul_dev.md) - Start development mode for ACUL project with automatic building and asset watching.
+- [auth0 acul init](auth0_acul_init.md) - Generate a new ACUL project from a template
+- [auth0 acul screen](auth0_acul_screen.md) - Manage individual screens for Advanced Customizations for Universal Login.
+
+
diff --git a/docs/auth0_acul_screen.md b/docs/auth0_acul_screen.md
new file mode 100644
index 000000000..8972361ea
--- /dev/null
+++ b/docs/auth0_acul_screen.md
@@ -0,0 +1,13 @@
+---
+layout: default
+has_toc: false
+has_children: true
+---
+# auth0 acul screen
+
+Manage individual screens for Auth0 Universal Login using ACUL (Advanced Customizations).
+
+## Commands
+
+- [auth0 acul screen add](auth0_acul_screen_add.md) - Add screens to an existing project
+
diff --git a/docs/auth0_acul_screen_add.md b/docs/auth0_acul_screen_add.md
new file mode 100644
index 000000000..b08d6c709
--- /dev/null
+++ b/docs/auth0_acul_screen_add.md
@@ -0,0 +1,44 @@
+---
+layout: default
+parent: auth0 acul screen
+has_toc: false
+---
+# auth0 acul screen add
+
+Add screens to an existing project. The project must have been initialized using `auth0 acul init`.
+
+## Usage
+```
+auth0 acul screen add [flags]
+```
+
+## Examples
+
+```
+  auth0 acul screen add <screen-name> <screen-name>... --dir <app-directory>
+  auth0 acul screen add login-id login-password -d acul_app
+```
+
+
+## Flags
+
+```
+  -d, --dir acul_config.json   Path to existing project directory (must contain acul_config.json)
+```
+
+
+## Inherited Flags
+
+```
+      --debug           Enable debug mode.
+      --no-color        Disable colors.
+      --no-input        Disable interactivity.
+      --tenant string   Specific tenant to use.
+```
+
+
+## Related Commands
+
+- [auth0 acul screen add](auth0_acul_screen_add.md) - Add screens to an existing project
+
+
diff --git a/docs/auth0_universal-login.md b/docs/auth0_universal-login.md
index 9440e021e..bc5d3e634 100644
--- a/docs/auth0_universal-login.md
+++ b/docs/auth0_universal-login.md
@@ -5,14 +5,23 @@ has_children: true
 ---
 # auth0 universal-login
 
-Manage a consistent, branded Universal Login experience that can handle all of your authentication flows.
+Manage Universal Login branding and customization settings.
+
+� DEPRECATION WARNING: Advanced Customizations (ACUL) have moved!
+
+The 'auth0 ul customize --rendering-mode advanced' functionality will be 
+DEPRECATED on June 15, 2026. Please migrate to the new ACUL commands:
+
+  ✅ auth0 acul config generate|get|set|list|docs
+
+Standard Universal Login customizations continue to work as before.
 
 ## Commands
 
-- [auth0 universal-login customize](auth0_universal-login_customize.md) - Customize the Universal Login experience for the standard or advanced mode
+- [auth0 universal-login customize](auth0_universal-login_customize.md) - ⚠️ Customize Universal Login (Advanced mode DEPRECATED)
 - [auth0 universal-login prompts](auth0_universal-login_prompts.md) - Manage custom text for prompts
 - [auth0 universal-login show](auth0_universal-login_show.md) - Display the custom branding settings for Universal Login
-- [auth0 universal-login switch](auth0_universal-login_switch.md) - Switch the rendering mode for Universal Login
+- [auth0 universal-login switch](auth0_universal-login_switch.md) - ⚠️ Switch rendering mode (DEPRECATED)
 - [auth0 universal-login templates](auth0_universal-login_templates.md) - Manage custom Universal Login templates
 - [auth0 universal-login update](auth0_universal-login_update.md) - Update the custom branding settings for Universal Login
 
diff --git a/docs/auth0_universal-login_customize.md b/docs/auth0_universal-login_customize.md
index 61c8f4995..7eac34983 100644
--- a/docs/auth0_universal-login_customize.md
+++ b/docs/auth0_universal-login_customize.md
@@ -6,18 +6,19 @@ has_toc: false
 # auth0 universal-login customize
 
 
-Customize your Universal Login Experience. Note that this requires a custom domain to be configured for the tenant. 
+Customize your Universal Login Experience. Note that this requires a custom domain to be configured for the tenant.
 
 * Standard mode is recommended for creating a consistent, branded experience for users. Choosing Standard mode will open a webpage
-within your browser where you can edit and preview your branding changes.For a comprehensive list of editable parameters and their values,
-please visit the [Management API Documentation](https://auth0.com/docs/api/management/v2)
+  in your browser where you can edit and preview your branding changes. For a comprehensive list of editable parameters and their values,
+  please visit the Management API documentation: https://auth0.com/docs/api/management/v2
 
-* Advanced mode is recommended for full customization/granular control of the login experience and to integrate your own component design system. 
-Choosing Advanced mode will open the default terminal editor, with the rendering configs:
+⚠️  DEPRECATION NOTICE: Advanced mode will be deprecated on 2026-06-15
+   For future Advanced Customizations, use: auth0 acul config <command>
 
-![storybook](settings.json)
+* Advanced mode is recommended for full customization and granular control of the login experience, allowing integration of your own component design system.
+  Choosing Advanced mode will open the default terminal editor with rendering configurations in a settings.json file.
 
-Closing the terminal editor will save the settings to your tenant.
+  Closing the terminal editor will save the settings to your tenant.
 
 ## Usage
 ```
@@ -29,11 +30,6 @@ auth0 universal-login customize [flags]
 ```
   auth0 universal-login customize
   auth0 ul customize
-  auth0 ul customize --rendering-mode standard
-  auth0 ul customize -r standard
-  auth0 ul customize --rendering-mode advanced --prompt login-id --screen login-id
-  auth0 ul customize --rendering-mode advanced --prompt login-id --screen login-id --settings-file settings.json
-  auth0 ul customize -r advanced -p login-id -s login-id -f settings.json
 ```
 
 
@@ -61,10 +57,10 @@ auth0 universal-login customize [flags]
 
 ## Related Commands
 
-- [auth0 universal-login customize](auth0_universal-login_customize.md) - Customize the Universal Login experience for the standard or advanced mode
+- [auth0 universal-login customize](auth0_universal-login_customize.md) - ⚠️ Customize Universal Login (Advanced mode DEPRECATED)
 - [auth0 universal-login prompts](auth0_universal-login_prompts.md) - Manage custom text for prompts
 - [auth0 universal-login show](auth0_universal-login_show.md) - Display the custom branding settings for Universal Login
-- [auth0 universal-login switch](auth0_universal-login_switch.md) - Switch the rendering mode for Universal Login
+- [auth0 universal-login switch](auth0_universal-login_switch.md) - ⚠️ Switch rendering mode (DEPRECATED)
 - [auth0 universal-login templates](auth0_universal-login_templates.md) - Manage custom Universal Login templates
 - [auth0 universal-login update](auth0_universal-login_update.md) - Update the custom branding settings for Universal Login
 
diff --git a/docs/auth0_universal-login_show.md b/docs/auth0_universal-login_show.md
index 98bcdbf86..e3361cb81 100644
--- a/docs/auth0_universal-login_show.md
+++ b/docs/auth0_universal-login_show.md
@@ -42,10 +42,10 @@ auth0 universal-login show [flags]
 
 ## Related Commands
 
-- [auth0 universal-login customize](auth0_universal-login_customize.md) - Customize the Universal Login experience for the standard or advanced mode
+- [auth0 universal-login customize](auth0_universal-login_customize.md) - ⚠️ Customize Universal Login (Advanced mode DEPRECATED)
 - [auth0 universal-login prompts](auth0_universal-login_prompts.md) - Manage custom text for prompts
 - [auth0 universal-login show](auth0_universal-login_show.md) - Display the custom branding settings for Universal Login
-- [auth0 universal-login switch](auth0_universal-login_switch.md) - Switch the rendering mode for Universal Login
+- [auth0 universal-login switch](auth0_universal-login_switch.md) - ⚠️ Switch rendering mode (DEPRECATED)
 - [auth0 universal-login templates](auth0_universal-login_templates.md) - Manage custom Universal Login templates
 - [auth0 universal-login update](auth0_universal-login_update.md) - Update the custom branding settings for Universal Login
 
diff --git a/docs/auth0_universal-login_switch.md b/docs/auth0_universal-login_switch.md
index ed44db77e..b40b035a3 100644
--- a/docs/auth0_universal-login_switch.md
+++ b/docs/auth0_universal-login_switch.md
@@ -7,6 +7,14 @@ has_toc: false
 
 Switch the rendering mode for Universal Login. Note that this requires a custom domain to be configured for the tenant.
 
+🚨 DEPRECATION WARNING: The 'auth0 ul switch' command will be DEPRECATED on June 15, 2026
+        
+✅ For Advanced Customizations, Use new ACUL config commands:
+  • auth0 acul config generate <screen>
+  • auth0 acul config get <screen>  
+  • auth0 acul config set <screen>
+  • auth0 acul config list
+
 ## Usage
 ```
 auth0 universal-login switch [flags]
@@ -45,10 +53,10 @@ auth0 universal-login switch [flags]
 
 ## Related Commands
 
-- [auth0 universal-login customize](auth0_universal-login_customize.md) - Customize the Universal Login experience for the standard or advanced mode
+- [auth0 universal-login customize](auth0_universal-login_customize.md) - ⚠️ Customize Universal Login (Advanced mode DEPRECATED)
 - [auth0 universal-login prompts](auth0_universal-login_prompts.md) - Manage custom text for prompts
 - [auth0 universal-login show](auth0_universal-login_show.md) - Display the custom branding settings for Universal Login
-- [auth0 universal-login switch](auth0_universal-login_switch.md) - Switch the rendering mode for Universal Login
+- [auth0 universal-login switch](auth0_universal-login_switch.md) - ⚠️ Switch rendering mode (DEPRECATED)
 - [auth0 universal-login templates](auth0_universal-login_templates.md) - Manage custom Universal Login templates
 - [auth0 universal-login update](auth0_universal-login_update.md) - Update the custom branding settings for Universal Login
 
diff --git a/docs/auth0_universal-login_update.md b/docs/auth0_universal-login_update.md
index d7023cab4..3f0a25315 100644
--- a/docs/auth0_universal-login_update.md
+++ b/docs/auth0_universal-login_update.md
@@ -52,10 +52,10 @@ auth0 universal-login update [flags]
 
 ## Related Commands
 
-- [auth0 universal-login customize](auth0_universal-login_customize.md) - Customize the Universal Login experience for the standard or advanced mode
+- [auth0 universal-login customize](auth0_universal-login_customize.md) - ⚠️ Customize Universal Login (Advanced mode DEPRECATED)
 - [auth0 universal-login prompts](auth0_universal-login_prompts.md) - Manage custom text for prompts
 - [auth0 universal-login show](auth0_universal-login_show.md) - Display the custom branding settings for Universal Login
-- [auth0 universal-login switch](auth0_universal-login_switch.md) - Switch the rendering mode for Universal Login
+- [auth0 universal-login switch](auth0_universal-login_switch.md) - ⚠️ Switch rendering mode (DEPRECATED)
 - [auth0 universal-login templates](auth0_universal-login_templates.md) - Manage custom Universal Login templates
 - [auth0 universal-login update](auth0_universal-login_update.md) - Update the custom branding settings for Universal Login
 
diff --git a/docs/index.md b/docs/index.md
index 7614f7701..79c703b37 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -80,6 +80,7 @@ Authenticating as a user is not supported for **private cloud** tenants. Instead
 ## Available Commands
 
 - [auth0 actions](auth0_actions.md) - Manage resources for actions
+- [auth0 acul](auth0_acul.md) - Advanced Customization the Universal Login experience
 - [auth0 api](auth0_api.md) - Makes an authenticated HTTP request to the Auth0 Management API
 - [auth0 apis](auth0_apis.md) - Manage resources for APIs
 - [auth0 apps](auth0_apps.md) - Manage resources for applications
diff --git a/internal/auth0/branding_prompt.go b/internal/auth0/branding_prompt.go
index 8a6bafc1a..dc424c52a 100644
--- a/internal/auth0/branding_prompt.go
+++ b/internal/auth0/branding_prompt.go
@@ -49,6 +49,11 @@ type PromptAPI interface {
 	// See: https://auth0.com/docs/api/management/v2/prompts/patch-rendering
 	UpdateRendering(ctx context.Context, prompt management.PromptType, screen management.ScreenName, c *management.PromptRendering, opts ...management.RequestOption) error
 
+	// BulkUpdateRendering updates multiple rendering settings in a single operation.
+	//
+	// See: https://auth0.com/docs/api/management/v2/prompts/patch-bulk-rendering
+	BulkUpdateRendering(ctx context.Context, c *management.PromptRenderingBulkUpdate, opts ...management.RequestOption) error
+
 	// ListRendering retrieves the settings for the ACUL.
 	//
 	ListRendering(ctx context.Context, opts ...management.RequestOption) (c *management.PromptRenderingList, err error)
diff --git a/internal/auth0/mock/branding_prompt_mock.go b/internal/auth0/mock/branding_prompt_mock.go
index 08a4754c5..a1c67d76d 100644
--- a/internal/auth0/mock/branding_prompt_mock.go
+++ b/internal/auth0/mock/branding_prompt_mock.go
@@ -35,6 +35,25 @@ func (m *MockPromptAPI) EXPECT() *MockPromptAPIMockRecorder {
 	return m.recorder
 }
 
+// BulkUpdateRendering mocks base method.
+func (m *MockPromptAPI) BulkUpdateRendering(ctx context.Context, c *management.PromptRenderingBulkUpdate, opts ...management.RequestOption) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, c}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "BulkUpdateRendering", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// BulkUpdateRendering indicates an expected call of BulkUpdateRendering.
+func (mr *MockPromptAPIMockRecorder) BulkUpdateRendering(ctx, c interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, c}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BulkUpdateRendering", reflect.TypeOf((*MockPromptAPI)(nil).BulkUpdateRendering), varargs...)
+}
+
 // CustomText mocks base method.
 func (m *MockPromptAPI) CustomText(ctx context.Context, p, l string, opts ...management.RequestOption) (map[string]interface{}, error) {
 	m.ctrl.T.Helper()
diff --git a/internal/cli/acul.go b/internal/cli/acul.go
new file mode 100644
index 000000000..cb0d3d17e
--- /dev/null
+++ b/internal/cli/acul.go
@@ -0,0 +1,65 @@
+package cli
+
+import (
+	"context"
+
+	"github.com/spf13/cobra"
+
+	"github.com/auth0/auth0-cli/internal/auth0"
+)
+
+func aculCmd(cli *cli) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "acul",
+		Short: "Advanced Customization the Universal Login experience",
+		Long:  `Customize the Universal Login experience. This requires a custom domain to be configured for the tenant.`,
+	}
+
+	cmd.AddCommand(aculConfigureCmd(cli))
+	cmd.AddCommand(aculInitCmd(cli))
+	cmd.AddCommand(aculScreenCmd(cli))
+	cmd.AddCommand(aculDevCmd(cli))
+
+	return cmd
+}
+
+func aculScreenCmd(cli *cli) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "screen",
+		Short: "Manage individual screens for Advanced Customizations for Universal Login.",
+		Long:  "Manage individual screens for Auth0 Universal Login using ACUL (Advanced Customizations).",
+	}
+
+	cmd.AddCommand(aculScreenAddCmd(cli))
+
+	return cmd
+}
+
+func aculConfigureCmd(cli *cli) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "config",
+		Short: "Configure Advanced Customizations for Universal Login screens.",
+		Long:  "Manage screen-level configuration for Auth0 Universal Login using ACUL (Advanced Customizations).",
+	}
+
+	cmd.AddCommand(aculConfigGenerateCmd(cli))
+	cmd.AddCommand(aculConfigGetCmd(cli))
+	cmd.AddCommand(aculConfigSetCmd(cli))
+	cmd.AddCommand(aculConfigListCmd(cli))
+	cmd.AddCommand(aculConfigDocsCmd(cli))
+
+	return cmd
+}
+
+// ensureACULPrerequisites checks that custom domain and new UL are enabled.
+func ensureACULPrerequisites(ctx context.Context, api *auth0.API) error {
+	if err := ensureCustomDomainIsEnabled(ctx, api); err != nil {
+		return err
+	}
+
+	if err := ensureNewUniversalLoginExperienceIsActive(ctx, api); err != nil {
+		return err
+	}
+
+	return nil
+}
diff --git a/internal/cli/acul_app_scaffolding.go b/internal/cli/acul_app_scaffolding.go
new file mode 100644
index 000000000..a0c4bc50d
--- /dev/null
+++ b/internal/cli/acul_app_scaffolding.go
@@ -0,0 +1,736 @@
+package cli
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"slices"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"github.com/auth0/auth0-cli/internal/ansi"
+	"github.com/auth0/auth0-cli/internal/prompt"
+	"github.com/auth0/auth0-cli/internal/utils"
+)
+
+type Manifest struct {
+	Templates map[string]Template `json:"templates"`
+	Metadata  Metadata            `json:"metadata"`
+}
+
+type Template struct {
+	Name            string    `json:"name"`
+	Description     string    `json:"description"`
+	Framework       string    `json:"framework"`
+	SDK             string    `json:"sdk"`
+	BaseFiles       []string  `json:"base_files"`
+	BaseDirectories []string  `json:"base_directories"`
+	Screens         []Screens `json:"screens"`
+}
+
+type Screens struct {
+	ID          string   `json:"id"`
+	Name        string   `json:"name"`
+	Description string   `json:"description"`
+	Path        string   `json:"path"`
+	ExtraFiles  []string `json:"extra_files"`
+}
+
+type Metadata struct {
+	Version     string `json:"version"`
+	Repository  string `json:"repository"`
+	LastUpdated string `json:"last_updated"`
+	Description string `json:"description"`
+}
+
+// loadManifest downloads and parses the manifest.json for the latest release.
+func loadManifest(tag string) (*Manifest, error) {
+	client := &http.Client{Timeout: 15 * time.Second}
+	url := fmt.Sprintf("https://raw.githubusercontent.com/auth0-samples/auth0-acul-samples/%s/manifest.json", tag)
+
+	resp, err := client.Get(url)
+	if err != nil {
+		return nil, fmt.Errorf("cannot fetch manifest: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("failed to fetch manifest: received status code %d", resp.StatusCode)
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("cannot read manifest body: %w", err)
+	}
+
+	var manifest Manifest
+	if err := json.Unmarshal(body, &manifest); err != nil {
+		return nil, fmt.Errorf("invalid manifest format: %w", err)
+	}
+
+	return &manifest, nil
+}
+
+// getLatestReleaseTag fetches the latest tag from GitHub API.
+func getLatestReleaseTag() (string, error) {
+	client := &http.Client{Timeout: 15 * time.Second}
+	url := "https://api.github.com/repos/auth0-samples/auth0-acul-samples/tags"
+
+	resp, err := client.Get(url)
+	if err != nil {
+		return "", fmt.Errorf("failed to fetch tags: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("failed to fetch tags: received status code %d", resp.StatusCode)
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("failed to read response body: %w", err)
+	}
+
+	var tags []struct {
+		Name string `json:"name"`
+	}
+
+	if err := json.Unmarshal(body, &tags); err != nil {
+		return "", fmt.Errorf("failed to parse tags response: %w", err)
+	}
+
+	if len(tags) == 0 {
+		return "", fmt.Errorf("no tags found in repository")
+	}
+
+	return tags[0].Name, nil
+}
+
+var (
+	templateFlag = Flag{
+		Name:       "Template",
+		LongForm:   "template",
+		ShortForm:  "t",
+		Help:       "Template framework to use for your ACUL project.",
+		IsRequired: false,
+	}
+
+	screensFlag = Flag{
+		Name:       "Screens",
+		LongForm:   "screens",
+		ShortForm:  "s",
+		Help:       "Comma-separated list of screens to include in your ACUL project.",
+		IsRequired: false,
+	}
+)
+
+// / aculInitCmd returns the cobra.Command for project initialization.
+func aculInitCmd(cli *cli) *cobra.Command {
+	var inputs struct {
+		Template string
+		Screens  []string
+	}
+
+	cmd := &cobra.Command{
+		Use:   "init",
+		Args:  cobra.MaximumNArgs(1),
+		Short: "Generate a new ACUL project from a template",
+		Long: `Generate a new Advanced Customizations for Universal Login (ACUL) project from a template.
+This command creates a new project with your choice of framework and authentication screens (login, signup, mfa, etc.). 
+The generated project includes all necessary configuration and boilerplate code to get started with ACUL customizations.`,
+		Example: `  auth0 acul init <app_name>
+  auth0 acul init acul-sample-app
+  auth0 acul init acul-sample-app --template react --screens login,signup
+  auth0 acul init acul-sample-app -t react -s login,mfa,signup`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := ensureACULPrerequisites(cmd.Context(), cli.api); err != nil {
+				return err
+			}
+
+			return runScaffold(cli, cmd, args, &inputs)
+		},
+	}
+
+	templateFlag.RegisterString(cmd, &inputs.Template, "")
+	screensFlag.RegisterStringSlice(cmd, &inputs.Screens, []string{})
+
+	return cmd
+}
+
+func runScaffold(cli *cli, cmd *cobra.Command, args []string, inputs *struct {
+	Template string
+	Screens  []string
+}) error {
+	if err := checkNodeInstallation(); err != nil {
+		return err
+	}
+
+	latestTag, err := getLatestReleaseTag()
+	if err != nil {
+		return fmt.Errorf("failed to get latest release tag: %w", err)
+	}
+
+	manifest, err := loadManifest(latestTag)
+	if err != nil {
+		return err
+	}
+
+	chosenTemplate, err := selectTemplate(cmd, manifest, inputs.Template)
+	if err != nil {
+		return err
+	}
+
+	var availableScreenIDs []string
+	for _, s := range manifest.Templates[chosenTemplate].Screens {
+		availableScreenIDs = append(availableScreenIDs, s.ID)
+	}
+
+	selectedScreens, err := validateAndSelectScreens(cli, availableScreenIDs, inputs.Screens, true)
+	if err != nil {
+		return err
+	}
+
+	destDir := getDestDir(args)
+
+	if err := os.MkdirAll(destDir, 0755); err != nil {
+		return fmt.Errorf("failed to create project dir: %w", err)
+	}
+
+	tempUnzipDir, err := downloadAndUnzipSampleRepo()
+	if err != nil {
+		return err
+	}
+
+	defer os.RemoveAll(tempUnzipDir)
+
+	selectedTemplate := manifest.Templates[chosenTemplate]
+
+	err = copyTemplateBaseDirs(cli, selectedTemplate.BaseDirectories, chosenTemplate, tempUnzipDir, destDir)
+	if err != nil {
+		return err
+	}
+
+	err = copyProjectTemplateFiles(cli, selectedTemplate.BaseFiles, chosenTemplate, tempUnzipDir, destDir)
+	if err != nil {
+		return err
+	}
+
+	err = copyProjectScreens(cli, selectedTemplate.Screens, selectedScreens, chosenTemplate, tempUnzipDir, destDir)
+	if err != nil {
+		return err
+	}
+
+	err = writeAculConfig(destDir, chosenTemplate, selectedScreens, manifest.Metadata.Version, latestTag)
+	if err != nil {
+		fmt.Printf("Failed to write config: %v\n", err)
+	}
+
+	runNpmGenerateScreenLoader(cli, destDir)
+
+	if prompt.Confirm("Would you like to proceed with installing the required dependencies using 'npm install'?") {
+		fmt.Println(ansi.Cyan("Installing Dependencies... This may take a little while."))
+		runNpmInstall(cli, destDir)
+	}
+
+	showPostScaffoldingOutput(cli, destDir, "Project successfully created")
+
+	return nil
+}
+
+func selectTemplate(cmd *cobra.Command, manifest *Manifest, providedTemplate string) (string, error) {
+	var templateNames []string
+	nameToKey := make(map[string]string)
+
+	for key, template := range manifest.Templates {
+		templateNames = append(templateNames, template.Name)
+		nameToKey[template.Name] = key
+	}
+
+	// If template provided via flag, validate it.
+	if providedTemplate != "" {
+		for key, template := range manifest.Templates {
+			if template.Name == providedTemplate || key == providedTemplate {
+				return key, nil
+			}
+		}
+		return "", fmt.Errorf("invalid template '%s'. Available templates: %s",
+			providedTemplate, strings.Join(templateNames, ", "))
+	}
+
+	var chosenTemplateName string
+	err := templateFlag.Select(cmd, &chosenTemplateName, templateNames, nil)
+	if err != nil {
+		return "", handleInputError(err)
+	}
+
+	return nameToKey[chosenTemplateName], nil
+}
+
+// ValidateAndSelectScreens validates provided screens or prompts for selection.
+func validateAndSelectScreens(cli *cli, screenIDs, providedScreens []string, multiSelect bool) ([]string, error) {
+	if len(screenIDs) == 0 {
+		return nil, fmt.Errorf("no available screens found")
+	}
+
+	var valid []string
+	var invalid []string
+
+	for _, s := range providedScreens {
+		screen := strings.TrimSpace(s)
+		if screen == "" {
+			continue
+		}
+		if slices.Contains(screenIDs, screen) {
+			valid = append(valid, screen)
+		} else {
+			invalid = append(invalid, screen)
+		}
+	}
+
+	// If user provided screens.
+	if len(providedScreens) > 0 {
+		if len(invalid) > 0 {
+			cli.renderer.Warnf("Unsupported screens: %s", ansi.Red(strings.Join(invalid, ", ")))
+		}
+
+		if len(valid) > 0 {
+			// If single-select, only return the first match.
+			if !multiSelect {
+				return []string{valid[0]}, nil
+			}
+			return valid, nil
+		}
+
+		cli.renderer.Warnf("No valid screen(s) found. Please select from the available options.")
+	}
+
+	// No valid provided screens — fall back to interactive selection.
+	if multiSelect {
+		var selected []string
+		if err := prompt.AskMultiSelect("Select screens:", &selected, screenIDs...); err != nil {
+			return nil, err
+		}
+		if len(selected) == 0 {
+			return nil, fmt.Errorf("at least one screen must be selected")
+		}
+		return selected, nil
+	}
+
+	// Single select.
+	var selected string
+	q := prompt.SelectInput("screen", "Select a screen:", "", screenIDs, screenIDs[0], true)
+	if err := prompt.AskOne(q, &selected); err != nil {
+		return nil, err
+	}
+
+	return []string{selected}, nil
+}
+
+func getDestDir(args []string) string {
+	if len(args) < 1 {
+		return "acul-sample-app"
+	}
+
+	return args[0]
+}
+
+func downloadAndUnzipSampleRepo() (string, error) {
+	latestTag, err := getLatestReleaseTag()
+	if err != nil {
+		return "", fmt.Errorf("failed to get latest release tag: %w", err)
+	}
+
+	repoURL := fmt.Sprintf("https://github.com/auth0-samples/auth0-acul-samples/archive/refs/tags/%s.zip", latestTag)
+	tempZipFile, err := downloadFile(repoURL)
+	if err != nil {
+		return "", fmt.Errorf("error downloading sample repo: %w", err)
+	}
+
+	defer os.Remove(tempZipFile) // Clean up the temp zip file.
+
+	tempUnzipDir, err := os.MkdirTemp("", "unzipped-repo-*")
+	if err != nil {
+		return "", fmt.Errorf("error creating temporary unzip dir: %w", err)
+	}
+
+	if err = utils.Unzip(tempZipFile, tempUnzipDir); err != nil {
+		return "", err
+	}
+
+	return tempUnzipDir, nil
+}
+
+// This supports any version tag (v1.0.0, v2.0.0, etc.) without hardcoding.
+func findExtractedRepoDir(tempUnzipDir string) (string, error) {
+	entries, err := os.ReadDir(tempUnzipDir)
+	if err != nil {
+		return "", fmt.Errorf("failed to read temp directory: %w", err)
+	}
+
+	for _, entry := range entries {
+		if entry.IsDir() && strings.HasPrefix(entry.Name(), "auth0-acul-samples-") {
+			return entry.Name(), nil
+		}
+	}
+
+	return "", fmt.Errorf("could not find extracted auth0-acul-samples directory")
+}
+
+func copyTemplateBaseDirs(cli *cli, baseDirs []string, chosenTemplate, tempUnzipDir, destDir string) error {
+	extractedDir, err := findExtractedRepoDir(tempUnzipDir)
+	if err != nil {
+		return fmt.Errorf("failed to find extracted directory: %w", err)
+	}
+
+	sourcePathPrefix := filepath.Join(extractedDir, chosenTemplate)
+	for _, dirPath := range baseDirs {
+		srcPath := filepath.Join(tempUnzipDir, sourcePathPrefix, dirPath)
+		destPath := filepath.Join(destDir, dirPath)
+
+		if _, err := os.Stat(srcPath); os.IsNotExist(err) {
+			cli.renderer.Warnf("⚠️ Source directory does not exist: %s", ansi.Faint(srcPath))
+			continue
+		}
+
+		if err := copyDir(srcPath, destPath); err != nil {
+			return fmt.Errorf("error copying directory %s: %w", dirPath, err)
+		}
+	}
+
+	return nil
+}
+
+func copyProjectTemplateFiles(cli *cli, baseFiles []string, chosenTemplate, tempUnzipDir, destDir string) error {
+	extractedDir, err := findExtractedRepoDir(tempUnzipDir)
+	if err != nil {
+		return fmt.Errorf("failed to find extracted directory: %w", err)
+	}
+
+	sourcePathPrefix := filepath.Join(extractedDir, chosenTemplate)
+
+	for _, filePath := range baseFiles {
+		srcPath := filepath.Join(tempUnzipDir, sourcePathPrefix, filePath)
+		destPath := filepath.Join(destDir, filePath)
+
+		if _, err := os.Stat(srcPath); os.IsNotExist(err) {
+			cli.renderer.Warnf("⚠️ Source file does not exist: %s", ansi.Faint(srcPath))
+			continue
+		}
+
+		parentDir := filepath.Dir(destPath)
+		if err := os.MkdirAll(parentDir, 0755); err != nil {
+			cli.renderer.Warnf("❌ Error creating parent directory for %s: %v", ansi.Bold(filePath), err)
+			continue
+		}
+
+		if err := copyFile(srcPath, destPath); err != nil {
+			return fmt.Errorf("error copying file %s: %w", filePath, err)
+		}
+	}
+
+	return nil
+}
+
+func copyProjectScreens(cli *cli, screens []Screens, selectedScreens []string, chosenTemplate, tempUnzipDir, destDir string) error {
+	extractedDir, err := findExtractedRepoDir(tempUnzipDir)
+	if err != nil {
+		return fmt.Errorf("failed to find extracted directory: %w", err)
+	}
+
+	sourcePathPrefix := filepath.Join(extractedDir, chosenTemplate)
+	screenInfo := createScreenMap(screens)
+	for _, s := range selectedScreens {
+		screen := screenInfo[s]
+
+		srcPath := filepath.Join(tempUnzipDir, sourcePathPrefix, screen.Path)
+		destPath := filepath.Join(destDir, screen.Path)
+
+		if _, err := os.Stat(srcPath); os.IsNotExist(err) {
+			cli.renderer.Warnf("%s Source directory does not exist: %s",
+				ansi.Bold(ansi.Yellow("⚠️")), ansi.Faint(srcPath))
+			continue
+		}
+
+		parentDir := filepath.Dir(destPath)
+		if err := os.MkdirAll(parentDir, 0755); err != nil {
+			cli.renderer.Warnf("❌ Error creating parent directory for %s: %v", ansi.Bold(screen.Path), err)
+			continue
+		}
+
+		if err := copyDir(srcPath, destPath); err != nil {
+			return fmt.Errorf("error copying screen directory %s: %w", screen.Path, err)
+		}
+
+		err = copyProjectTemplateFiles(cli, screen.ExtraFiles, chosenTemplate, tempUnzipDir, destDir)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func writeAculConfig(destDir, chosenTemplate string, selectedScreens []string, manifestVersion, appVersion string) error {
+	config := AculConfig{
+		ChosenTemplate:      chosenTemplate,
+		Screens:             selectedScreens,
+		CreatedAt:           time.Now().UTC().Format(time.RFC3339),
+		ModifiedAt:          time.Now().UTC().Format(time.RFC3339),
+		AculManifestVersion: manifestVersion,
+		AppVersion:          appVersion,
+	}
+
+	data, err := json.MarshalIndent(config, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal config: %w", err)
+	}
+
+	configPath := filepath.Join(destDir, "acul_config.json")
+	if err = os.WriteFile(configPath, data, 0644); err != nil {
+		return fmt.Errorf("failed to write config: %v", err)
+	}
+
+	return nil
+}
+
+// downloadFile downloads a file from a URL to a temporary file and returns its name.
+func downloadFile(url string) (string, error) {
+	client := &http.Client{Timeout: 15 * time.Second}
+
+	resp, err := client.Get(url)
+	if err != nil {
+		return "", fmt.Errorf("failed to download %s: %w", url, err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("unexpected status code %d when downloading %s", resp.StatusCode, url)
+	}
+
+	tempFile, err := os.CreateTemp("", "github-zip-*.zip")
+	if err != nil {
+		return "", fmt.Errorf("failed to create temp file: %w", err)
+	}
+	defer tempFile.Close()
+
+	if _, err := io.Copy(tempFile, resp.Body); err != nil {
+		return "", fmt.Errorf("failed to save zip file: %w", err)
+	}
+
+	return tempFile.Name(), nil
+}
+
+// Function to copy a file from a source path to a destination path.
+func copyFile(src, dst string) error {
+	in, err := os.Open(src)
+	if err != nil {
+		return fmt.Errorf("failed to open source file: %w", err)
+	}
+	defer in.Close()
+
+	out, err := os.Create(dst)
+	if err != nil {
+		return fmt.Errorf("failed to create destination file: %w", err)
+	}
+	defer out.Close()
+
+	if _, err = io.Copy(out, in); err != nil {
+		return fmt.Errorf("failed to copy file contents: %w", err)
+	}
+	return out.Close()
+}
+
+// Function to recursively copy a directory.
+func copyDir(src, dst string) error {
+	sourceInfo, err := os.Stat(src)
+	if err != nil {
+		return err
+	}
+
+	err = os.MkdirAll(dst, sourceInfo.Mode())
+	if err != nil {
+		return err
+	}
+
+	return filepath.Walk(src, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if path == src {
+			return nil
+		}
+
+		relPath, err := filepath.Rel(src, path)
+		if err != nil {
+			return err
+		}
+		destPath := filepath.Join(dst, relPath)
+
+		if info.IsDir() {
+			return os.MkdirAll(destPath, info.Mode())
+		}
+		return copyFile(path, destPath)
+	})
+}
+
+func createScreenMap(screens []Screens) map[string]Screens {
+	screenMap := make(map[string]Screens)
+	for _, screen := range screens {
+		screenMap[screen.ID] = screen
+	}
+	return screenMap
+}
+
+// showPostScaffoldingOutput displays comprehensive post-scaffolding information including
+// success message, documentation, Node version check, next steps, and available commands.
+func showPostScaffoldingOutput(cli *cli, destDir, successMessage string) {
+	cli.renderer.Output("")
+	cli.renderer.Infof("🎉 %s in %s!", successMessage, ansi.Bold(ansi.Cyan(fmt.Sprintf("'%s'", destDir))))
+	cli.renderer.Output("")
+
+	cli.renderer.Infof("📖  Explore the sample app: %s",
+		ansi.Blue("https://github.com/auth0-samples/auth0-acul-samples"))
+	cli.renderer.Output("")
+
+	// Show next steps and related commands.
+	fmt.Println()
+	fmt.Println(ansi.Bold("Next Steps:"))
+	fmt.Printf("  Navigate to %s\n", ansi.Cyan(destDir))
+	fmt.Printf("  Run %s if dependencies are not installed\n", ansi.Cyan("npm install"))
+	fmt.Printf("  Start the local dev server using %s\n", ansi.Cyan("auth0 acul dev"))
+
+	printAvailableCommands()
+	checkNodeVersion(cli)
+}
+
+func printAvailableCommands() {
+	fmt.Println()
+	fmt.Println(ansi.Bold("📋  Available Commands:"))
+	fmt.Println()
+
+	fmt.Printf("  %s - Add authentication screens\n", ansi.Bold(ansi.Green("auth0 acul screen add <screen-name>")))
+	fmt.Printf("  %s - Local development with hot-reload\n", ansi.Bold(ansi.Green("auth0 acul dev")))
+	fmt.Printf("  %s - Live sync changes to Auth0 tenant\n", ansi.Bold(ansi.Green("auth0 acul dev --connected")))
+	fmt.Printf("  %s - Create starter config template\n", ansi.Bold(ansi.Green("auth0 acul config generate <screen>")))
+	fmt.Printf("  %s - Pull current Auth0 settings\n", ansi.Bold(ansi.Green("auth0 acul config get <screen>")))
+	fmt.Printf("  %s - Push local config to Auth0\n", ansi.Bold(ansi.Green("auth0 acul config set <screen>")))
+	fmt.Printf("  %s - List all configurable screens\n", ansi.Bold(ansi.Green("auth0 acul config list")))
+
+	fmt.Println()
+	fmt.Printf("%s  Use %s to see all available commands\n",
+		ansi.Yellow("💡 Tip:"), ansi.Cyan("auth0 acul --help"))
+	fmt.Println()
+}
+
+type AculConfig struct {
+	ChosenTemplate      string   `json:"chosen_template"`
+	Screens             []string `json:"screens"`
+	CreatedAt           string   `json:"created_at"`
+	ModifiedAt          string   `json:"modified_at"`
+	AppVersion          string   `json:"app_version"`
+	AculManifestVersion string   `json:"acul_manifest_version"`
+}
+
+// checkNodeInstallation ensures that Node is installed and accessible in the system PATH.
+func checkNodeInstallation() error {
+	cmd := exec.Command("node", "--version")
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("node is required but not found. Please install Node v22 or higher and try again")
+	}
+	return nil
+}
+
+// checkNodeVersion checks the major version number of the installed Node.
+func checkNodeVersion(cli *cli) {
+	cmd := exec.Command("node", "--version")
+	output, err := cmd.Output()
+	if err != nil {
+		cli.renderer.Warnf(ansi.Yellow("Unable to detect Node version. Please ensure Node v22+ is installed."))
+		return
+	}
+
+	version := strings.TrimSpace(string(output))
+	re := regexp.MustCompile(`v?(\d+)\.`)
+	matches := re.FindStringSubmatch(version)
+	if len(matches) < 2 {
+		cli.renderer.Warnf(ansi.Yellow(fmt.Sprintf("Unable to parse Node version: %s. Please ensure Node v22+ is installed.", version)))
+		return
+	}
+
+	if major, _ := strconv.Atoi(matches[1]); major < 22 {
+		fmt.Println(
+			ansi.Yellow(fmt.Sprintf(
+				"⚠️  Node %s detected. This project requires Node v22 or higher.\n"+
+					"   Please upgrade to Node v22+ to run the sample app and build assets successfully.\n",
+				version,
+			)),
+		)
+
+		cli.renderer.Output("")
+	}
+}
+
+// runNpmGenerateScreenLoader runs `npm run generate:screenLoader` in the given directory.
+// Prints errors or warnings directly; silent if successful with no issues.
+func runNpmGenerateScreenLoader(cli *cli, destDir string) {
+	cmd := exec.Command("npm", "run", "generate:screenLoader")
+	cmd.Dir = destDir
+
+	output, err := cmd.CombinedOutput()
+	lines := strings.Split(strings.TrimSpace(string(output)), "\n")
+
+	summary := strings.Join(lines, "\n")
+	if len(lines) > 5 {
+		summary = strings.Join(lines[:5], "\n") + "\n..."
+	}
+
+	if err != nil {
+		cli.renderer.Warnf(
+			"⚠️  Screen loader generation failed: %v\n"+
+				"👉 Run manually: %s\n"+
+				"📄 Required for: %s\n"+
+				"💡 Tip: If it continues to fail, verify your Node setup and screen structure.",
+			err,
+			ansi.Bold(ansi.Cyan(fmt.Sprintf("cd %s && npm run generate:screenLoader", destDir))),
+			ansi.Faint(fmt.Sprintf("%s/src/utils/screen/screenLoader.ts", destDir)),
+		)
+
+		if len(summary) > 0 {
+			fmt.Println(summary)
+		}
+
+		return
+	}
+}
+
+// runNpmInstall runs `npm install` in the given directory.
+// Prints concise logs; warns on failure, silent if successful.
+func runNpmInstall(cli *cli, destDir string) {
+	cmd := exec.Command("npm", "install")
+	cmd.Dir = destDir
+
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	if err := cmd.Run(); err != nil {
+		cli.renderer.Warnf(
+			"⚠️  npm install failed: %v\n"+
+				"👉 Run manually: %s\n"+
+				"📦 Directory: %s\n"+
+				"💡 Tip: Check your Node.js and npm setup, or clear node_modules and retry.",
+			err,
+			ansi.Bold(ansi.Cyan(fmt.Sprintf("cd %s && npm install", destDir))),
+			ansi.Faint(destDir),
+		)
+	}
+
+	fmt.Println("✅ " + ansi.Green("All dependencies installed successfully"))
+}
diff --git a/internal/cli/acul_config.go b/internal/cli/acul_config.go
new file mode 100644
index 000000000..268827f52
--- /dev/null
+++ b/internal/cli/acul_config.go
@@ -0,0 +1,597 @@
+package cli
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"strconv"
+
+	"github.com/auth0/go-auth0/management"
+
+	"github.com/pkg/browser"
+	"github.com/spf13/cobra"
+
+	"github.com/auth0/auth0-cli/internal/ansi"
+	"github.com/auth0/auth0-cli/internal/prompt"
+	"github.com/auth0/auth0-cli/internal/utils"
+)
+
+var (
+	screenName = Flag{
+		Name:       "Screen Name",
+		LongForm:   "screen",
+		ShortForm:  "s",
+		Help:       "Name of the screen to customize.",
+		IsRequired: true,
+	}
+	file = Flag{
+		Name:       "File",
+		LongForm:   "file",
+		ShortForm:  "f",
+		Help:       "File to save the rendering configs to.",
+		IsRequired: false,
+	}
+	rendererScript = Flag{
+		Name:       "Script",
+		LongForm:   "script",
+		Help:       "Script contents for the rendering configs.",
+		IsRequired: true,
+	}
+	fieldsFlag = Flag{
+		Name:       "Fields",
+		LongForm:   "fields",
+		Help:       "Comma-separated list of fields to include or exclude in the result (based on value provided for include_fields) ",
+		IsRequired: false,
+	}
+	includeFieldsFlag = Flag{
+		Name:       "Include Fields",
+		LongForm:   "include-fields",
+		Help:       "Whether specified fields are to be included (true) or excluded (false).",
+		IsRequired: false,
+	}
+	includeTotalsFlag = Flag{
+		Name:       "Include Totals",
+		LongForm:   "include-totals",
+		Help:       "Return results inside an object that contains the total result count (true) or as a direct array of results (false).",
+		IsRequired: false,
+	}
+	pageFlag = Flag{
+		Name:       "Page",
+		LongForm:   "page",
+		Help:       "Page index of the results to return. First page is 0.",
+		IsRequired: false,
+	}
+	perPageFlag = Flag{
+		Name:       "Per Page",
+		LongForm:   "per-page",
+		Help:       "Number of results per page. Default value is 50, maximum value is 100.",
+		IsRequired: false,
+	}
+	promptFlag = Flag{
+		Name:       "Prompt",
+		LongForm:   "prompt",
+		Help:       "Filter by the Universal Login prompt.",
+		IsRequired: false,
+	}
+	screenFlag = Flag{
+		Name:       "Screen",
+		LongForm:   "screen",
+		Help:       "Filter by the Universal Login screen.",
+		IsRequired: false,
+	}
+	renderingModeFlag = Flag{
+		Name:       "Rendering Mode",
+		LongForm:   "rendering-mode",
+		Help:       "Filter by the rendering mode (advanced or standard).",
+		IsRequired: false,
+	}
+	queryFlag = Flag{
+		Name:       "Query",
+		LongForm:   "query",
+		ShortForm:  "q",
+		Help:       "Advanced query.",
+		IsRequired: false,
+	}
+	ScreenPromptMap = map[string]string{
+		"signup-id":                                      "signup-id",
+		"signup-password":                                "signup-password",
+		"login-id":                                       "login-id",
+		"login-password":                                 "login-password",
+		"login-passwordless-email-code":                  "login-passwordless",
+		"login-passwordless-sms-otp":                     "login-passwordless",
+		"phone-identifier-enrollment":                    "phone-identifier-enrollment",
+		"phone-identifier-challenge":                     "phone-identifier-challenge",
+		"email-identifier-challenge":                     "email-identifier-challenge",
+		"passkey-enrollment":                             "passkeys",
+		"passkey-enrollment-local":                       "passkeys",
+		"interstitial-captcha":                           "captcha",
+		"login":                                          "login",
+		"signup":                                         "signup",
+		"reset-password-request":                         "reset-password",
+		"reset-password-email":                           "reset-password",
+		"reset-password":                                 "reset-password",
+		"reset-password-success":                         "reset-password",
+		"reset-password-error":                           "reset-password",
+		"reset-password-mfa-email-challenge":             "reset-password",
+		"reset-password-mfa-otp-challenge":               "reset-password",
+		"reset-password-mfa-push-challenge-push":         "reset-password",
+		"reset-password-mfa-sms-challenge":               "reset-password",
+		"reset-password-mfa-phone-challenge":             "reset-password",
+		"reset-password-mfa-voice-challenge":             "reset-password",
+		"reset-password-mfa-recovery-code-challenge":     "reset-password",
+		"reset-password-mfa-webauthn-platform-challenge": "reset-password",
+		"reset-password-mfa-webauthn-roaming-challenge":  "reset-password",
+		"mfa-detect-browser-capabilities":                "mfa",
+		"mfa-enroll-result":                              "mfa",
+		"mfa-begin-enroll-options":                       "mfa",
+		"mfa-login-options":                              "mfa",
+		"mfa-email-challenge":                            "mfa-email",
+		"mfa-email-list":                                 "mfa-email",
+		"mfa-country-codes":                              "mfa-sms",
+		"mfa-sms-challenge":                              "mfa-sms",
+		"mfa-sms-enrollment":                             "mfa-sms",
+		"mfa-sms-list":                                   "mfa-sms",
+		"mfa-push-challenge-push":                        "mfa-push",
+		"mfa-push-enrollment-qr":                         "mfa-push",
+		"mfa-push-list":                                  "mfa-push",
+		"mfa-push-welcome":                               "mfa-push",
+		"accept-invitation":                              "invitation",
+		"organization-selection":                         "organizations",
+		"organization-picker":                            "organizations",
+		"mfa-otp-challenge":                              "mfa-otp",
+		"mfa-otp-enrollment-code":                        "mfa-otp",
+		"mfa-otp-enrollment-qr":                          "mfa-otp",
+		"device-code-activation":                         "device-flow",
+		"device-code-activation-allowed":                 "device-flow",
+		"device-code-activation-denied":                  "device-flow",
+		"device-code-confirmation":                       "device-flow",
+		"mfa-phone-challenge":                            "mfa-phone",
+		"mfa-phone-enrollment":                           "mfa-phone",
+		"mfa-voice-challenge":                            "mfa-voice",
+		"mfa-voice-enrollment":                           "mfa-voice",
+		"mfa-recovery-code-challenge":                    "mfa-recovery-code",
+		"mfa-recovery-code-enrollment":                   "mfa-recovery-code",
+		"mfa-recovery-code-challenge-new-code":           "mfa-recovery-code",
+		"redeem-ticket":                                  "common",
+		"email-verification-result":                      "email-verification",
+		"login-email-verification":                       "login-email-verification",
+		"logout":                                         "logout",
+		"logout-aborted":                                 "logout",
+		"logout-complete":                                "logout",
+		"mfa-webauthn-change-key-nickname":               "mfa-webauthn",
+		"mfa-webauthn-enrollment-success":                "mfa-webauthn",
+		"mfa-webauthn-error":                             "mfa-webauthn",
+		"mfa-webauthn-platform-challenge":                "mfa-webauthn",
+		"mfa-webauthn-platform-enrollment":               "mfa-webauthn",
+		"mfa-webauthn-roaming-challenge":                 "mfa-webauthn",
+		"mfa-webauthn-roaming-enrollment":                "mfa-webauthn",
+	}
+)
+
+type aculConfigInput struct {
+	screenName string
+	filePath   string
+}
+
+// ensureConfigFilePath sets a default config file path if none is provided and creates the config directory.
+func ensureConfigFilePath(input *aculConfigInput, cli *cli) error {
+	if input.filePath == "" {
+		input.filePath = fmt.Sprintf("acul_config/%s.json", input.screenName)
+		cli.renderer.Warnf("No configuration file path specified. Defaulting to '%s'.", ansi.Green(input.filePath))
+	}
+	if err := os.MkdirAll("acul_config", 0755); err != nil {
+		return fmt.Errorf("could not create config directory: %w", err)
+	}
+	return nil
+}
+
+// Generate default ACUL config stub.
+func defaultACULConfig() map[string]interface{} {
+	return map[string]interface{}{
+		"rendering_mode":             "standard",
+		"context_configuration":      []interface{}{},
+		"use_page_template":          false,
+		"default_head_tags_disabled": false,
+		"head_tags":                  []interface{}{},
+		"filters":                    map[string]interface{}{},
+	}
+}
+
+func aculConfigGenerateCmd(cli *cli) *cobra.Command {
+	var input aculConfigInput
+
+	cmd := &cobra.Command{
+		Use:   "generate",
+		Args:  cobra.MaximumNArgs(1),
+		Short: "Generate a stub config file for a Universal Login screen.",
+		Long: "Generate a stub config file for a Universal Login screen and save it to a file.\n" +
+			"If fileName is not provided, it will default to <screen-name>.json in the current directory.",
+		Example: `  auth0 acul config generate <screen-name>
+  auth0 acul config generate <screen-name> --file settings.json
+  auth0 acul config generate signup-id
+  auth0 acul config generate login-id --file login-settings.json`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := ensureACULPrerequisites(cmd.Context(), cli.api); err != nil {
+				return err
+			}
+
+			screens, err := validateAndSelectScreens(cli, utils.FetchKeys(ScreenPromptMap), args, false)
+			if err != nil {
+				return err
+			}
+
+			input.screenName = screens[0]
+
+			if err := ensureConfigFilePath(&input, cli); err != nil {
+				return err
+			}
+
+			config := defaultACULConfig()
+
+			// Error handling omitted for brevity.
+			data, _ := json.MarshalIndent(config, "", "  ")
+
+			message := fmt.Sprintf("Overwrite file '%s' with default config? : ", ansi.Green(input.filePath))
+			if shouldCancelOverwrite(cli, cmd, input.filePath, message) {
+				return nil
+			}
+
+			if err := os.WriteFile(input.filePath, data, 0644); err != nil {
+				return fmt.Errorf("could not write config: %w", err)
+			}
+
+			cli.renderer.Infof("Configuration generated at '%s'", ansi.Green(input.filePath))
+
+			cli.renderer.Output("Learn more about configuring ACUL screens https://auth0.com/docs/customize/login-pages/advanced-customizations/getting-started/configure-acul-screens")
+
+			cli.renderer.Output(ansi.Yellow("💡 Tip: Use `auth0 acul config get` to fetch remote rendering settings or `auth0 acul config set` to sync local configs."))
+			return nil
+		},
+	}
+
+	file.RegisterString(cmd, &input.filePath, "")
+	return cmd
+}
+
+func aculConfigGetCmd(cli *cli) *cobra.Command {
+	var input aculConfigInput
+
+	cmd := &cobra.Command{
+		Use:   "get",
+		Args:  cobra.MaximumNArgs(1),
+		Short: "Get the current rendering settings for a specific screen",
+		Long:  "Get the current rendering settings for a specific screen.",
+		Example: `  auth0 acul config get <screen-name>
+  auth0 acul config get <screen-name> --file settings.json
+  auth0 acul config get signup-id
+  auth0 acul config get login-id -f ./acul_config/login-id.json`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			ctx := cmd.Context()
+			if err := ensureACULPrerequisites(cmd.Context(), cli.api); err != nil {
+				return err
+			}
+
+			screens, err := validateAndSelectScreens(cli, utils.FetchKeys(ScreenPromptMap), args, false)
+			if err != nil {
+				return err
+			}
+
+			input.screenName = screens[0]
+
+			existingRenderSettings, err := cli.api.Prompt.ReadRendering(ctx, management.PromptType(ScreenPromptMap[input.screenName]), management.ScreenName(input.screenName))
+			if err != nil {
+				return fmt.Errorf("failed to fetch the existing render settings: %w", err)
+			}
+
+			if existingRenderSettings == nil {
+				cli.renderer.Warnf("No rendering settings found for screen '%s' in tenant '%s'.", ansi.Green(input.screenName), ansi.Blue(cli.tenant))
+				cli.renderer.Output(ansi.Yellow("💡 Tip: Use `auth0 acul config generate` to generate a stub config file or `auth0 acul config set` to sync local configs."))
+				cli.renderer.Output(ansi.Cyan("📖 Customization Guide: https://github.com/auth0/auth0-cli/blob/main/CUSTOMIZATION_GUIDE.md"))
+				return nil
+			}
+
+			if err := ensureConfigFilePath(&input, cli); err != nil {
+				return err
+			}
+
+			message := fmt.Sprintf("Overwrite file '%s' with new data from tenant '%s'? : ", ansi.Green(input.filePath), ansi.Blue(cli.tenant))
+			if shouldCancelOverwrite(cli, cmd, input.filePath, message) {
+				return nil
+			}
+
+			data, err := json.MarshalIndent(existingRenderSettings, "", "  ")
+			if err != nil {
+				return fmt.Errorf("failed to marshal render settings: %w", err)
+			}
+			if err := os.WriteFile(input.filePath, data, 0644); err != nil {
+				return fmt.Errorf("failed to write render settings to file %q: %w", input.filePath, err)
+			}
+
+			cli.renderer.Infof("Configuration downloaded and saved at '%s'.", ansi.Green(input.filePath))
+			cli.renderer.Output(ansi.Yellow("💡 Tip: Use `auth0 acul config set` to sync local config to remote or `auth0 acul config list` to view all ACUL screens."))
+			return nil
+		},
+	}
+
+	file.RegisterString(cmd, &input.filePath, "")
+
+	return cmd
+}
+
+func shouldCancelOverwrite(cli *cli, cmd *cobra.Command, filePath, message string) bool {
+	_, err := os.Stat(filePath)
+	if os.IsNotExist(err) {
+		return false
+	}
+	if !cli.force && canPrompt(cmd) {
+		if confirmed := prompt.Confirm(message); !confirmed {
+			return true
+		}
+	}
+
+	return false
+}
+
+func aculConfigSetCmd(cli *cli) *cobra.Command {
+	var input aculConfigInput
+
+	cmd := &cobra.Command{
+		Use:   "set",
+		Args:  cobra.MaximumNArgs(1),
+		Short: "Set the rendering settings for a specific screen",
+		Long:  "Set the rendering settings for a specific screen.",
+		Example: `  auth0 acul config set <screen-name>
+  auth0 acul config set <screen-name> --file settings.json
+  auth0 acul config set signup-id --file settings.json
+  auth0 acul config set login-id`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := ensureACULPrerequisites(cmd.Context(), cli.api); err != nil {
+				return err
+			}
+
+			screens, err := validateAndSelectScreens(cli, utils.FetchKeys(ScreenPromptMap), args, false)
+			if err != nil {
+				return err
+			}
+
+			input.screenName = screens[0]
+
+			cli.renderer.Output(ansi.Yellow("📖 Customization Guide: https://github.com/auth0/auth0-cli/blob/main/CUSTOMIZATION_GUIDE.md"))
+
+			return advanceCustomize(cmd, cli, input)
+		},
+	}
+
+	file.RegisterString(cmd, &input.filePath, "")
+	return cmd
+}
+
+func advanceCustomize(cmd *cobra.Command, cli *cli, input aculConfigInput) error {
+	currMode := standardMode
+	renderSettings, err := fetchRenderSettings(cmd, cli, input)
+	if renderSettings != nil && renderSettings.RenderingMode != nil {
+		currMode = string(*renderSettings.RenderingMode)
+	}
+
+	if errors.Is(err, ErrNoChangesDetected) {
+		cli.renderer.Infof("Current rendering mode for Prompt '%s', Screen '%s': %s", ansi.Green(ScreenPromptMap[input.screenName]), ansi.Green(input.screenName), ansi.Green(currMode))
+		return nil
+	}
+
+	if err != nil {
+		return err
+	}
+
+	if err = ansi.Waiting(func() error {
+		return cli.api.Prompt.UpdateRendering(cmd.Context(), management.PromptType(ScreenPromptMap[input.screenName]), management.ScreenName(input.screenName), renderSettings)
+	}); err != nil {
+		return fmt.Errorf("failed to set the render settings: %w", err)
+	}
+
+	cli.renderer.Infof("Rendering settings updated. Current rendering mode for '%s', Screen '%s': %s", ansi.Green(ScreenPromptMap[input.screenName]), ansi.Green(input.screenName), ansi.Green(currMode))
+	cli.renderer.Output(ansi.Yellow("💡 Tip: Use `auth0 acul config get` to fetch remote rendering settings or `auth0 acul config list` to view all ACUL screens."))
+	return nil
+}
+
+func fetchRenderSettings(cmd *cobra.Command, cli *cli, input aculConfigInput) (*management.PromptRendering, error) {
+	var (
+		userRenderSettings string
+		renderSettings     = &management.PromptRendering{}
+		existingSettings   = map[string]interface{}{}
+		currentSettings    = map[string]interface{}{}
+	)
+
+	if input.filePath != "" {
+		// Case 1: File path is provided, use that file's content.
+		data, err := os.ReadFile(input.filePath)
+		if err != nil {
+			return nil, fmt.Errorf("unable to read file %q: %v", input.filePath, err)
+		}
+		if err := json.Unmarshal(data, &renderSettings); err != nil {
+			return nil, fmt.Errorf("file %q contains invalid JSON: %v", input.filePath, err)
+		}
+		return renderSettings, nil
+	}
+
+	// Case 2: No file path provided, default to config/<screen-name>.json.
+	defaultFilePath := fmt.Sprintf("acul_config/%s.json", input.screenName)
+	data, err := os.ReadFile(defaultFilePath)
+	if err == nil {
+		cli.renderer.Warnf("No file path specified. Defaulting to '%s'.", ansi.Green(defaultFilePath))
+		if !cli.force && canPrompt(cmd) {
+			message := fmt.Sprintf("Use file '%s' for updating remote ACUL configs for '%s'? : ", ansi.Green(defaultFilePath), ansi.Blue(input.screenName))
+			if confirmed := prompt.Confirm(message); confirmed {
+				if err := json.Unmarshal(data, &renderSettings); err != nil {
+					return nil, fmt.Errorf("file %s contains invalid JSON: %v", defaultFilePath, err)
+				}
+				return renderSettings, nil
+			}
+		}
+	}
+
+	// Case 3: No file path provided and default file doesn't exist or user declined to use it, open editor.
+	cli.renderer.Infof("Opening editor to update remote ACUL configs for '%s'.", ansi.Green(input.screenName))
+	existingRenderSettings, err := cli.api.Prompt.ReadRendering(cmd.Context(), management.PromptType(ScreenPromptMap[input.screenName]), management.ScreenName(input.screenName))
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch the existing render settings: %w", err)
+	}
+
+	if existingRenderSettings != nil {
+		readRenderingJSON, _ := json.MarshalIndent(existingRenderSettings, "", "  ")
+		if err := json.Unmarshal(readRenderingJSON, &existingSettings); err != nil {
+			cli.renderer.Warnf("Error parsing fetched rendering JSON: %v", err)
+		}
+	}
+
+	existingSettings["___customization guide___"] = "https://github.com/auth0/auth0-cli/blob/main/CUSTOMIZATION_GUIDE.md"
+	// Error handling omitted for brevity.
+	finalJSON, _ := json.MarshalIndent(existingSettings, "", "  ")
+
+	err = rendererScript.OpenEditor(cmd, &userRenderSettings, string(finalJSON), input.screenName+".json", cli.customizeEditorHint)
+	if err != nil {
+		return nil, fmt.Errorf("failed to capture input from the editor: %w", err)
+	}
+
+	err = json.Unmarshal([]byte(userRenderSettings), &currentSettings)
+	if err != nil {
+		return nil, fmt.Errorf("failed to unmarshal JSON input into a map: %w", err)
+	}
+
+	// Compare the existing settings with the updated settings to detect changes.
+	if jsonEqual(existingSettings, currentSettings) {
+		cli.renderer.Warnf("No changes detected in the customization settings. This could be due to uncommitted configuration changes or no modifications being made to the configurations.")
+
+		return existingRenderSettings, ErrNoChangesDetected
+	}
+
+	if err := json.Unmarshal([]byte(userRenderSettings), &renderSettings); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal JSON input: %w", err)
+	}
+
+	return renderSettings, nil
+}
+
+// jsonEqual ignores the special "___customization guide___" key used for user reference.
+func jsonEqual(a, b map[string]interface{}) bool {
+	copyA := make(map[string]interface{}, len(a))
+	copyB := make(map[string]interface{}, len(b))
+	for k, v := range a {
+		if k != "___customization guide___" {
+			copyA[k] = v
+		}
+	}
+	for k, v := range b {
+		if k != "___customization guide___" {
+			copyB[k] = v
+		}
+	}
+
+	aj, err1 := json.Marshal(copyA)
+	bj, err2 := json.Marshal(copyB)
+	if err1 != nil || err2 != nil {
+		return false
+	}
+	return bytes.Equal(aj, bj)
+}
+
+func aculConfigListCmd(cli *cli) *cobra.Command {
+	var (
+		fields        string
+		includeFields bool
+		includeTotals bool
+		page          int
+		perPage       int
+		promptName    string
+		screen        string
+		renderingMode string
+		query         string
+	)
+
+	cmd := &cobra.Command{
+		Use:     "list",
+		Aliases: []string{"ls"},
+		Short:   "List Universal Login rendering configurations",
+		Long:    "List Universal Login rendering configurations with optional filters and pagination.",
+		Example: `  auth0 acul config list --prompt reset-password
+  auth0 acul config list --rendering-mode advanced --include-fields true --fields head_tags,context_configuration`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			ctx := cmd.Context()
+			if err := ensureACULPrerequisites(ctx, cli.api); err != nil {
+				return err
+			}
+
+			params := []management.RequestOption{
+				management.Parameter("page", strconv.Itoa(page)),
+				management.Parameter("per_page", strconv.Itoa(perPage)),
+			}
+
+			if query != "" {
+				params = append(params, management.Parameter("q", query))
+			}
+			if includeFields && fields != "" {
+				params = append(params, management.IncludeFields(fields))
+			}
+			if !includeFields && fields != "" {
+				params = append(params, management.ExcludeFields(fields))
+			}
+			if screen != "" {
+				params = append(params, management.Parameter("screen", screen))
+			}
+			if promptName != "" {
+				params = append(params, management.Parameter("prompt", promptName))
+			}
+			if renderingMode != "" {
+				params = append(params, management.Parameter("rendering_mode", renderingMode))
+			}
+
+			var results *management.PromptRenderingList
+			if err := ansi.Waiting(func() (err error) {
+				results, err = cli.api.Prompt.ListRendering(cmd.Context(), params...)
+				return err
+			}); err != nil {
+				cli.renderer.Errorf("Failed to list rendering configurations: %v", err)
+				return err
+			}
+
+			cli.renderer.ACULConfigList(results)
+
+			return nil
+		},
+	}
+
+	cmd.Flags().BoolVar(&cli.json, "json", false, "Output in json format.")
+	cmd.Flags().BoolVar(&cli.jsonCompact, "json-compact", false, "Output in compact json format.")
+	cmd.MarkFlagsMutuallyExclusive("json", "json-compact")
+
+	fieldsFlag.RegisterString(cmd, &fields, "")
+	includeFieldsFlag.RegisterBool(cmd, &includeFields, true)
+	includeTotalsFlag.RegisterBool(cmd, &includeTotals, false)
+	pageFlag.RegisterInt(cmd, &page, 0)
+	perPageFlag.RegisterInt(cmd, &perPage, 50)
+	promptFlag.RegisterString(cmd, &promptName, "")
+	screenFlag.RegisterString(cmd, &screen, "")
+	renderingModeFlag.RegisterString(cmd, &renderingMode, "")
+	queryFlag.RegisterString(cmd, &query, "")
+
+	return cmd
+}
+
+func aculConfigDocsCmd(cli *cli) *cobra.Command {
+	return &cobra.Command{
+		Use:     "docs",
+		Short:   "Open the ACUL configuration documentation",
+		Long:    "Open the documentation for configuring Advanced Customizations for Universal Login screens.",
+		Example: `  auth0 acul config docs`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			url := "https://auth0.com/docs/customize/login-pages/advanced-customizations/getting-started/configure-acul-screens"
+			cli.renderer.Infof("Opening documentation: %s", url)
+			return browser.OpenURL(url)
+		},
+	}
+}
+
+func (c *cli) customizeEditorHint() {
+	c.renderer.Infof("%s Once you close the editor, the shown settings will be saved. To cancel, press CTRL+C.", ansi.Faint("Hint:"))
+}
diff --git a/internal/cli/acul_dev.go b/internal/cli/acul_dev.go
new file mode 100644
index 000000000..cd8689ecd
--- /dev/null
+++ b/internal/cli/acul_dev.go
@@ -0,0 +1,860 @@
+package cli
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"net"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path/filepath"
+	"reflect"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/auth0/go-auth0/management"
+	"github.com/fsnotify/fsnotify"
+	"github.com/pkg/browser"
+	"github.com/spf13/cobra"
+
+	"github.com/auth0/auth0-cli/internal/ansi"
+	"github.com/auth0/auth0-cli/internal/auth0"
+	"github.com/auth0/auth0-cli/internal/prompt"
+)
+
+var (
+	projectDirFlag = Flag{
+		Name:       "Project Directory",
+		LongForm:   "dir",
+		ShortForm:  "d",
+		Help:       "Path to the ACUL project directory (must contain package.json).",
+		IsRequired: false,
+	}
+	screenDevFlag = Flag{
+		Name:         "Screens",
+		LongForm:     "screens",
+		ShortForm:    "s",
+		Help:         "Specific screens to develop and watch.",
+		IsRequired:   false,
+		AlwaysPrompt: false,
+	}
+
+	portFlag = Flag{
+		Name:       "Port",
+		LongForm:   "port",
+		ShortForm:  "p",
+		Help:       "Port for the local development server.",
+		IsRequired: false,
+	}
+
+	connectedFlag = Flag{
+		Name:       "Connected",
+		LongForm:   "connected",
+		ShortForm:  "c",
+		Help:       "Enable connected mode to update advance rendering settings of Auth0 tenant. Use only on stage/dev tenants.",
+		IsRequired: false,
+	}
+)
+
+func aculDevCmd(cli *cli) *cobra.Command {
+	var projectDir, port string
+	var screenDirs []string
+	var connected bool
+
+	cmd := &cobra.Command{
+		Use:   "dev",
+		Short: "Start development mode for ACUL project with automatic building and asset watching.",
+		Long: `Start development mode for an ACUL project. This command:
+- Runs 'npm run build' to build the project initially
+- Watches the dist directory for asset changes
+- Automatically patches screen assets when new builds are created
+- Supports both single screen development and all screens
+
+The project directory must contain package.json with a build script.
+
+DEV MODE (default):
+- Requires: --port flag for the local development server
+- Runs your build process (e.g., npm run screen <name>) for HMR development
+
+CONNECTED MODE (--connected):
+- Requires: --screens flag to specify screens to patch in Auth0 tenant  
+- Updates advance rendering settings of the chosen screens in your Auth0 tenant
+- Runs initial build and expects you to host assets locally
+- Optionally runs build:watch in the background for continuous asset updates
+- Watches and patches assets automatically when changes are detected
+
+⚠️  Connected mode should only be used on stage/dev tenants, not production!`,
+		Example: `  # Dev mode
+  auth0 acul dev --port 55444
+  auth0 acul dev -p 55444 --dir ./my_project
+  
+  # Connected mode
+  auth0 acul dev --connected
+  auth0 acul dev --connected --debug --dir ./my_project
+  auth0 acul dev --connected --screens all
+  auth0 acul dev -c --dir ./my_project
+  auth0 acul dev --connected --screens login-id
+  auth0 acul dev -c -s login-id,signup`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := ensureACULPrerequisites(cmd.Context(), cli.api); err != nil {
+				return err
+			}
+
+			checkNodeVersion(cli)
+
+			pwd, err := os.Getwd()
+			if err != nil {
+				return fmt.Errorf("failed to get current directory: %v", err)
+			}
+
+			if projectDir == "" {
+				err = projectDirFlag.Ask(cmd, &projectDir, &pwd)
+				if err != nil {
+					return err
+				}
+			} else {
+				fmt.Printf("📂 Project: %s\n", ansi.Yellow(projectDir))
+			}
+
+			if err = validateAculProject(projectDir); err != nil {
+				return fmt.Errorf("invalid ACUL project: %w", err)
+			}
+
+			if connected {
+				if confirmed := showConnectedModeInformation(); !confirmed {
+					fmt.Println(ansi.Red("Connected mode cancelled."))
+					return nil
+				}
+
+				fmt.Println("")
+				fmt.Println("⚠️  " + ansi.Bold(ansi.Yellow("🌟 CONNECTED MODE ENABLED 🌟")))
+				fmt.Println("")
+
+				screensToWatch, err := selectScreensSimple(cli, projectDir, screenDirs)
+				if err != nil {
+					return fmt.Errorf("failed to determine screens to watch: %w", err)
+				}
+
+				return runConnectedMode(cmd.Context(), cli, projectDir, port, screensToWatch)
+			}
+
+			if port == "" {
+				err = portFlag.Ask(cmd, &port, auth0.String("55444"))
+				if err != nil {
+					return err
+				}
+			} else {
+				fmt.Printf("🖥️ Server: %s\n", ansi.Cyan(fmt.Sprintf("http://localhost:%s", port)))
+			}
+			return runNormalMode(cli, projectDir, port)
+		},
+	}
+
+	projectDirFlag.RegisterString(cmd, &projectDir, "")
+	screenDevFlag.RegisterStringSlice(cmd, &screenDirs, nil)
+	portFlag.RegisterString(cmd, &port, "")
+	connectedFlag.RegisterBool(cmd, &connected, false)
+
+	return cmd
+}
+
+func runNormalMode(cli *cli, projectDir, port string) error {
+	if !isPortFree(port) {
+		return fmt.Errorf("port %s is already in use; please free it or choose another port", port)
+	}
+
+	// 1. Set up the command.
+	cmd := exec.Command("npm", "run", "dev", "--", "--port", port)
+	cmd.Dir = projectDir
+
+	// 2. Set up output pipes/redirection.
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		return fmt.Errorf("failed to capture stdout: %w", err)
+	}
+
+	if cli.debug {
+		cmd.Stderr = os.Stderr
+		fmt.Println("\n🔄 Executing:", ansi.Cyan("npm run dev -- --port "+port))
+	}
+
+	// 3. Start the command asynchronously.
+	if err := cmd.Start(); err != nil {
+		return fmt.Errorf("failed to start 'npm run dev -- --port %s': %w", port, err)
+	}
+
+	// 4. Print the success/info logs immediately after starting the server process.
+	server := fmt.Sprintf("http://localhost:%s", port)
+
+	// 5. Wait for the command to exit and handle intentional stops (Ctrl+C).
+	readyChan := make(chan struct{})
+	go func() {
+		scanner := bufio.NewScanner(stdout)
+		for scanner.Scan() {
+			line := scanner.Text()
+			fmt.Println(line)
+			if strings.Contains(line, "Local:") && strings.Contains(line, "http") {
+				close(readyChan)
+				return
+			}
+		}
+	}()
+
+	select {
+	case <-readyChan:
+		fmt.Println("💡 " + ansi.Italic("Make changes to your code and view the live changes as we have HMR enabled!"))
+		_ = browser.OpenURL(server)
+
+	case <-time.After(20 * time.Second):
+		fmt.Println("⏳ Dev server is taking longer than expected to start...")
+	}
+
+	if err = cmd.Wait(); err != nil {
+		if exitErr, ok := err.(*exec.ExitError); ok && exitErr.ExitCode() == 130 {
+			fmt.Println(ansi.Bold("\n👋 Server stopped intentionally (Ctrl+C)."))
+			return nil
+		}
+
+		return fmt.Errorf("dev server exited with an error: %w", err)
+	}
+
+	fmt.Println(ansi.Bold("\n'npm run dev' finished gracefully."))
+	return nil
+}
+
+func showConnectedModeInformation() bool {
+	fmt.Println("")
+	fmt.Println("📢 " + ansi.Bold(ansi.Cyan("Connected Mode Information")))
+	fmt.Println("")
+	fmt.Println("ℹ️  " + ansi.Cyan("This mode updates advanced rendering settings for selected screens in your Auth0 tenant."))
+	fmt.Println("")
+	fmt.Println("🚨 " + ansi.Bold(ansi.Red("IMPORTANT: Never use on production tenants!")))
+	fmt.Println("    " + ansi.Yellow("• Production may break sessions or incur unexpected charges with local assets."))
+	fmt.Println("    " + ansi.Yellow("• Use ONLY for dev/stage tenants."))
+
+	fmt.Println("")
+	fmt.Println("⚙️  " + ansi.Bold(ansi.Magenta("Technical Requirements:")))
+	fmt.Println("    " + ansi.Cyan("• Requires sample apps with viteConfig.ts configured for asset building"))
+	fmt.Println("    " + ansi.Cyan("• Assets must be built in the following structure:"))
+	fmt.Println("      " + ansi.Green("	assets/<screens>/"))
+	fmt.Println("      " + ansi.Green("	assets/<shared>/"))
+	fmt.Println("      " + ansi.Green("	assets/<main.*.js>"))
+	fmt.Println("")
+	fmt.Println("🔄  " + ansi.Bold(ansi.Magenta("How it works:")))
+	fmt.Println("    " + ansi.Cyan("• Combines files from screen-specific, shared, and main asset folders"))
+	fmt.Println("    " + ansi.Cyan("• Makes API patch calls to update rendering settings for each specified screen"))
+	fmt.Println("    " + ansi.Cyan("• Watches for changes and automatically re-patches when assets are rebuilt"))
+	fmt.Println("")
+
+	return prompt.Confirm("Proceed with connected mode?")
+}
+
+// isPortFree returns true if port is free (no TCP connection possible).
+func isPortFree(port string) bool {
+	addr := net.JoinHostPort("127.0.0.1", port)
+	conn, err := net.DialTimeout("tcp", addr, 250*time.Millisecond)
+	if err != nil {
+		return true
+	}
+
+	conn.Close()
+	// Dial succeeded -> something is listening -> not free.
+	return false
+}
+
+func runConnectedMode(ctx context.Context, cli *cli, projectDir, port string, screensToWatch []string) error {
+	fmt.Println("\n🚀 " + ansi.Green("ACUL connected dev mode started for: "+ansi.Cyan(projectDir)))
+
+	// Step 1: Do initial build.
+	fmt.Println("")
+	fmt.Println("🔨 " + ansi.Bold(ansi.Blue("Step 1: Running initial build with 'npm run build'")))
+	if err := buildProject(cli, projectDir); err != nil {
+		return fmt.Errorf("initial build failed: %w", err)
+	}
+
+	// Always validate screens after build to ensure they have actual built assets.
+	screensToWatch, err := validateScreensAfterBuild(projectDir, screensToWatch)
+	if err != nil {
+		return fmt.Errorf("screen validation failed after build: %w", err)
+	}
+
+	// Step 2: Ask user to host assets and get port confirmation.
+	fmt.Println("")
+	fmt.Println("📡 " + ansi.Bold(ansi.Blue("Step 2: Host your assets locally")))
+
+	if port == "" {
+		var portInput string
+
+		portQuestion := prompt.TextInput("port", "Enter port to serve assets:", "Example: 55444", "55444", true)
+		if err := prompt.AskOne(portQuestion, &portInput); err != nil {
+			return fmt.Errorf("failed to get port: %w", err)
+		}
+
+		if _, err = strconv.Atoi(portInput); err != nil {
+			return fmt.Errorf("invalid port number: %s", portInput)
+		}
+
+		port = portInput
+	}
+
+	if !isPortFree(port) {
+		return fmt.Errorf("port %s is already in use; please free it or choose another port", port)
+	}
+
+	fmt.Println("💡 " + ansi.Yellow("Your assets must be served locally with CORS enabled."))
+
+	runServe := prompt.Confirm(fmt.Sprintf("Would you like to host the assets by running 'npx serve dist -p %s --cors' in the background?", port))
+
+	var serveStarted bool
+
+	if runServe {
+		fmt.Println("🚀 " + ansi.Cyan("Starting local server in the background..."))
+
+		serveCmd := exec.Command("npx", "serve", "dist", "-p", port, "--cors")
+		serveCmd.Dir = projectDir
+
+		if cli.debug {
+			serveCmd.Stdout = os.Stdout
+			serveCmd.Stderr = os.Stderr
+		}
+
+		if err := serveCmd.Start(); err != nil {
+			fmt.Println("⚠️  " + ansi.Yellow("Failed to start local server: ") + ansi.Bold(err.Error()))
+			fmt.Println("    You can manually run " + ansi.Cyan(fmt.Sprintf("'npx serve dist -p %s --cors'", port)) + " in a separate terminal.")
+		} else {
+			serveStarted = true
+			fmt.Println("✅ " + ansi.Green("Local server started successfully at ") +
+				ansi.Cyan(fmt.Sprintf("http://localhost:%s", port)))
+			time.Sleep(2 * time.Second) // Give server time to start.
+		}
+	} else {
+		fmt.Println("Please either run the following command in a separate terminal to serve your assets or host someway on your own")
+		fmt.Println("    " + ansi.Bold(ansi.Green(fmt.Sprintf("npx serve dist -p %s --cors", port))))
+		fmt.Println("")
+		fmt.Println("This will serve your built assets at the specified port with CORS enabled.")
+	}
+
+	assetsURL := fmt.Sprintf("http://localhost:%s", port)
+
+	// Only ask confirmation if not started in background.
+	if !serveStarted {
+		assetsHosted := prompt.Confirm(fmt.Sprintf("Are your assets hosted and accessible at %s?", assetsURL))
+		if !assetsHosted {
+			cli.renderer.Warnf("❌ Please host your assets first and run the command again.")
+			return nil
+		}
+	}
+
+	// Step 3: Ask about build:watch.
+	fmt.Println("")
+	fmt.Println("🔧 " + ansi.Bold(ansi.Blue("Step 3: Continuous build watching (optional)")))
+	fmt.Println("    " + ansi.Green("1. Manually run 'npm run build' after changes, OR"))
+	fmt.Println("    " + ansi.Green("2. Run 'npm run build:watch' for continuous updates"))
+	fmt.Println("")
+	fmt.Println("💡 " + ansi.Yellow("If auto-save is enabled in your IDE, build:watch will rebuild frequently."))
+
+	runBuildWatch := prompt.Confirm("Would you like to run 'npm run build:watch' in the background?")
+
+	if runBuildWatch {
+		fmt.Println("🚀 " + ansi.Cyan("Starting 'npm run build:watch' in the background..."))
+		buildWatchCmd := exec.Command("npm", "run", "build:watch")
+		buildWatchCmd.Dir = projectDir
+
+		// Only show command output if debug mode is enabled.
+		if cli.debug {
+			buildWatchCmd.Stdout = os.Stdout
+			buildWatchCmd.Stderr = os.Stderr
+		}
+
+		if err := buildWatchCmd.Start(); err != nil {
+			fmt.Println("⚠️  " + ansi.Yellow("Failed to start build:watch: ") + ansi.Bold(err.Error()))
+			fmt.Println("    You can manually run " + ansi.Cyan("'npm run build'") + " whenever you update your code.")
+		} else {
+			fmt.Println("✅ " + ansi.Green("Build watch started successfully"))
+		}
+	}
+
+	fmt.Println("")
+	fmt.Println("👀 " + ansi.Bold(ansi.Blue("Step 4: Start watching assets and auto-patching...")))
+
+	distPath := filepath.Join(projectDir, "dist")
+
+	fmt.Println("🌐 Assets URL: " + ansi.Green(assetsURL))
+	fmt.Println("👀 Watching screens: " + ansi.Cyan(strings.Join(screensToWatch, ", ")))
+
+	// Fetch original head tags before starting watcher.
+	fmt.Println("💡 " + ansi.Yellow("Note: Your original rendering settings will be saved and can be restored on exit."))
+	originalHeadTags, err := fetchOriginalHeadTags(ctx, cli, screensToWatch)
+	if err != nil {
+		fmt.Println("⚠️  " + ansi.Yellow(fmt.Sprintf("Could not fetch original settings: %v", err)))
+		fmt.Println("    " + ansi.Yellow("Restoration will be skipped since no previous settings could be retrieved."))
+		originalHeadTags = nil // Continue without restoration capability.
+	} else {
+		fmt.Println("✅ " + ansi.Green(fmt.Sprintf("Saved original settings for %d screen(s)", len(originalHeadTags))))
+	}
+
+	fmt.Println()
+	fmt.Println(ansi.Magenta("💡 Tips:"))
+	fmt.Println(ansi.Cyan("  • Assets in '/dist/assets' are continuously monitored and patched when changes occur."))
+	fmt.Println(ansi.Cyan("  • Run 'auth0 test login' anytime to preview your changes in real-time."))
+	fmt.Println(ansi.Cyan("  • Press Ctrl+C to stop. You'll be prompted to restore your original settings."))
+	fmt.Println()
+
+	return watchAndPatch(ctx, cli, assetsURL, distPath, screensToWatch, originalHeadTags)
+}
+
+func validateAculProject(projectDir string) error {
+	packagePath := filepath.Join(projectDir, "package.json")
+	if _, err := os.Stat(packagePath); os.IsNotExist(err) {
+		return fmt.Errorf("package.json not found. This doesn't appear to be a valid ACUL project")
+	}
+	return nil
+}
+
+func buildProject(cli *cli, projectDir string) error {
+	cmd := exec.Command("npm", "run", "build")
+	cmd.Dir = projectDir
+
+	// Only show command output if debug mode is enabled.
+	if cli.debug {
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+	}
+
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("build failed: %w", err)
+	}
+
+	fmt.Println("✅ " + ansi.Green("Build completed successfully"))
+	return nil
+}
+
+func selectScreensSimple(cli *cli, projectDir string, screenDirs []string) ([]string, error) {
+	// 1. Screens provided via --screens flag.
+	if len(screenDirs) > 0 {
+		if len(screenDirs) == 1 && screenDirs[0] == "all" {
+			cli.renderer.Infof(ansi.Cyan("📂  Selecting all screens from src/screens"))
+
+			return getScreensFromSrcFolder(filepath.Join(projectDir, "src", "screens"))
+		}
+
+		return screenDirs, nil
+	}
+
+	// 2. No --screens flag: auto-detect from src/screens.
+	srcScreensPath := filepath.Join(projectDir, "src", "screens")
+
+	if availableScreens, err := getScreensFromSrcFolder(srcScreensPath); err == nil && len(availableScreens) > 0 {
+		return validateAndSelectScreens(cli, availableScreens, nil, true)
+	}
+
+	return nil, fmt.Errorf(`no screens found in project.
+
+Please either:
+1. Specify screens using --screens flag: auth0 acul dev --connected --screens login-id,signup
+2. Create a new ACUL project: auth0 acul init
+3. Ensure your project has screens in src/screens/ folder`)
+}
+
+func validateScreensAfterBuild(projectDir string, selectedScreens []string) ([]string, error) {
+	distAssetsPath := filepath.Join(projectDir, "dist", "assets")
+
+	availableScreens, err := getScreensFromDistAssets(distAssetsPath)
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to read available screens from dist/assets: %w", err)
+	}
+
+	if len(availableScreens) == 0 {
+		return nil, fmt.Errorf("no valid screens found in dist/assets after build")
+	}
+
+	availableScreensMap := make(map[string]bool)
+
+	for _, screen := range availableScreens {
+		availableScreensMap[screen] = true
+	}
+
+	var validScreens, missingScreens []string
+
+	for _, screen := range selectedScreens {
+		if availableScreensMap[screen] {
+			validScreens = append(validScreens, screen)
+		} else {
+			missingScreens = append(missingScreens, screen)
+		}
+	}
+
+	if len(missingScreens) > 0 {
+		return nil, fmt.Errorf("⚠️  Missing built assets for: %s", strings.Join(missingScreens, ", "))
+	}
+
+	if len(validScreens) == 0 {
+		return nil, fmt.Errorf(
+			"none of the selected screens were built. Available built screens: %s",
+			strings.Join(availableScreens, ", "),
+		)
+	}
+
+	return validScreens, nil
+}
+
+// getScreensFromDistAssets reads screen names from dist/assets folder.
+func getScreensFromDistAssets(distAssetsPath string) ([]string, error) {
+	if _, err := os.Stat(distAssetsPath); os.IsNotExist(err) {
+		return nil, fmt.Errorf("dist/assets not found")
+	}
+
+	dirs, err := os.ReadDir(distAssetsPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read dist/assets: %w", err)
+	}
+
+	var screens []string
+	for _, d := range dirs {
+		if d.IsDir() && d.Name() != "shared" {
+			screens = append(screens, d.Name())
+		}
+	}
+
+	return screens, nil
+}
+
+// getScreensFromSrcFolder reads screen names from src/screens folder.
+func getScreensFromSrcFolder(srcScreensPath string) ([]string, error) {
+	if _, err := os.Stat(srcScreensPath); os.IsNotExist(err) {
+		return nil, fmt.Errorf("src/screens not found")
+	}
+
+	entries, err := os.ReadDir(srcScreensPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read src/screens: %w", err)
+	}
+
+	var screens []string
+	for _, entry := range entries {
+		if entry.IsDir() {
+			screens = append(screens, entry.Name())
+		}
+	}
+
+	return screens, nil
+}
+
+// fetchOriginalHeadTags retrieves the current rendering settings for all screens before making changes.
+func fetchOriginalHeadTags(ctx context.Context, cli *cli, screensToWatch []string) (map[string][]interface{}, error) {
+	originalTags := make(map[string][]interface{})
+
+	existing, err := cli.api.Prompt.ListRendering(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	promptRenderingMap := make(map[string]*management.PromptRendering, len(existing.PromptRenderings))
+	for _, r := range existing.PromptRenderings {
+		if r.Prompt != nil && r.Screen != nil {
+			key := string(*r.Prompt) + "|" + string(*r.Screen)
+			promptRenderingMap[key] = r
+		}
+	}
+
+	// Collect only requested screens.
+	for _, screen := range screensToWatch {
+		promptType := management.PromptType(ScreenPromptMap[screen])
+		screenType := management.ScreenName(screen)
+		key := string(promptType) + "|" + string(screenType)
+
+		if r := promptRenderingMap[key]; r != nil && r.HeadTags != nil {
+			originalTags[screen] = r.HeadTags
+		}
+	}
+
+	return originalTags, nil
+}
+
+func applyPromptRenderings(ctx context.Context, cli *cli, screenTagMap map[string][]interface{}, debugPrefix string) error {
+	var updates []*management.PromptRendering
+	for screen, headTags := range screenTagMap {
+		p := management.PromptType(ScreenPromptMap[screen])
+		s := management.ScreenName(screen)
+		updates = append(updates, &management.PromptRendering{
+			Prompt:        &p,
+			Screen:        &s,
+			RenderingMode: &management.RenderingModeAdvanced,
+			HeadTags:      headTags,
+		})
+	}
+
+	if len(updates) == 0 {
+		return fmt.Errorf("no renderings to apply")
+	}
+
+	// Snapshot originals.
+	existing, err := cli.api.Prompt.ListRendering(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to fetch current renderings: %w", err)
+	}
+
+	promptRenderingMap := make(map[string]*management.PromptRendering, len(existing.PromptRenderings))
+	for _, r := range existing.PromptRenderings {
+		if r.Prompt != nil && r.Screen != nil {
+			promptRenderingMap[string(*r.Prompt)+"|"+string(*r.Screen)] = r
+		}
+	}
+
+	originals := make([]*management.PromptRendering, len(updates))
+	for i, u := range updates {
+		originals[i] = promptRenderingMap[string(*u.Prompt)+"|"+string(*u.Screen)]
+	}
+
+	const maxBatch = 20
+	doBatchedPatch := func(list []*management.PromptRendering) error {
+		return cli.api.Prompt.BulkUpdateRendering(ctx,
+			&management.PromptRenderingBulkUpdate{PromptRenderings: list})
+	}
+
+	// --- Batching loop with rollback awareness ---.
+	for i := 0; i < len(updates); i += maxBatch {
+		end := i + maxBatch
+		if end > len(updates) {
+			end = len(updates)
+		}
+
+		if err := doBatchedPatch(updates[i:end]); err != nil {
+			if debugPrefix == "Restoring" {
+				return fmt.Errorf("restore failed: %w", err)
+			}
+
+			if cli.debug {
+				cli.renderer.Errorf("%s batch %d-%d failed: %v", debugPrefix, i+1, end, err)
+				cli.renderer.Infof("%s rollback starting for screens 1-%d...", debugPrefix, i)
+			} else {
+				// Removed the redundant log: cli.renderer.Errorf("patch failed; rolling back...").
+				cli.renderer.Warnf("Patch failed. Attempting rollback...")
+			}
+
+			// Rollback all fully-applied previous batches.
+			for r := 0; r < i; r += maxBatch {
+				rEnd := r + maxBatch
+				if rEnd > i {
+					rEnd = i
+				}
+
+				if rbErr := doBatchedPatch(originals[r:rEnd]); rbErr != nil {
+					if cli.debug {
+						cli.renderer.Warnf("%s rollback failed for screens %d-%d: %v", debugPrefix, r+1, rEnd, rbErr)
+					} else {
+						cli.renderer.Warnf("Partial rollback failed for screens %d-%d.", r+1, rEnd)
+					}
+				} else {
+					if cli.debug {
+						cli.renderer.Infof("%s rollback restored screens %d-%d", debugPrefix, r+1, rEnd)
+					}
+				}
+			}
+
+			cli.renderer.Infof("Rollback complete for all applied batches.")
+
+			if cli.debug {
+				return fmt.Errorf("%s update failed at batch %d-%d: %w", debugPrefix, i+1, end, err)
+			}
+
+			return fmt.Errorf("%s failed: %w", debugPrefix, err)
+		}
+	}
+
+	return nil
+}
+
+func watchAndPatch(ctx context.Context, cli *cli, assetsURL, distPath string, screensToWatch []string, originalHeadTags map[string][]interface{}) error {
+	watcher, err := fsnotify.NewWatcher()
+	if err != nil {
+		return fmt.Errorf("failed to create file system watcher: %w", err)
+	}
+	defer watcher.Close()
+
+	if err := watcher.Add(distPath); err != nil {
+		return fmt.Errorf("failed to watch distribution path %s: %w", distPath, err)
+	}
+
+	fmt.Println("👀  Watching: " + ansi.Yellow(strings.Join(screensToWatch, ", ")))
+
+	// First, stop any existing global signal handlers (from root.go).
+	signal.Reset(os.Interrupt, syscall.SIGTERM)
+
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
+	defer signal.Stop(sigChan)
+
+	const debounceWindow = 5 * time.Second
+	var (
+		lastEventTime time.Time
+		lastHeadTags  = make(map[string][]interface{})
+	)
+
+	cleanup := func() {
+		time.Sleep(1 * time.Second)
+		fmt.Fprintln(os.Stderr, ansi.Yellow("\nShutting down ACUL connected mode..."))
+		if len(originalHeadTags) > 0 {
+			restore := prompt.Confirm("Would you like to restore your original rendering settings?")
+
+			if restore {
+				fmt.Fprintln(os.Stderr, ansi.Cyan("Restoring original rendering settings..."))
+
+				if err := applyPromptRenderings(ctx, cli, originalHeadTags, "Restoring"); err != nil {
+					fmt.Fprintln(os.Stderr, ansi.Yellow(fmt.Sprintf("Restoration failed: %v", err)))
+				} else {
+					fmt.Fprintln(os.Stderr, ansi.Green(fmt.Sprintf("Successfully restored rendering settings for %d screen(s).", len(originalHeadTags))))
+				}
+			} else {
+				fmt.Fprintln(os.Stderr, ansi.Yellow("Restoration skipped. The patched assets will continue to remain active in your Auth0 tenant."))
+			}
+		}
+
+		fmt.Println()
+		fmt.Fprintln(os.Stderr, ansi.Green("👋 ACUL connected mode stopped."))
+
+		fmt.Fprintf(os.Stderr, "%s  Use %s to see all available commands\n\n",
+			ansi.Yellow("💡 Tip:"), ansi.Cyan("auth0 acul --help"))
+	}
+
+	for {
+		select {
+		case event, ok := <-watcher.Events:
+			if !ok {
+				return nil
+			}
+
+			// Ignore non-asset events or irrelevant file ops.
+			if event.Op&(fsnotify.Write|fsnotify.Create) == 0 || !strings.Contains(event.Name, "assets") {
+				continue
+			}
+
+			now := time.Now()
+			if now.Sub(lastEventTime) < debounceWindow {
+				continue
+			}
+			lastEventTime = now
+
+			time.Sleep(500 * time.Millisecond) // Let writes settle.
+
+			newHeadTags := make(map[string][]interface{})
+			changedScreens := make([]string, 0)
+
+			for _, screen := range screensToWatch {
+				headTags, err := buildHeadTagsFromDirs(distPath, assetsURL, screen)
+				if err != nil {
+					if cli.debug {
+						cli.renderer.Warnf(ansi.Yellow(fmt.Sprintf("Skipping '%s': failed to build head tags: %v", screen, err)))
+					}
+					continue
+				}
+
+				// Compare with last known tags.
+				if reflect.DeepEqual(lastHeadTags[screen], headTags) {
+					continue
+				}
+
+				// Only record changed screens.
+				newHeadTags[screen] = headTags
+				changedScreens = append(changedScreens, screen)
+			}
+
+			if len(changedScreens) == 0 {
+				if cli.debug {
+					fmt.Println(ansi.Yellow("No effective asset changes detected, skipping patch."))
+				}
+				continue
+			}
+
+			if cli.debug {
+				fmt.Println(ansi.Cyan(fmt.Sprintf("🔄 Changes detected in %d screen(s): %s", len(changedScreens),
+					strings.Join(changedScreens, ", "))))
+			} else {
+				fmt.Println(ansi.Cyan("⚙️ Change detected, patching assets..."))
+			}
+
+			if err = applyPromptRenderings(ctx, cli, newHeadTags, "Patching"); err != nil {
+				cli.renderer.Errorf("Patching assets failed: %v", err)
+			} else {
+				fmt.Println(ansi.Green("✅ Assets patched successfully!"))
+				for screen, headTags := range newHeadTags {
+					lastHeadTags[screen] = headTags
+				}
+			}
+
+		case err := <-watcher.Errors:
+			cli.renderer.Warnf("File watcher internal error: %v", err)
+
+		case <-sigChan:
+			cleanup()
+			return nil
+
+		case <-ctx.Done():
+			cleanup()
+			return ctx.Err()
+		}
+	}
+}
+
+// buildHeadTagsFromDirs collects <script> and <link> tags from shared, screen-specific, and common asset directories.
+func buildHeadTagsFromDirs(distPath, assetsURL, screen string) ([]interface{}, error) {
+	searchDirs := []string{
+		filepath.Join(distPath, "assets", "shared"),
+		filepath.Join(distPath, "assets", screen),
+		filepath.Join(distPath, "assets"),
+	}
+
+	var tags []interface{}
+	for _, dir := range searchDirs {
+		entries, err := os.ReadDir(dir)
+		if err != nil {
+			continue
+		}
+
+		for _, e := range entries {
+			if e.IsDir() {
+				continue
+			}
+
+			ext := filepath.Ext(e.Name())
+			subDir := filepath.Base(dir)
+			if subDir == "assets" {
+				subDir = ""
+			}
+
+			src := fmt.Sprintf("%s/assets", assetsURL)
+			if subDir != "" {
+				src = fmt.Sprintf("%s/%s", src, subDir)
+			}
+			src = fmt.Sprintf("%s/%s", src, e.Name())
+
+			switch ext {
+			case ".js":
+				tags = append(tags, map[string]interface{}{
+					"tag": "script",
+					"attributes": map[string]interface{}{
+						"src":   src,
+						"defer": true,
+						"type":  "module",
+					},
+				})
+			case ".css":
+				tags = append(tags, map[string]interface{}{
+					"tag": "link",
+					"attributes": map[string]interface{}{
+						"href": src,
+						"rel":  "stylesheet",
+					},
+				})
+			}
+		}
+	}
+	if len(tags) == 0 {
+		return nil, fmt.Errorf("no .js or .css assets found for '%s'", screen)
+	}
+	return tags, nil
+}
diff --git a/internal/cli/acul_screen_scaffolding.go b/internal/cli/acul_screen_scaffolding.go
new file mode 100644
index 000000000..d79adf4bd
--- /dev/null
+++ b/internal/cli/acul_screen_scaffolding.go
@@ -0,0 +1,482 @@
+package cli
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/fs"
+	"log"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"github.com/auth0/auth0-cli/internal/ansi"
+	"github.com/auth0/auth0-cli/internal/prompt"
+)
+
+var destDirFlag = Flag{
+	Name:       "Destination Directory",
+	LongForm:   "dir",
+	ShortForm:  "d",
+	Help:       "Path to existing project directory (must contain `acul_config.json`)",
+	IsRequired: false,
+}
+
+func aculScreenAddCmd(cli *cli) *cobra.Command {
+	var destDir string
+	cmd := &cobra.Command{
+		Use:   "add",
+		Short: "Add screens to an existing project",
+		Long:  "Add screens to an existing project. The project must have been initialized using `auth0 acul init`.",
+		Example: `  auth0 acul screen add <screen-name> <screen-name>... --dir <app-directory>
+  auth0 acul screen add login-id login-password -d acul_app`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if err := ensureACULPrerequisites(cmd.Context(), cli.api); err != nil {
+				return err
+			}
+
+			pwd, err := os.Getwd()
+			if err != nil {
+				return fmt.Errorf("failed to get current directory: %v", err)
+			}
+
+			if len(destDir) < 1 {
+				err = destDirFlag.Ask(cmd, &destDir, &pwd)
+				if err != nil {
+					return err
+				}
+			}
+
+			return scaffoldAddScreen(cli, args, destDir)
+		},
+	}
+
+	destDirFlag.RegisterString(cmd, &destDir, "")
+
+	return cmd
+}
+
+// checkVersionCompatibility compares the user's ACUL config version with the latest available tag
+// and warns if the project version is missing or outdated.
+func checkVersionCompatibility(cli *cli, aculConfig *AculConfig, latestTag string) {
+	if aculConfig.AppVersion == "" {
+		cli.renderer.Warnf(
+			ansi.Yellow("⚠️  Missing app version in acul_config.json. Reinitialize your project with `auth0 acul init`."),
+		)
+		return
+	}
+
+	if aculConfig.AppVersion != latestTag {
+		compareLink := fmt.Sprintf(
+			"https://github.com/auth0-samples/auth0-acul-samples/compare/%s...%s",
+			aculConfig.AppVersion, latestTag,
+		)
+
+		cli.renderer.Warnf(
+			ansi.Yellow(fmt.Sprintf("⚠️  ACUL project version outdated (%s). Check updates: %s",
+				aculConfig.AppVersion, compareLink)),
+		)
+	}
+}
+
+func scaffoldAddScreen(cli *cli, args []string, destDir string) error {
+	aculConfig, err := loadAculConfig(filepath.Join(destDir, "acul_config.json"))
+
+	if err != nil {
+		if os.IsNotExist(err) {
+			cli.renderer.Warnf("couldn't find acul_config.json in destination directory. Please ensure you're in the right directory or have initialized the project using `auth0 acul init`")
+			return nil
+		}
+
+		return err
+	}
+
+	latestTag, err := getLatestReleaseTag()
+	if err != nil {
+		return fmt.Errorf("failed to get latest release tag: %w", err)
+	}
+
+	manifest, err := loadManifest(aculConfig.AppVersion)
+	if err != nil {
+		return err
+	}
+
+	checkVersionCompatibility(cli, aculConfig, latestTag)
+
+	selectedScreens, err := selectAndFilterScreens(cli, args, manifest, aculConfig.ChosenTemplate, aculConfig.Screens)
+	if err != nil {
+		return err
+	}
+
+	if err = addScreensToProject(cli, destDir, aculConfig.ChosenTemplate, selectedScreens, manifest.Templates[aculConfig.ChosenTemplate]); err != nil {
+		return err
+	}
+
+	runNpmGenerateScreenLoader(cli, destDir)
+
+	if err = updateAculConfigFile(destDir, aculConfig, selectedScreens); err != nil {
+		return err
+	}
+
+	showPostScaffoldingOutput(cli, destDir, "Screens added successfully")
+
+	return nil
+}
+
+func selectAndFilterScreens(cli *cli, args []string, manifest *Manifest, chosenTemplate string, existingScreens []string) ([]string, error) {
+	var availableScreenIDs []string
+	for _, s := range manifest.Templates[chosenTemplate].Screens {
+		availableScreenIDs = append(availableScreenIDs, s.ID)
+	}
+
+	selectedScreens, err := validateAndSelectScreens(cli, availableScreenIDs, args, true)
+	if err != nil {
+		return nil, err
+	}
+
+	var finalScreens []string
+	for _, s := range selectedScreens {
+		exists := false
+		for _, existing := range existingScreens {
+			if s == existing {
+				exists = true
+				break
+			}
+		}
+
+		if exists {
+			promptMsg := fmt.Sprintf("Screen '%s' already exists. Do you want to overwrite its directory? ", s)
+			if !prompt.Confirm(promptMsg) {
+				continue
+			}
+		}
+		finalScreens = append(finalScreens, s)
+	}
+
+	if len(finalScreens) == 0 {
+		return nil, fmt.Errorf("no valid screens selected after filtering existing screens")
+	}
+
+	return finalScreens, nil
+}
+
+func addScreensToProject(cli *cli, destDir, chosenTemplate string, selectedScreens []string, selectedTemplate Template) error {
+	tempUnzipDir, err := downloadAndUnzipSampleRepo()
+	if err != nil {
+		return err
+	}
+	defer os.RemoveAll(tempUnzipDir) // Clean up the entire temp directory.
+
+	extractedDir, err := findExtractedRepoDir(tempUnzipDir)
+	if err != nil {
+		return fmt.Errorf("failed to find extracted directory: %w", err)
+	}
+
+	sourcePathPrefix := filepath.Join(extractedDir, chosenTemplate)
+	var sourceRoot = filepath.Join(tempUnzipDir, sourcePathPrefix)
+	var destRoot = destDir
+
+	missingFiles, editedFiles, err := processFiles(cli, selectedTemplate.BaseFiles, sourceRoot, destRoot)
+	if err != nil {
+		log.Printf("Error processing base files: %v", err)
+	}
+
+	missingDirFiles, editedDirFiles, err := processDirectories(cli, selectedTemplate.BaseDirectories, sourceRoot, destRoot)
+	if err != nil {
+		log.Printf("Error processing base directories: %v", err)
+	}
+
+	editedFiles = append(editedFiles, editedDirFiles...)
+	missingFiles = append(missingFiles, missingDirFiles...)
+
+	// Filter out screenLoader.ts since it gets regenerated by runNpmGenerateScreenLoader.
+	filteredEditedFiles := filterOutScreenLoader(editedFiles)
+
+	err = handleEditedFiles(cli, filteredEditedFiles, sourceRoot, destRoot)
+	if err != nil {
+		return fmt.Errorf("error during backup/overwrite: %w", err)
+	}
+
+	err = handleMissingFiles(cli, missingFiles, tempUnzipDir, sourcePathPrefix, destDir)
+	if err != nil {
+		return fmt.Errorf("error copying missing files: %w", err)
+	}
+
+	return copyProjectScreens(cli, selectedTemplate.Screens, selectedScreens, chosenTemplate, tempUnzipDir, destDir)
+}
+
+func handleEditedFiles(cli *cli, edited []string, sourceRoot, destRoot string) error {
+	if len(edited) < 1 {
+		return nil
+	}
+
+	fmt.Println("Edited files/directories may be overwritten:")
+	for _, p := range edited {
+		fmt.Println("  ", p)
+	}
+
+	fmt.Println("⚠️ DISCLAIMER: Some required base files and directories have been edited.\n" +
+		"Your added screen(s) may NOT work correctly without these updates.\n" +
+		"Proceeding without overwriting could lead to inconsistent or unstable behavior.")
+
+	if !prompt.Confirm("Proceed with overwrite and backup? : ") {
+		cli.renderer.Warnf("User opted not to overwrite modified files.")
+		return nil
+	}
+
+	err := backupAndOverwrite(cli, edited, sourceRoot, destRoot)
+	if err != nil {
+		cli.renderer.Warnf("Error during backup and overwrite: %v\n", err)
+		return err
+	}
+
+	cli.renderer.Infof(ansi.Bold(ansi.Blue("Edited files backed up to back_up folder and overwritten.")))
+
+	return nil
+}
+
+// Copy missing files from source to destination.
+func handleMissingFiles(cli *cli, missing []string, tempUnzipDir, sourcePrefix, destDir string) error {
+	for _, baseFile := range missing {
+		srcPath := filepath.Join(tempUnzipDir, sourcePrefix, baseFile)
+		destPath := filepath.Join(destDir, baseFile)
+		if _, err := os.Stat(srcPath); os.IsNotExist(err) {
+			cli.renderer.Warnf("Warning: Source file does not exist: %s", srcPath)
+			continue
+		}
+
+		parentDir := filepath.Dir(destPath)
+		if err := os.MkdirAll(parentDir, 0755); err != nil {
+			cli.renderer.Warnf("Error creating parent dir for %s: %v", baseFile, err)
+			continue
+		}
+
+		if err := copyFile(srcPath, destPath); err != nil {
+			return fmt.Errorf("error copying file %s: %w", baseFile, err)
+		}
+	}
+	return nil
+}
+
+// backupAndOverwrite backs up edited files, then overwrites them with source files.
+func backupAndOverwrite(cli *cli, edited []string, sourceRoot, destRoot string) error {
+	backupRoot := filepath.Join(destRoot, "back_up")
+
+	// Remove existing backup folder if it exists.
+	if _, err := os.Stat(backupRoot); err == nil {
+		if err := os.RemoveAll(backupRoot); err != nil {
+			return fmt.Errorf("failed to clear existing backup folder: %w", err)
+		}
+	}
+
+	// Create a fresh backup folder.
+	if err := os.MkdirAll(backupRoot, 0755); err != nil {
+		return fmt.Errorf("failed to create backup directory: %w", err)
+	}
+
+	for _, relPath := range edited {
+		destFile := filepath.Join(destRoot, relPath)
+		backupFile := filepath.Join(backupRoot, relPath)
+		sourceFile := filepath.Join(sourceRoot, relPath)
+
+		if err := os.MkdirAll(filepath.Dir(backupFile), 0755); err != nil {
+			cli.renderer.Warnf("Failed to create backup directory for %s: %v", relPath, err)
+			continue
+		}
+
+		if err := copyFile(destFile, backupFile); err != nil {
+			cli.renderer.Warnf("Failed to backup file %s: %v", relPath, err)
+			continue
+		}
+
+		if err := copyFile(sourceFile, destFile); err != nil {
+			cli.renderer.Errorf("Failed to overwrite file %s: %v", relPath, err)
+			continue
+		}
+
+		cli.renderer.Infof("Overwritten: %s", relPath)
+	}
+	return nil
+}
+
+// processDirectories processes files in all base directories relative to chosenTemplate.
+func processDirectories(cli *cli, baseDirs []string, sourceRoot, destRoot string) (missing, edited []string, err error) {
+	for _, dir := range baseDirs {
+		sourceDir := filepath.Join(sourceRoot, dir)
+		files, listErr := listFilesInDir(sourceDir)
+		if listErr != nil {
+			err = fmt.Errorf("failed to list files in %s: %w", sourceDir, listErr)
+			return
+		}
+
+		for _, sourceFile := range files {
+			relPath, relErr := filepath.Rel(sourceRoot, sourceFile)
+			if relErr != nil {
+				continue
+			}
+
+			destFile := filepath.Join(destRoot, relPath)
+			editedFlag, compErr := isFileEdited(sourceFile, destFile)
+			switch {
+			case compErr != nil && os.IsNotExist(compErr):
+				missing = append(missing, relPath)
+			case compErr != nil:
+				cli.renderer.Warnf("Warning: failed to determine if file has been edited: %v", compErr)
+				continue
+			case editedFlag:
+				edited = append(edited, relPath)
+			}
+		}
+	}
+	return
+}
+
+func listFilesInDir(dir string) ([]string, error) {
+	var files []string
+	err := filepath.Walk(dir, func(path string, info fs.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if !info.IsDir() {
+			files = append(files, path)
+		}
+		return nil
+	})
+
+	return files, err
+}
+
+func processFiles(cli *cli, baseFiles []string, sourceRoot, destRoot string) (missing, edited []string, err error) {
+	for _, baseFile := range baseFiles {
+		sourcePath := filepath.Join(sourceRoot, baseFile)
+		destPath := filepath.Join(destRoot, baseFile)
+
+		editedFlag, err := isFileEdited(sourcePath, destPath)
+		switch {
+		case err != nil && os.IsNotExist(err):
+			missing = append(missing, baseFile)
+		case err != nil:
+			cli.renderer.Warnf("Warning: failed to determine if file has been edited: %v", err)
+			continue
+		case editedFlag:
+			edited = append(edited, baseFile)
+		}
+	}
+	return
+}
+
+func isFileEdited(source, dest string) (bool, error) {
+	sourceInfo, err := os.Stat(source)
+	if err != nil {
+		return false, err
+	}
+
+	destInfo, err := os.Stat(dest)
+	if os.IsNotExist(err) {
+		return true, nil
+	}
+
+	if err != nil {
+		return false, err
+	}
+
+	if sourceInfo.Size() != destInfo.Size() {
+		return true, nil
+	}
+
+	hashSource, err := fileHash(source)
+	if err != nil {
+		return false, err
+	}
+	hashDest, err := fileHash(dest)
+	if err != nil {
+		return false, err
+	}
+
+	return !bytes.Equal(hashSource, hashDest), nil
+}
+
+func fileHash(path string) ([]byte, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	h := sha256.New()
+	// Use buffered copy for performance.
+	if _, err := io.Copy(h, f); err != nil {
+		return nil, err
+	}
+	return h.Sum(nil), nil
+}
+
+// LoadAculConfig loads acul_config.json from the specified directory.
+func loadAculConfig(configPath string) (*AculConfig, error) {
+	data, err := os.ReadFile(configPath)
+	if err != nil {
+		return nil, err
+	}
+
+	var config AculConfig
+	err = json.Unmarshal(data, &config)
+	if err != nil {
+		return nil, err
+	}
+
+	return &config, nil
+}
+
+// addUniqueScreens ensures selectedScreens are added uniquely to cfg.Screens.
+func addUniqueScreens(cfg *AculConfig, selected []string) {
+	existingSet := make(map[string]bool, len(cfg.Screens))
+	for _, s := range cfg.Screens {
+		existingSet[s] = true
+	}
+
+	for _, s := range selected {
+		if !existingSet[s] {
+			cfg.Screens = append(cfg.Screens, s)
+			existingSet[s] = true
+		}
+	}
+}
+
+// updateAculConfigFile merges new screens into acul_config.json and updates metadata.
+func updateAculConfigFile(destDir string, cfg *AculConfig, selectedScreens []string) error {
+	if cfg == nil {
+		return fmt.Errorf("aculConfig cannot be nil")
+	}
+
+	addUniqueScreens(cfg, selectedScreens)
+	cfg.ModifiedAt = time.Now().UTC().Format(time.RFC3339)
+
+	configPath := filepath.Join(destDir, "acul_config.json")
+	data, err := json.MarshalIndent(cfg, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal acul_config.json: %w", err)
+	}
+
+	if err := os.WriteFile(configPath, data, 0644); err != nil {
+		return fmt.Errorf("failed to write acul_config.json: %w", err)
+	}
+
+	return nil
+}
+
+// since it gets regenerated by runNPMGenerate command anyway.
+func filterOutScreenLoader(editedFiles []string) []string {
+	var filtered []string
+	for _, file := range editedFiles {
+		// Skip only the specific screenLoader.ts file that gets regenerated.
+		normalizedPath := filepath.ToSlash(file)
+		if normalizedPath == "src/utils/screen/screenLoader.ts" {
+			continue
+		}
+		filtered = append(filtered, file)
+	}
+	return filtered
+}
diff --git a/internal/cli/input.go b/internal/cli/input.go
index 8b577f14f..bd7811486 100644
--- a/internal/cli/input.go
+++ b/internal/cli/input.go
@@ -5,6 +5,7 @@ import (
 	"os"
 	"reflect"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/AlecAivazis/survey/v2/terminal"
 	"github.com/auth0/go-auth0"
 
@@ -79,7 +80,14 @@ func _select(i commandInput, value interface{}, options []string, defaultValue *
 		defaultValue = &(options[0])
 	}
 
-	input := prompt.SelectInput("", i.GetLabel(), i.GetHelp(), options, auth0.StringValue(defaultValue), isRequired)
+	var input *survey.Question
+
+	// Use paginated select for large option sets (>15 options).
+	if len(options) > 15 {
+		input = prompt.PaginatedSelectInput("", i.GetLabel(), i.GetHelp(), options, auth0.StringValue(defaultValue), isRequired)
+	} else {
+		input = prompt.SelectInput("", i.GetLabel(), i.GetHelp(), options, auth0.StringValue(defaultValue), isRequired)
+	}
 
 	if err := prompt.AskOne(input, value); err != nil {
 		return handleInputError(err)
diff --git a/internal/cli/root.go b/internal/cli/root.go
index dafb9e176..918362f7c 100644
--- a/internal/cli/root.go
+++ b/internal/cli/root.go
@@ -154,6 +154,7 @@ func addSubCommands(rootCmd *cobra.Command, cli *cli) {
 	rootCmd.AddCommand(logoutCmd(cli))
 	rootCmd.AddCommand(tenantsCmd(cli))
 	rootCmd.AddCommand(appsCmd(cli))
+	rootCmd.AddCommand(aculCmd(cli))
 	rootCmd.AddCommand(usersCmd(cli))
 	rootCmd.AddCommand(rulesCmd(cli))
 	rootCmd.AddCommand(actionsCmd(cli))
diff --git a/internal/cli/universal_login.go b/internal/cli/universal_login.go
index 6e37e0f38..0bb88b86f 100644
--- a/internal/cli/universal_login.go
+++ b/internal/cli/universal_login.go
@@ -56,8 +56,16 @@ func universalLoginCmd(cli *cli) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "universal-login",
 		Short: "Manage the Universal Login experience",
-		Long: "Manage a consistent, branded Universal Login experience that can " +
-			"handle all of your authentication flows.",
+		Long: `Manage Universal Login branding and customization settings.
+
+� DEPRECATION WARNING: Advanced Customizations (ACUL) have moved!
+
+The 'auth0 ul customize --rendering-mode advanced' functionality will be 
+DEPRECATED on June 15, 2026. Please migrate to the new ACUL commands:
+
+  ✅ auth0 acul config generate|get|set|list|docs
+
+Standard Universal Login customizations continue to work as before.`,
 		Aliases: []string{"ul"},
 	}
 
diff --git a/internal/cli/universal_login_customize.go b/internal/cli/universal_login_customize.go
index ce7606297..c46da33d2 100644
--- a/internal/cli/universal_login_customize.go
+++ b/internal/cli/universal_login_customize.go
@@ -4,14 +4,11 @@ import (
 	"context"
 	"embed"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io/fs"
 	"net"
 	"net/http"
 	"net/url"
-	"os"
-	"reflect"
 	"strings"
 	"time"
 
@@ -39,8 +36,11 @@ const (
 	fetchPartialFeatureFlag  = "FETCH_PARTIALS_FEATURE_FLAG"
 	errorMessageType         = "ERROR"
 	successMessageType       = "SUCCESS"
-	advancedMode             = "advanced"
 	standardMode             = "standard"
+	advancedMode             = "advanced"
+
+	sunsetDate        = "2026-06-15" // 6 months from GA.
+	warningPeriodDays = 30           // Show urgent warnings 30 days before sunset.
 )
 
 var (
@@ -71,7 +71,7 @@ var (
 		IsRequired: true,
 	}
 
-	screenName = Flag{
+	screenNameFlag = Flag{
 		Name:       "Screen Name",
 		LongForm:   "screen",
 		ShortForm:  "s",
@@ -79,21 +79,13 @@ var (
 		IsRequired: true,
 	}
 
-	file = Flag{
+	fileFlag = Flag{
 		Name:       "File",
 		LongForm:   "settings-file",
 		ShortForm:  "f",
 		Help:       "File to save the rendering configs to.",
 		IsRequired: false,
 	}
-
-	rendererScript = Flag{
-		Name:       "Script",
-		LongForm:   "script",
-		ShortForm:  "s",
-		Help:       "Script contents for the rendering configs.",
-		IsRequired: true,
-	}
 )
 
 var allowedPromptsWithPartials = []management.PromptType{
@@ -106,7 +98,7 @@ var allowedPromptsWithPartials = []management.PromptType{
 	management.PromptLoginPasswordLess,
 }
 
-var ScreenPromptMap = map[string][]string{
+var PromptScreenMap = map[string][]string{
 	"signup-id":                   {"signup-id"},
 	"signup-password":             {"signup-password"},
 	"login-id":                    {"login-id"},
@@ -271,39 +263,33 @@ func (m *webSocketMessage) UnmarshalJSON(b []byte) error {
 }
 
 type promptScreen struct {
+	filePath   string
 	promptName string
 	screenName string
 }
 
-type customizationInputs struct {
-	promptScreen
-	filePath string
-}
-
 func customizeUniversalLoginCmd(cli *cli) *cobra.Command {
 	var (
 		selectedRenderingMode string
-		input                 customizationInputs
+		input                 promptScreen
 	)
 
 	cmd := &cobra.Command{
 		Use:   "customize",
 		Args:  cobra.NoArgs,
-		Short: "Customize the Universal Login experience for the standard or advanced mode",
-		Long: "\nCustomize your Universal Login Experience. Note that this requires a custom domain to be configured for the tenant. \n\n" +
+		Short: "⚠️ Customize Universal Login (Advanced mode DEPRECATED)",
+		Long: "\nCustomize your Universal Login Experience. Note that this requires a custom domain to be configured for the tenant.\n\n" +
 			"* Standard mode is recommended for creating a consistent, branded experience for users. Choosing Standard mode will open a webpage\n" +
-			"within your browser where you can edit and preview your branding changes.For a comprehensive list of editable parameters and their values,\n" +
-			"please visit the [Management API Documentation](https://auth0.com/docs/api/management/v2)\n\n" +
-			"* Advanced mode is recommended for full customization/granular control of the login experience and to integrate your own component design system. \n" +
-			"Choosing Advanced mode will open the default terminal editor, with the rendering configs:\n\n" +
-			"![storybook](settings.json)\n\nClosing the terminal editor will save the settings to your tenant.",
+			"  in your browser where you can edit and preview your branding changes. For a comprehensive list of editable parameters and their values,\n" +
+			"  please visit the Management API documentation: https://auth0.com/docs/api/management/v2\n\n" +
+			"⚠️  DEPRECATION NOTICE: Advanced mode will be deprecated on " + sunsetDate + "\n" +
+			"   For future Advanced Customizations, use: auth0 acul config <command>\n\n" +
+			"* Advanced mode is recommended for full customization and granular control of the login experience, allowing integration of your own component design system.\n" +
+			"  Choosing Advanced mode will open the default terminal editor with rendering configurations in a settings.json file.\n\n" +
+			"  Closing the terminal editor will save the settings to your tenant.",
+
 		Example: `  auth0 universal-login customize
-  auth0 ul customize
-  auth0 ul customize --rendering-mode standard
-  auth0 ul customize -r standard
-  auth0 ul customize --rendering-mode advanced --prompt login-id --screen login-id
-  auth0 ul customize --rendering-mode advanced --prompt login-id --screen login-id --settings-file settings.json
-  auth0 ul customize -r advanced -p login-id -s login-id -f settings.json`,
+  auth0 ul customize`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := cmd.Context()
 
@@ -315,17 +301,35 @@ func customizeUniversalLoginCmd(cli *cli) *cobra.Command {
 				return err
 			}
 
-			cli.renderer.Infof("Tip : Use `auth0 ul switch` to switch the rendering-modes between standard and advanced mode")
-
 			if selectedRenderingMode == "" {
 				cli.renderer.Infof("Please select a rendering mode to customize:")
-				if err := renderingMode.Select(cmd, &selectedRenderingMode, []string{advancedMode, standardMode}, nil); err != nil {
+				if err := renderingMode.Select(cmd, &selectedRenderingMode, []string{standardMode, advancedMode}, auth0.String(standardMode)); err != nil {
 					return err
 				}
 			}
 
 			if selectedRenderingMode == advancedMode {
-				return advanceCustomize(cmd, cli, input)
+				if err := displayDeprecationStatus(cli, true); err != nil {
+					return err
+				}
+
+				// Add visual separation and brief pause to ensure users see the warning.
+				cli.renderer.Output(ansi.Bold("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"))
+				cli.renderer.Output("")
+
+				if !cli.noInput {
+					time.Sleep(1 * time.Second) // Brief pause to let users read.
+				}
+
+				err := fetchPromptScreenInfo(cmd, cli, &input, "customize")
+				if err != nil {
+					return err
+				}
+
+				return advanceCustomize(cmd, cli, aculConfigInput{
+					screenName: input.screenName,
+					filePath:   input.filePath,
+				})
 			}
 
 			// RenderingMode as standard.
@@ -335,146 +339,34 @@ func customizeUniversalLoginCmd(cli *cli) *cobra.Command {
 
 	renderingMode.RegisterString(cmd, &selectedRenderingMode, "")
 	promptName.RegisterString(cmd, &input.promptName, "")
-	screenName.RegisterString(cmd, &input.screenName, "")
-	file.RegisterString(cmd, &input.filePath, "")
+	screenNameFlag.RegisterString(cmd, &input.screenName, "")
+	fileFlag.RegisterString(cmd, &input.filePath, "")
 
 	return cmd
 }
 
-func advanceCustomize(cmd *cobra.Command, cli *cli, input customizationInputs) error {
-	var currMode = standardMode
-
-	err := fetchPromptScreenInfo(cmd, cli, &input.promptScreen, "customize")
-	if err != nil {
-		return err
-	}
-
-	renderSettings, err := fetchRenderSettings(cmd, cli, input)
-	if renderSettings != nil && renderSettings.RenderingMode != nil {
-		currMode = string(*renderSettings.RenderingMode)
-	}
-
-	if errors.Is(err, ErrNoChangesDetected) {
-		cli.renderer.Infof("Current rendering mode for Prompt '%s' and Screen '%s': %s",
-			ansi.Green(input.promptName), ansi.Green(input.screenName), ansi.Green(currMode))
-		return nil
-	}
-
-	if err != nil {
-		return err
-	}
-
-	if err = ansi.Waiting(func() error {
-		return cli.api.Prompt.UpdateRendering(cmd.Context(), management.PromptType(input.promptName), management.ScreenName(input.screenName), renderSettings)
-	}); err != nil {
-		return fmt.Errorf("failed to set the render settings: %w", err)
-	}
-
-	cli.renderer.Infof(
-		"Successfully updated the rendering settings.\n Current rendering mode for Prompt '%s' and Screen '%s': %s",
-		ansi.Green(input.promptName),
-		ansi.Green(input.screenName),
-		ansi.Green(currMode),
-	)
-
-	return nil
-}
-
 func fetchPromptScreenInfo(cmd *cobra.Command, cli *cli, input *promptScreen, action string) error {
 	if input.promptName == "" {
 		cli.renderer.Infof("Please select a prompt to %s its rendering mode:", action)
-		if err := promptName.Select(cmd, &input.promptName, utils.FetchKeys(ScreenPromptMap), nil); err != nil {
+		if err := promptName.Select(cmd, &input.promptName, utils.FetchKeys(PromptScreenMap), nil); err != nil {
 			return handleInputError(err)
 		}
 	}
 
 	if input.screenName == "" {
-		if len(ScreenPromptMap[input.promptName]) > 1 {
+		if len(PromptScreenMap[input.promptName]) > 1 {
 			cli.renderer.Infof("Please select a screen to %s its rendering mode:", action)
-			if err := screenName.Select(cmd, &input.screenName, ScreenPromptMap[input.promptName], nil); err != nil {
+			if err := screenName.Select(cmd, &input.screenName, PromptScreenMap[input.promptName], nil); err != nil {
 				return handleInputError(err)
 			}
 		} else {
-			input.screenName = ScreenPromptMap[input.promptName][0]
+			input.screenName = PromptScreenMap[input.promptName][0]
 		}
 	}
 
 	return nil
 }
 
-func fetchRenderSettings(cmd *cobra.Command, cli *cli, input customizationInputs) (*management.PromptRendering, error) {
-	var (
-		userRenderSettings string
-		renderSettings     = &management.PromptRendering{}
-		existingSettings   = map[string]interface{}{}
-		currentSettings    = map[string]interface{}{}
-	)
-
-	if input.filePath != "" {
-		data, err := os.ReadFile(input.filePath)
-		if err != nil {
-			return nil, fmt.Errorf("unable to read file %q: %v", input.filePath, err)
-		}
-
-		// Validate JSON content.
-		if err := json.Unmarshal(data, &renderSettings); err != nil {
-			return nil, fmt.Errorf("file %q contains invalid JSON: %v", input.filePath, err)
-		}
-
-		return renderSettings, nil
-	}
-
-	// Fetch existing render settings from the API.
-	existingRenderSettings, err := cli.api.Prompt.ReadRendering(cmd.Context(), management.PromptType(input.promptName), management.ScreenName(input.screenName))
-	if err != nil {
-		return nil, fmt.Errorf("failed to fetch the existing render settings: %w", err)
-	}
-
-	// Marshal existing render settings into JSON and parse into a map if it's not nil.
-	if existingRenderSettings != nil {
-		readRenderingJSON, _ := json.MarshalIndent(existingRenderSettings, "", "  ")
-		if err := json.Unmarshal(readRenderingJSON, &existingSettings); err != nil {
-			fmt.Println("Error parsing readRendering JSON:", err)
-		}
-	}
-
-	existingSettings["___customization guide___"] = "https://github.com/auth0/auth0-cli/blob/main/CUSTOMIZATION_GUIDE.md"
-
-	// Marshal final JSON.
-	finalJSON, err := json.MarshalIndent(existingSettings, "", "  ")
-	if err != nil {
-		fmt.Println("Error generating final JSON:", err)
-	}
-
-	err = rendererScript.OpenEditor(cmd, &userRenderSettings, string(finalJSON), input.promptName+"_"+input.screenName+".json", cli.customizeEditorHint)
-	if err != nil {
-		return nil, fmt.Errorf("failed to capture input from the editor: %w", err)
-	}
-
-	// Unmarshal user-provided JSON into a map for comparison.
-	err = json.Unmarshal([]byte(userRenderSettings), &currentSettings)
-	if err != nil {
-		return nil, fmt.Errorf("failed to unmarshal JSON input into a map: %w", err)
-	}
-
-	// Compare the existing settings with the updated settings to detect changes.
-	if reflect.DeepEqual(existingSettings, currentSettings) {
-		cli.renderer.Warnf("No changes detected in the customization settings. This could be due to uncommitted configuration changes or no modifications being made to the configurations.")
-
-		return existingRenderSettings, ErrNoChangesDetected
-	}
-
-	if err := json.Unmarshal([]byte(userRenderSettings), &renderSettings); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal JSON input: %w", err)
-	}
-
-	return renderSettings, nil
-}
-
-func (c *cli) customizeEditorHint() {
-	c.renderer.Infof("%s Once you close the editor, the shown settings will be saved. To cancel, press CTRL+C.", ansi.Faint("Hint:"))
-}
-
 func ensureNewUniversalLoginExperienceIsActive(ctx context.Context, api *auth0.API) error {
 	authenticationProfile, err := api.Prompt.Read(ctx)
 	if err != nil {
@@ -491,6 +383,70 @@ func ensureNewUniversalLoginExperienceIsActive(ctx context.Context, api *auth0.A
 	)
 }
 
+// displayDeprecationStatus displays timeline information.
+// The `showCommands` flag controls whether to display helpful usage examples.
+func displayDeprecationStatus(cli *cli, showCommands bool) error {
+	parsedSunset, _ := time.Parse("2006-01-02", sunsetDate)
+	now := time.Now()
+	daysUntil := int(parsedSunset.Sub(now).Hours() / 24)
+	formattedDate := ansi.Bold(ansi.Cyan(parsedSunset.Format("Jan 2, 2006")))
+
+	switch {
+	case daysUntil <= 0:
+		cli.renderer.Errorf("Advanced rendering mode was retired on %s", formattedDate)
+		cli.renderer.Errorf("   Use instead: %s", ansi.Green("auth0 acul config"))
+		if showCommands {
+			showNewConfigExamples(cli)
+		}
+		return fmt.Errorf("advanced rendering mode is no longer supported")
+
+	case daysUntil <= warningPeriodDays:
+		cli.renderer.Output("")
+		cli.renderer.Output(ansi.Bold(ansi.Red("🚨 URGENT: DEPRECATION NOTICE 🚨")))
+		cli.renderer.Warnf("%s will be retired soon (%d days left)",
+			ansi.Bold("Advanced rendering mode"), daysUntil)
+		cli.renderer.Warnf("   Switch to: %s", ansi.Bold(ansi.Cyan("auth0 acul config")))
+
+		if showCommands {
+			cli.renderer.Output("")
+			showNewConfigExamples(cli)
+		}
+
+		cli.renderer.Warnf("⏳ Proceeding with advanced rendering mode (deprecated)")
+
+	default:
+		cli.renderer.Output("")
+		cli.renderer.Output(ansi.Bold(ansi.Red("⚠️  DEPRECATION NOTICE ⚠️")))
+		cli.renderer.Warnf("%s will be retired on %s (%d days remaining)",
+			ansi.Bold("Advanced rendering mode"), formattedDate, daysUntil)
+		cli.renderer.Warnf("   Try new commands: %s", ansi.Bold(ansi.Cyan("auth0 acul config")))
+		if showCommands {
+			cli.renderer.Output("")
+			showNewConfigExamples(cli)
+		}
+	}
+
+	cli.renderer.Output("")
+	cli.renderer.Warnf("   For help: %s", ansi.Bold(ansi.Cyan("auth0 acul config --help")))
+	cli.renderer.Output("")
+
+	return nil
+}
+
+// showNewConfigExamples displays example commands for managing ACUL configurations.
+func showNewConfigExamples(cli *cli) {
+	cli.renderer.Warnf("  %s - Create config files", ansi.Yellow("auth0 acul config generate <screen>"))
+	cli.renderer.Warnf("  %s - Download current settings", ansi.Yellow("auth0 acul config get <screen>"))
+	cli.renderer.Warnf("  %s - Upload customizations", ansi.Yellow("auth0 acul config set <screen>"))
+	cli.renderer.Warnf("  %s - View available screens", ansi.Yellow("auth0 acul config list"))
+	cli.renderer.Output("")
+	cli.renderer.Warnf("  %s", ansi.Bold("Quick Start:"))
+	cli.renderer.Warnf("  1. %s", ansi.Cyan("auth0 acul config generate login-id"))
+	cli.renderer.Warnf("  2. Edit the generated JSON file as needed")
+	cli.renderer.Warnf("  3. %s", ansi.Cyan("auth0 acul config set login-id --file login-id.json"))
+	cli.renderer.Output("")
+}
+
 func startWebSocketServer(
 	ctx context.Context,
 	api *auth0.API,
@@ -1096,20 +1052,33 @@ func switchUniversalLoginRendererModeCmd(cli *cli) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "switch",
 		Args:  cobra.NoArgs,
-		Short: "Switch the rendering mode for Universal Login",
-		Long:  "Switch the rendering mode for Universal Login. Note that this requires a custom domain to be configured for the tenant.",
+		Short: "⚠️ Switch rendering mode (DEPRECATED)",
+		Long: `Switch the rendering mode for Universal Login. Note that this requires a custom domain to be configured for the tenant.
+
+🚨 DEPRECATION WARNING: The 'auth0 ul switch' command will be DEPRECATED on June 15, 2026
+        
+✅ For Advanced Customizations, Use new ACUL config commands:
+  • auth0 acul config generate <screen>
+  • auth0 acul config get <screen>  
+  • auth0 acul config set <screen>
+  • auth0 acul config list`,
 		Example: `  auth0 universal-login switch
   auth0 universal-login switch --prompt login-id --screen login-id --rendering-mode standard
   auth0 ul switch --prompt login-id --screen login-id --rendering-mode advanced
   auth0 ul switch -p login-id -s login-id -r standard`,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			err := fetchPromptScreenInfo(cmd, cli, &input, "switch")
+			err := displayDeprecationStatus(cli, false)
+			if err != nil {
+				return err
+			}
+
+			err = fetchPromptScreenInfo(cmd, cli, &input, "switch")
 			if err != nil {
 				return err
 			}
 
 			if selectedRenderingMode == "" {
-				cli.renderer.Infof("Please select a select a rendering mode to switch:\n")
+				cli.renderer.Infof("Please select a rendering mode to switch:")
 				if err = renderingMode.Select(cmd, &selectedRenderingMode, []string{advancedMode, standardMode}, nil); err != nil {
 					return err
 				}
@@ -1136,7 +1105,7 @@ func switchUniversalLoginRendererModeCmd(cli *cli) *cobra.Command {
 	}
 
 	promptName.RegisterString(cmd, &input.promptName, "")
-	screenName.RegisterString(cmd, &input.screenName, "")
+	screenNameFlag.RegisterString(cmd, &input.screenName, "")
 	renderingMode.RegisterString(cmd, &selectedRenderingMode, "")
 
 	return cmd
diff --git a/internal/display/acul.go b/internal/display/acul.go
new file mode 100644
index 000000000..104b153b7
--- /dev/null
+++ b/internal/display/acul.go
@@ -0,0 +1,61 @@
+package display
+
+import (
+	"github.com/auth0/go-auth0/management"
+)
+
+type aculConfigView struct {
+	ScreenName    string
+	RenderingMode string
+	raw           interface{}
+}
+
+func (v *aculConfigView) Object() interface{} {
+	return v.raw
+}
+
+func (v *aculConfigView) AsTableHeader() []string {
+	return []string{
+		"Screen Name",
+		"Rendering Mode",
+	}
+}
+
+func (v *aculConfigView) AsTableRow() []string {
+	return []string{v.ScreenName, v.RenderingMode}
+}
+
+func (r *Renderer) ACULConfigList(aculConfigs *management.PromptRenderingList) {
+	resource := "prompt rendering configurations"
+	r.Heading(resource)
+
+	if len(aculConfigs.PromptRenderings) == 0 {
+		r.EmptyState(resource, " Use 'auth0 acul config get' to fetch remote rendering settings or 'auth0 acul config set' to sync local configs.")
+	}
+
+	if r.Format == OutputFormatJSONCompact {
+		r.JSONCompactResult(aculConfigs)
+		return
+	}
+
+	if r.Format == OutputFormatJSON {
+		r.JSONResult(aculConfigs)
+		return
+	}
+
+	r.Results(makeACULConfigView(aculConfigs))
+}
+
+func makeACULConfigView(aculConfig *management.PromptRenderingList) []View {
+	views := make([]View, 0, len(aculConfig.PromptRenderings))
+
+	for _, v := range aculConfig.PromptRenderings {
+		views = append(views, &aculConfigView{
+			ScreenName:    string(*v.Screen),
+			RenderingMode: string(*v.RenderingMode),
+			raw:           v,
+		})
+	}
+
+	return views
+}
diff --git a/internal/prompt/paginated_select.go b/internal/prompt/paginated_select.go
new file mode 100644
index 000000000..46c8f7c0f
--- /dev/null
+++ b/internal/prompt/paginated_select.go
@@ -0,0 +1,35 @@
+package prompt
+
+import (
+	"strings"
+
+	"github.com/AlecAivazis/survey/v2"
+)
+
+var (
+	defaultPageSize = 13
+)
+
+func PaginatedSelectInput(name string, message string, help string, options []string, defaultValue string, required bool) *survey.Question {
+	input := &survey.Question{
+		Name: name,
+		Prompt: &survey.Select{
+			Message:  message,
+			Help:     help,
+			Options:  options,
+			PageSize: defaultPageSize,
+			Default:  defaultValue,
+
+			Filter: func(filterVal string, optionVal string, optionIndex int) bool {
+				// Case-insensitive search - matches if the search term appears anywhere in the option.
+				return strings.Contains(strings.ToLower(optionVal), strings.ToLower(filterVal))
+			},
+		},
+	}
+
+	if required {
+		input.Validate = survey.Required
+	}
+
+	return input
+}
diff --git a/internal/utils/utils.go b/internal/utils/utils.go
index bebcd89ad..4ffd4ef68 100644
--- a/internal/utils/utils.go
+++ b/internal/utils/utils.go
@@ -1,10 +1,13 @@
 package utils
 
+import "sort"
+
 // FetchKeys function to get all keys from a map.
-func FetchKeys[K comparable, V any](m map[K]V) []K {
-	keys := make([]K, 0, len(m))
+func FetchKeys[V any](m map[string]V) []string {
+	keys := make([]string, 0, len(m))
 	for k := range m {
 		keys = append(keys, k)
 	}
+	sort.Strings(keys)
 	return keys
 }