diff --git a/WordPress-Extra/ruleset.xml b/WordPress-Extra/ruleset.xml
index 53da8be01..f5f02e0bf 100644
--- a/WordPress-Extra/ruleset.xml
+++ b/WordPress-Extra/ruleset.xml
@@ -192,6 +192,13 @@
 		 https://github.com/WordPress/WordPress-Coding-Standards/issues/2459 -->
 	<rule ref="WordPress.WP.GetMetaSingle"/>
 
+	<!-- Flags calls to add_option(), update_option(), wp_set_options_autoload(),
+		 wp_set_option_autoload(), wp_set_option_autoload_values() functions when the
+		 `$autoload` parameter is missing or contain an invalid, internal-only or
+		 deprecated value.
+		 https://github.com/WordPress/WordPress-Coding-Standards/issues/2473 -->
+	<rule ref="WordPress.WP.OptionAutoload"/>
+
 	<!--
 	#############################################################################
 	Code style sniffs for more recent PHP features and syntaxes.
diff --git a/WordPress/Docs/WP/OptionAutoloadStandard.xml b/WordPress/Docs/WP/OptionAutoloadStandard.xml
new file mode 100644
index 000000000..b2520ae14
--- /dev/null
+++ b/WordPress/Docs/WP/OptionAutoloadStandard.xml
@@ -0,0 +1,102 @@
+<?xml version="1.0"?>
+<documentation xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:noNamespaceSchemaLocation="https://phpcsstandards.github.io/PHPCSDevTools/phpcsdocs.xsd"
+    title="Option Autoload"
+    >
+    <standard>
+    <![CDATA[
+    When using `add_option()`, `update_option()`, `wp_set_options_autoload()`,
+    `wp_set_option_autoload()`, or `wp_set_option_autoload_values()`, it is recommended to
+    explicitly set the autoload parameter to ensure predictable behavior. This parameter determines
+    whether the option is automatically loaded on every page load, which can impact site performance.
+    ]]>
+    </standard>
+    <standard>
+    <![CDATA[
+    The following values should be used when setting the autoload parameter depending on the function:
+
+    - For `add_option()` and `update_option()`: `true`, `false`, or `null`.
+    - For `wp_set_option_autoload_values()`, `wp_set_option_autoload()`, and
+    `wp_set_options_autoload()`: `true` or `false`.
+
+    Using 'yes' or 'no' is deprecated since WordPress 6.6.0. Using 'auto', 'auto-on', 'auto-off',
+    'on', or 'off' in plugin/theme code is strongly discouraged as those values are meant for
+    internal-use only.
+
+    Any other values, including `null` for functions other than `add_option()` and `update_option()`
+    are invalid.
+    ]]>
+    </standard>
+    <code_comparison>
+        <code title="Valid: Using a boolean value or `null`">
+        <![CDATA[
+add_option(
+    'my_option',
+    'value',
+    '',
+    <em>true</em>
+);
+
+update_option(
+    'my_option',
+    'value',
+    <em>null</em>
+);
+        ]]>
+        </code>
+        <code title="Invalid: Using deprecated, internal-only, or invalid values">
+        <![CDATA[
+add_option(
+    'my_option',
+    'value',
+    '',
+    <em>'yes'</em>
+);
+
+wp_set_option_autoload(
+    'my_option',
+    <em>null</em>
+);
+
+wp_set_option_autoload_values(
+    array(
+        'option1' => <em>'auto-on'</em>,
+        'option2' => <em>'off'</em>
+    )
+);
+
+wp_set_options_autoload(
+    array('option1', 'option2'),
+    <em>1</em>
+);
+        ]]>
+        </code>
+    </code_comparison>
+    <standard>
+    <![CDATA[
+    Even though the autoload parameter is optional for `add_option()` and `update_option()`, it is
+    recommended to always explicitly set it.
+    ]]>
+    </standard>
+    <code_comparison>
+        <code title="Valid: Explicitly setting the autoload parameter.">
+        <![CDATA[
+add_option(
+    'my_option',
+    'value',
+    '',
+    <em>true</em>
+);
+        ]]>
+        </code>
+        <code title="Invalid: Autoload parameter missing.">
+        <![CDATA[
+add_option(
+    'my_option',
+    'value',
+    ''
+);
+        ]]>
+        </code>
+    </code_comparison>
+</documentation>
diff --git a/WordPress/Sniffs/WP/OptionAutoloadSniff.php b/WordPress/Sniffs/WP/OptionAutoloadSniff.php
new file mode 100644
index 000000000..647fcaa4e
--- /dev/null
+++ b/WordPress/Sniffs/WP/OptionAutoloadSniff.php
@@ -0,0 +1,439 @@
+<?php
+/**
+ * WordPress Coding Standard.
+ *
+ * @package WPCS\WordPressCodingStandards
+ * @link    https://github.com/WordPress/WordPress-Coding-Standards
+ * @license https://opensource.org/licenses/MIT MIT
+ */
+
+namespace WordPressCS\WordPress\Sniffs\WP;
+
+use PHP_CodeSniffer\Util\Tokens;
+use PHPCSUtils\Utils\Arrays;
+use PHPCSUtils\Tokens\Collections;
+use PHPCSUtils\Utils\PassedParameters;
+use PHPCSUtils\Utils\TextStrings;
+use WordPressCS\WordPress\AbstractFunctionParameterSniff;
+
+/**
+ * Warns when calls to add_option(), update_option(), wp_set_options_autoload(),
+ * wp_set_option_autoload(), wp_set_option_autoload_values() are missing the `$autoload` param or
+ * contain an invalid, internal or deprecated value.
+ *
+ * @link https://github.com/WordPress/WordPress-Coding-Standards/issues/2473
+ *
+ * @since 3.2.0
+ */
+final class OptionAutoloadSniff extends AbstractFunctionParameterSniff {
+
+	/**
+	 * The phrase to use for the metric recorded by this sniff.
+	 *
+	 * @since 3.2.0
+	 *
+	 * @var string
+	 */
+	const METRIC_NAME = 'Value of the `$autoload` parameter in the option functions';
+
+	/**
+	 * Valid values for the `$autoload` parameter in the add_option() and update_option() functions.
+	 *
+	 * @since 3.2.0
+	 *
+	 * @var array<string, string>
+	 */
+	private $valid_values_add_and_update = array(
+		'true'  => 'true',
+		'false' => 'false',
+		'null'  => 'null',
+	);
+
+	/**
+	 * Valid values for the `$autoload` parameter in the wp_set_options_autoload(),
+	 * wp_set_option_autoload(), and wp_set_option_autoload_values() functions.
+	 *
+	 * @since 3.2.0
+	 *
+	 * @var array<string, string>
+	 */
+	private $valid_values_other_functions = array(
+		'true'  => 'true',
+		'false' => 'false',
+	);
+
+	/**
+	 * Deprecated values for the `$autoload` parameter.
+	 *
+	 * @since 3.2.0
+	 *
+	 * @var array<string, true>
+	 */
+	private $deprecated_values = array(
+		'yes' => true,
+		'no'  => true,
+	);
+
+	/**
+	 * Internal-use only values for `$autoload` that cannot be fixed automatically by the sniff.
+	 *
+	 * @since 3.2.0
+	 *
+	 * @var array<string, true>
+	 */
+	private $internal_values_non_fixable = array(
+		'auto'     => true,
+		'auto-on'  => true,
+		'auto-off' => true,
+	);
+
+	/**
+	 * Internal-use only values for `$autoload` that can be fixed automatically by the sniff.
+	 *
+	 * @since 3.2.0
+	 *
+	 * @var array<string, true>
+	 */
+	private $internal_values_fixable = array(
+		'on'  => true,
+		'off' => true,
+	);
+
+	/**
+	 * Replacements for fixable values.
+	 *
+	 * @since 3.2.0
+	 *
+	 * @var array<string, string>
+	 */
+	private $fixable_values = array(
+		'yes' => 'true',
+		'no'  => 'false',
+		'on'  => 'true',
+		'off' => 'false',
+	);
+
+	/**
+	 * Functions for which the `$autoload` parameter is optional.
+	 *
+	 * @since 3.2.0
+	 *
+	 * @var array<string, true>
+	 */
+	private $autoload_is_optional = array(
+		'add_option'    => true,
+		'update_option' => true,
+	);
+
+	/**
+	 * The group name for this group of functions.
+	 *
+	 * @since 3.2.0
+	 *
+	 * @var string
+	 */
+	protected $group_name = 'option_autoload';
+
+	/**
+	 * List of functions this sniff should examine.
+	 *
+	 * @link https://developer.wordpress.org/reference/functions/add_option/
+	 * @link https://developer.wordpress.org/reference/functions/update_option/
+	 * @link https://developer.wordpress.org/reference/functions/wp_set_option_autoload/
+	 * @link https://developer.wordpress.org/reference/functions/wp_set_option_autoload_values/
+	 * @link https://developer.wordpress.org/reference/functions/wp_set_options_autoload/
+	 *
+	 * @since 3.2.0
+	 *
+	 * @var array<string, array<string, string|int>> Key is the function name, value is an array
+	 *                                               containing the name and the position of the
+	 *                                               autoload parameter.
+	 */
+	protected $target_functions = array(
+		'add_option'                    => array(
+			'param_name' => 'autoload',
+			'position'   => 4,
+		),
+		'update_option'                 => array(
+			'param_name' => 'autoload',
+			'position'   => 3,
+		),
+		'wp_set_options_autoload'       => array(
+			'param_name' => 'autoload',
+			'position'   => 2,
+		),
+		'wp_set_option_autoload'        => array(
+			'param_name' => 'autoload',
+			'position'   => 2,
+		),
+		// Special case as it takes an array of option names and autoload values as the first param.
+		'wp_set_option_autoload_values' => array(
+			'param_name' => 'options',
+			'position'   => 1,
+		),
+	);
+
+	/**
+	 * Process the parameters of a matched function.
+	 *
+	 * @since 3.2.0
+	 *
+	 * @param int    $stackPtr      The position of the current token in the stack.
+	 * @param string $group_name    The name of the group which was matched.
+	 * @param string $function_name The token content (function name) which was matched
+	 *                              in lowercase.
+	 * @param array  $parameters    Array with information about the parameters.
+	 *
+	 * @return void
+	 */
+	public function process_parameters( $stackPtr, $group_name, $function_name, $parameters ) {
+		$function_info = $this->target_functions[ $function_name ];
+
+		$target_param = PassedParameters::getParameterFromStack(
+			$parameters,
+			$function_info['position'],
+			$function_info['param_name']
+		);
+
+		if ( ! is_array( $target_param ) ) {
+			$this->maybe_display_missing_autoload_warning( $stackPtr, $function_name );
+			return;
+		}
+
+		if ( 'wp_set_option_autoload_values' === $function_name ) {
+			$this->handle_wp_set_option_autoload_values( $target_param, $stackPtr );
+			return;
+		}
+
+		$this->check_autoload_value( $target_param, $function_name );
+	}
+
+	/**
+	 * Process the function if no parameters were found.
+	 *
+	 * @since 3.2.0
+	 *
+	 * @param int    $stackPtr      The position of the current token in the stack.
+	 * @param string $group_name    The name of the group which was matched.
+	 * @param string $function_name The token content (function name) which was matched
+	 *                              in lowercase.
+	 *
+	 * @return void
+	 */
+	public function process_no_parameters( $stackPtr, $group_name, $function_name ) {
+		$this->maybe_display_missing_autoload_warning( $stackPtr, $function_name );
+	}
+
+	/**
+	 * Handle the `wp_set_option_autoload_values()` function. It requires special treatment as it
+	 * takes an array of option names and autoload values instead of the autoload value of a single
+	 * option as a separate parameter.
+	 *
+	 * @since 3.2.0
+	 *
+	 * @param array $options_param Options parameter information.
+	 * @param int   $stackPtr      The position of the current token in the stack.
+	 *
+	 * @return void
+	 */
+	private function handle_wp_set_option_autoload_values( array $options_param, $stackPtr ) {
+		$array_token = $this->phpcsFile->findNext(
+			Tokens::$emptyTokens,
+			$options_param['start'],
+			$options_param['end'],
+			true
+		);
+
+		if ( false === isset( Collections::arrayOpenTokensBC()[ $this->tokens[ $array_token ]['code'] ] ) ) {
+			// Bail if the first non-empty token in the parameter is not an array opener as this
+			// means it is not possible to determine the option names and autoload values passed to
+			// wp_set_option_autoload_values().
+			return;
+		}
+
+		$options = PassedParameters::getParameters( $this->phpcsFile, $array_token );
+
+		if ( empty( $options ) ) {
+			// Bail if the array is empty.
+			return;
+		}
+
+		foreach ( $options as $array_item ) {
+			$double_arrow_pointer = Arrays::getDoubleArrowPtr( $this->phpcsFile, $array_item['start'], $array_item['end'] );
+
+			if ( false === $double_arrow_pointer ) {
+				$start = $array_item['start'];
+				$clean = $array_item['clean'];
+			} else {
+				$array_item_parts = explode( '=>', $array_item['clean'] );
+				$start            = $double_arrow_pointer + 1;
+				$clean            = trim( $array_item_parts[1] );
+			}
+
+			$array_value_info = array(
+				'start' => $start,
+				'end'   => $array_item['end'],
+				'clean' => $clean,
+			);
+
+			$this->check_autoload_value( $array_value_info, 'wp_set_option_autoload_values' );
+		}
+	}
+
+	/**
+	 * Adds a PHPCS warning when autoload parameter is missing for the functions where
+	 * this parameter is optional.
+	 *
+	 * @since 3.2.0
+	 *
+	 * @param int    $stackPtr      The position of the current token in the stack.
+	 * @param string $function_name The token content (function name) which was matched
+	 *                              in lowercase.
+	 *
+	 * @return void
+	 */
+	private function maybe_display_missing_autoload_warning( $stackPtr, $function_name ) {
+		$this->phpcsFile->recordMetric( $stackPtr, self::METRIC_NAME, 'param missing' );
+
+		// Only display a warning for the functions in which the `$autoload` parameter is optional.
+		if ( isset( $this->autoload_is_optional[ $function_name ] ) ) {
+			$this->phpcsFile->addWarning(
+				'It is recommended to always pass the `$autoload` parameter when using %s() function.',
+				$stackPtr,
+				'Missing',
+				array( $this->tokens[ $stackPtr ]['content'] )
+			);
+		}
+	}
+
+	/**
+	 * Check the autoload value for possible violations.
+	 *
+	 * @since 3.2.0
+	 *
+	 * @param array  $autoload_info Information about the autoload value (start and end tokens and
+	 *                              the clean value).
+	 * @param string $function_name The token content (function name) which was matched
+	 *                              in lowercase.
+	 *
+	 * @return void
+	 */
+	private function check_autoload_value( array $autoload_info, $function_name ) {
+		$param_first_token  = $this->phpcsFile->findNext(
+			Tokens::$emptyTokens,
+			$autoload_info['start'],
+			( $autoload_info['end'] + 1 ),
+			true
+		);
+		$param_second_token = $this->phpcsFile->findNext(
+			Tokens::$emptyTokens,
+			$param_first_token + 1,
+			( $autoload_info['end'] + 1 ),
+			true
+		);
+
+		$normalized_value = strtolower( $autoload_info['clean'] );
+
+		if ( \T_NS_SEPARATOR === $this->tokens[ $param_first_token ]['code'] && $param_second_token ) {
+			$token_content_lowercase = strtolower( $this->tokens[ $param_second_token ]['content'] );
+
+			if ( isset( $this->valid_values_add_and_update[ $token_content_lowercase ] ) ) {
+				// Ensure the sniff handles correctly `true`, `false` and `null` when they are
+				// namespaced (preceded by a backslash).
+				$param_first_token  = $param_second_token;
+				$param_second_token = false;
+				$normalized_value   = substr( $normalized_value, 1 );
+			}
+		}
+
+		if ( isset( $this->autoload_is_optional[ $function_name ] ) ) {
+			$valid_values = $this->valid_values_add_and_update;
+		} else {
+			$valid_values = $this->valid_values_other_functions;
+		}
+
+		if ( isset( $valid_values[ $normalized_value ] ) ) {
+			$this->phpcsFile->recordMetric( $param_first_token, self::METRIC_NAME, $normalized_value );
+			return;
+		}
+
+		if ( in_array( $this->tokens[ $param_first_token ]['code'], array( \T_VARIABLE, \T_STRING ), true )
+			&& 'null' !== strtolower( $this->tokens[ $param_first_token ]['content'] )
+		) {
+			// Bail early if the first non-empty token in the parameter is T_VARIABLE or T_STRING as
+			// this means it is not possible to determine the value.
+			$this->phpcsFile->recordMetric( $param_first_token, self::METRIC_NAME, 'undetermined value' );
+			return;
+		}
+
+		if ( $param_second_token
+			&& false === isset( Collections::arrayOpenTokensBC()[ $this->tokens[ $param_first_token ]['code'] ] )
+		) {
+			// Bail early if the parameter has two or more non-empty tokens and the second token is
+			// not an array opener as this means an undetermined param value or a value that is not
+			// easy to determine.
+			$this->phpcsFile->recordMetric( $param_first_token, self::METRIC_NAME, 'undetermined value' );
+			return;
+		}
+
+		$autoload_value = TextStrings::stripQuotes( $autoload_info['clean'] );
+
+		$known_discouraged_values = array_merge( $this->deprecated_values, $this->internal_values_non_fixable, $this->internal_values_fixable );
+
+		if ( isset( $known_discouraged_values[ $autoload_value ] ) ) {
+			$metric_value = $autoload_value;
+		} else {
+			$metric_value = 'other value';
+		}
+
+		$this->phpcsFile->recordMetric( $param_first_token, self::METRIC_NAME, $metric_value );
+
+		if ( isset( $this->deprecated_values[ $autoload_value ] ) ) {
+			$message    = 'The use of `%s` as the value of the `$autoload` parameter is deprecated. Use `%s` instead.';
+			$error_code = 'Deprecated';
+			$data       = array( $autoload_info['clean'], $this->fixable_values[ $autoload_value ] );
+		} elseif ( isset( $this->internal_values_fixable[ $autoload_value ] ) ) {
+			$message    = 'The use of `%s` as the value of the `$autoload` parameter is discouraged. Use `%s` instead.';
+			$error_code = 'InternalUseOnly';
+			$data       = array( $autoload_info['clean'], $this->fixable_values[ $autoload_value ] );
+		} elseif ( isset( $this->internal_values_non_fixable [ $autoload_value ] ) ) {
+			$message    = 'The use of `%s` as the value of the `$autoload` parameter is discouraged.';
+			$error_code = 'InternalUseOnly';
+			$data       = array( $autoload_info['clean'] );
+		} else {
+			$valid_values        = array_map(
+				function ( $value ) {
+					return '`' . $value . '`';
+				},
+				$valid_values
+			);
+			$valid_values_string = implode( ', ', $valid_values );
+			$valid_values_string = substr_replace( $valid_values_string, ' or', strrpos( $valid_values_string, ',' ), 1 );
+			$message             = 'The use of `%s` as the value of the `$autoload` parameter is invalid. Use %s instead.';
+			$error_code          = 'InvalidValue';
+			$data                = array( $autoload_info['clean'], $valid_values_string );
+		}
+
+		if ( isset( $this->fixable_values[ $autoload_value ] ) ) {
+			$fix = $this->phpcsFile->addFixableWarning(
+				$message,
+				$param_first_token,
+				$error_code,
+				$data
+			);
+
+			if ( $fix ) {
+				$this->phpcsFile->fixer->replaceToken( $param_first_token, $this->fixable_values[ $autoload_value ] );
+			}
+
+			return;
+		}
+
+		$this->phpcsFile->addWarning(
+			$message,
+			$param_first_token,
+			$error_code,
+			$data
+		);
+	}
+}
diff --git a/WordPress/Tests/WP/OptionAutoloadUnitTest.inc b/WordPress/Tests/WP/OptionAutoloadUnitTest.inc
new file mode 100644
index 000000000..a7917d410
--- /dev/null
+++ b/WordPress/Tests/WP/OptionAutoloadUnitTest.inc
@@ -0,0 +1,229 @@
+<?php
+
+/*
+ * Not the sniff target.
+ */
+my\ns\add_option($a, $b);
+$this->add_option($a, $b);
+MyClass::add_option($a, $b);
+echo ADD_OPTION;
+add_action('my_action', add_option(...)); // PHP 8.1 first class callable.
+use function add_option;
+
+/*
+ * These should all be okay.
+ */
+$ok = \add_option( 'my_option', 'my_value', '', true );
+$ok = add_option( 'my_option', array('some', 'big', 'array'), '', false );
+$ok = ADD_OPTION( 'my_option', new stdClass(), '', null );
+$ok = add_option( 'my_option', autoload: FALSE, value: 'my_value' );
+$ok = add_option( 'my_option', autoload: false );
+$ok = add_option( autoload: false, deprecated: '', value: 'my_value', option: 'my_option' );
+$ok = \update_option(    'my_option'    ,    'new_value'    ,    \true    );
+$ok = update_option(
+    'my_option',
+    'new_value',
+    // phpcs:ignore Standard.Category.Sniff -- For test reasons.
+    /* comment */ \false /* comment */
+);
+$ok = Update_Option( 'my_option', 'new_value', \NULL );
+$ok = update_option( 'my_option', autoload: TrUe, value: 'new_value' );
+$ok = update_option( autoload: false, value: 'my_value', option: 'my_option' );
+$ok = update_OPTION( $option_name, get_option( $option_name ), false );
+$ok = wp_set_options_autoload( array( 'option1', 'option2' ), \false );
+$ok = wp_set_options_autoload( array( 'option1', 'option2' ), \true );
+$ok = wp_set_options_autoload( autoload: false, options: array( 'option1', 'option2' ) );
+$ok = wp_set_option_autoload( 'option1', false );
+$ok = wp_set_option_autoload( 'option1', true );
+$ok = wp_set_option_autoload( autoload: false, option: 'option1' );
+$ok = wp_set_option_autoload_values(
+    array(
+        'option1' => true,
+        'option2' => false,
+    )
+);
+$ok = wp_set_option_autoload_values(
+    options: array(
+        'option1' => true,
+        $option_name => false,
+    )
+);
+
+/*
+ * These should all be ignored by the sniff as the autoload value can't be reliably
+ * determined.
+ */
+$ignored = add_option( 'my_option', 'my_value', '', $some_variable );
+$ignored = ADD_OPTION( 'my_option', 'my_value', '', $obj->yes );
+$ignored = add_option( 'my_option', 'my_value', '', $some_variable ? 'yes' : 'no' );
+$ignored = Add_Option( 'my_option', 'my_value', '', 'ye' . 's' );
+$ignored = add_option( 'my_option', 'my_value', '', (function () { return 'yes'; })() );
+$ignored = add_option(
+    'my_option',
+    'new_value',
+    '',
+    /* comment */ yes /* comment */
+);
+$ignored = wp_set_options_autoload( array( 'option1', 'option2' ), $some_variable );
+$ignored = wp_set_OPTION_autoload( 'option1', $some_variable );
+$ignored = wp_set_option_autoload_values(
+    array(
+        'option1' => $some_variable,
+        'option2' => $obj->yes,
+        'option3' => $some_variable ? 'yes' : 'no',
+        'option4' => 'ye' . 's',
+        'option5' => (function () { return 'yes'; })(),
+        'option6' => yes,
+        'option7' => \my_function(),
+        'option8' => \SOME_CONSTANT,
+        'option9' => \YES,
+    )
+);
+
+/*
+ * These are ignored because the option names and the autoload values can't be reliably determined
+ * or the `$options` parameter is empty.
+ */
+$ignored = wp_set_option_autoload_values( $options );
+$ignored = wp_set_option_autoload_values( options: $options );
+$ignored = wp_set_option_autoload_values(array());
+$ignored = wp_set_option_autoload_values([]);
+$ignored = wp_set_option_autoload_values(options: array());
+$ignored = wp_set_option_autoload_values(options: []);
+
+/*
+ * Invalid function calls that are ignored by the sniff as a mandatory parameter is missing.
+ */
+$ignored = wp_set_option_autoload_values();
+$ignored = wp_set_options_autoload( /* some comment */ );
+$ignored = wp_set_options_autoload( array( 'option1', 'option2' ) );
+$ignored = wp_set_option_autoload();
+$ignored = wp_set_option_autoload( 'option1' );
+
+/*
+ * These should all be flagged with a warning.
+ */
+$warning = add_option( 'my_option' );
+$warning = \add_option( 'my_option', 'my_value' );
+if ( add_option( 'my_option', 'my_value', true ) ) {}
+$warning = ADD_OPTION( 'my_option', 'my_value', '', 'auto' );
+$warning = add_option( 'my_option', 'my_value', '', 'auto-on' );
+$warning = add_option(
+    'my_option',
+    'my_value',
+    '',
+    'auto-off'
+);
+$warning = add_option( 'my_option', 'my_value', '', 'invalid_value' );
+$warning = add_option( 'my_option', 'my_value', '', 'true' );
+$warning = add_option( 'my_option', 'my_value', '', "false" );
+$warning = add_option( 'my_option', 'my_value', '', array('some', 'array') );
+$warning = /* comment */ add_option /* comment */ ( 'my_option', 'my_value', '', ['some', 'array'] );
+$warning = add_option( option: 'my_option' );
+$warning = add_option( value: 'my_value', option: 'my_option' );
+$warning = add_option( value: 'my_value', deprecated: '', option: 'my_option' );
+$warning = add_option( value: 'my_value', deprecated: '', autoload: 'auto', option: 'my_option' );
+$warning = add_option( 'my_option', 'my_value', '', 'YES' ); // the uppercase versions of the valid values are not supported.
+$warning = update_option( 'my_option', 'new_value' );
+$warning = update_option( 'my_option', 'new_value', 'auto' );
+$warning = update_option( 'my_option', 'new_value', 'auto-on' );
+$warning = update_option(
+    /* option name */ 'my_option',
+    'new_value' /* option value */,
+    /* autoload value */ 'auto-off' // phpcs:ignore Standard.Category.Sniff -- For test reasons.
+);
+$warning = update_option( 'my_option', 'new_value', 'invalid_value' );
+$warning = update_option( value: 'new_value', option: 'my_option' );
+$warning = update_option( value: 'new_value', autoload: 'auto', option: 'my_option' );
+$warning = update_option( $option_name, get_option( $option_name ) );
+$warning = wp_set_options_autoload( array( 'option1', 'option2' ), 'invalid_value' );
+$warning = wp_set_options_autoload( array( 'option1' ), null );
+$warning = wp_set_option_autoload( 'option1', 'invalid_value' );
+$warning = wp_set_option_autoload( 'option1', \NuLL );
+$warning = wp_set_option_autoload_values( ['option1' => null] );
+$warning = wp_set_option_autoload_values(
+    // phpcs:ignore Standard.Category.Sniff -- For test reasons.
+    [
+        'option1' => '',
+        'option2' => 'true',
+        'option3' => "false",
+        'option4' => array('some', 'array'),
+        'option5' => ['some', 'array'],
+        'option6' => 'YES',
+        'option7' => 'invalid_value',
+        'option8' => 'auto',
+        'option9' /* some comment */ => /* some comment */ 'auto-on',
+        'option10' => 'auto-off',
+        'option11',
+        /* some comment */ 'option12' /* some comment */,
+    ]
+);
+
+// Incorrect function calls, should be flagged by the sniff.
+$incorrect_but_warning = add_option();
+$incorrect_but_warning = update_OPTION();
+$incorrect_but_warning = update_option( 'my_option' );
+$incorrect_but_warning = update_option( autoloader: false, value: 'my_value', option: 'my_option' ); // Typo in the autoload parameter.
+$incorrect_but_warning = add_option( autoload: 'yes', 'my_option' );
+$incorrect_but_warning = add_option( autoload: 'no' );
+
+/*
+ * These should all be flagged with a warning and auto-fixed.
+ */
+$autofix_warning = add_option( 'my_option', 'my_value', '', 'yes' );
+$autofix_warning = add_option( 'my_option', 'my_value', '', 'no' );
+$autofix_warning = add_option( 'my_option', 'my_value', '', "yes" );
+$autofix_warning = add_option( 'my_option', 'my_value', '', "no" );
+$autofix_warning = add_option( 'my_option', 'my_value', '', 'on' );
+$autofix_warning = add_option( 'my_option', 'my_value', '', 'off' );
+$autofix_warning = add_option( 'my_option', 'my_value', '', /* weirdly placed comment */ 'off' /* weirdly placed comment */ );
+$autofix_warning = add_option(
+    'my_option',
+    'my_value',
+    '',
+    // weirdly placed comment
+    'off'
+);
+$autofix_warning = add_option(
+    'my_option',
+    'my_value',
+    '',
+    // phpcs:ignore Standard.Category.Sniff -- For test reasons.
+    'off'
+);
+$autofix_warning = add_option( 'my_option', 'my_value', '', 'off' );
+$autofix_warning = add_option( value: 'my_value', deprecated: '', autoload: 'yes', option: 'my_option' );
+$autofix_warning = update_option( 'my_option', 'new_value', 'yes' );
+$autofix_warning = update_option( 'my_option', 'new_value', 'no' );
+$autofix_warning = update_option( 'my_option', 'new_value', 'on' );
+$autofix_warning = update_option( 'my_option', 'new_value', 'off' );
+$autofix_warning = update_option( value: 'new_value', autoload: 'yes', option: 'my_option' );
+
+$autofix_warning = wp_set_options_autoload( array( 'option1', 'option2' ), 'yes' );
+$autofix_warning = wp_set_options_autoload( array( 'option1', 'option2' ), 'no' );
+$autofix_warning = wp_set_option_autoload( 'option1', 'yes' );
+$autofix_warning = wp_set_option_autoload( 'option1', 'no' );
+$autofix_warning = WP_SET_OPTION_AUTOLOAD_VALUES(
+    array(
+        'option1' => 'yes',
+        'option2' => 'no',
+        'option3' => 'on',
+        'option4' => 'off',
+    )
+);
+$autofix_warning = Wp_Set_Option_Autoload_Values(
+    options: array(
+        'option1' => 'yes',
+    )
+);
+
+$mixed_autoload_values = wp_set_option_autoload_values(
+    array(
+        'option1' => 'yes',
+        'option2' => false,
+        'option3' => 'on',
+        'option4' => true,
+        'option5' => $option_value,
+        'option6' => 'auto',
+    )
+);
diff --git a/WordPress/Tests/WP/OptionAutoloadUnitTest.inc.fixed b/WordPress/Tests/WP/OptionAutoloadUnitTest.inc.fixed
new file mode 100644
index 000000000..accac21b5
--- /dev/null
+++ b/WordPress/Tests/WP/OptionAutoloadUnitTest.inc.fixed
@@ -0,0 +1,229 @@
+<?php
+
+/*
+ * Not the sniff target.
+ */
+my\ns\add_option($a, $b);
+$this->add_option($a, $b);
+MyClass::add_option($a, $b);
+echo ADD_OPTION;
+add_action('my_action', add_option(...)); // PHP 8.1 first class callable.
+use function add_option;
+
+/*
+ * These should all be okay.
+ */
+$ok = \add_option( 'my_option', 'my_value', '', true );
+$ok = add_option( 'my_option', array('some', 'big', 'array'), '', false );
+$ok = ADD_OPTION( 'my_option', new stdClass(), '', null );
+$ok = add_option( 'my_option', autoload: FALSE, value: 'my_value' );
+$ok = add_option( 'my_option', autoload: false );
+$ok = add_option( autoload: false, deprecated: '', value: 'my_value', option: 'my_option' );
+$ok = \update_option(    'my_option'    ,    'new_value'    ,    \true    );
+$ok = update_option(
+    'my_option',
+    'new_value',
+    // phpcs:ignore Standard.Category.Sniff -- For test reasons.
+    /* comment */ \false /* comment */
+);
+$ok = Update_Option( 'my_option', 'new_value', \NULL );
+$ok = update_option( 'my_option', autoload: TrUe, value: 'new_value' );
+$ok = update_option( autoload: false, value: 'my_value', option: 'my_option' );
+$ok = update_OPTION( $option_name, get_option( $option_name ), false );
+$ok = wp_set_options_autoload( array( 'option1', 'option2' ), \false );
+$ok = wp_set_options_autoload( array( 'option1', 'option2' ), \true );
+$ok = wp_set_options_autoload( autoload: false, options: array( 'option1', 'option2' ) );
+$ok = wp_set_option_autoload( 'option1', false );
+$ok = wp_set_option_autoload( 'option1', true );
+$ok = wp_set_option_autoload( autoload: false, option: 'option1' );
+$ok = wp_set_option_autoload_values(
+    array(
+        'option1' => true,
+        'option2' => false,
+    )
+);
+$ok = wp_set_option_autoload_values(
+    options: array(
+        'option1' => true,
+        $option_name => false,
+    )
+);
+
+/*
+ * These should all be ignored by the sniff as the autoload value can't be reliably
+ * determined.
+ */
+$ignored = add_option( 'my_option', 'my_value', '', $some_variable );
+$ignored = ADD_OPTION( 'my_option', 'my_value', '', $obj->yes );
+$ignored = add_option( 'my_option', 'my_value', '', $some_variable ? 'yes' : 'no' );
+$ignored = Add_Option( 'my_option', 'my_value', '', 'ye' . 's' );
+$ignored = add_option( 'my_option', 'my_value', '', (function () { return 'yes'; })() );
+$ignored = add_option(
+    'my_option',
+    'new_value',
+    '',
+    /* comment */ yes /* comment */
+);
+$ignored = wp_set_options_autoload( array( 'option1', 'option2' ), $some_variable );
+$ignored = wp_set_OPTION_autoload( 'option1', $some_variable );
+$ignored = wp_set_option_autoload_values(
+    array(
+        'option1' => $some_variable,
+        'option2' => $obj->yes,
+        'option3' => $some_variable ? 'yes' : 'no',
+        'option4' => 'ye' . 's',
+        'option5' => (function () { return 'yes'; })(),
+        'option6' => yes,
+        'option7' => \my_function(),
+        'option8' => \SOME_CONSTANT,
+        'option9' => \YES,
+    )
+);
+
+/*
+ * These are ignored because the option names and the autoload values can't be reliably determined
+ * or the `$options` parameter is empty.
+ */
+$ignored = wp_set_option_autoload_values( $options );
+$ignored = wp_set_option_autoload_values( options: $options );
+$ignored = wp_set_option_autoload_values(array());
+$ignored = wp_set_option_autoload_values([]);
+$ignored = wp_set_option_autoload_values(options: array());
+$ignored = wp_set_option_autoload_values(options: []);
+
+/*
+ * Invalid function calls that are ignored by the sniff as a mandatory parameter is missing.
+ */
+$ignored = wp_set_option_autoload_values();
+$ignored = wp_set_options_autoload( /* some comment */ );
+$ignored = wp_set_options_autoload( array( 'option1', 'option2' ) );
+$ignored = wp_set_option_autoload();
+$ignored = wp_set_option_autoload( 'option1' );
+
+/*
+ * These should all be flagged with a warning.
+ */
+$warning = add_option( 'my_option' );
+$warning = \add_option( 'my_option', 'my_value' );
+if ( add_option( 'my_option', 'my_value', true ) ) {}
+$warning = ADD_OPTION( 'my_option', 'my_value', '', 'auto' );
+$warning = add_option( 'my_option', 'my_value', '', 'auto-on' );
+$warning = add_option(
+    'my_option',
+    'my_value',
+    '',
+    'auto-off'
+);
+$warning = add_option( 'my_option', 'my_value', '', 'invalid_value' );
+$warning = add_option( 'my_option', 'my_value', '', 'true' );
+$warning = add_option( 'my_option', 'my_value', '', "false" );
+$warning = add_option( 'my_option', 'my_value', '', array('some', 'array') );
+$warning = /* comment */ add_option /* comment */ ( 'my_option', 'my_value', '', ['some', 'array'] );
+$warning = add_option( option: 'my_option' );
+$warning = add_option( value: 'my_value', option: 'my_option' );
+$warning = add_option( value: 'my_value', deprecated: '', option: 'my_option' );
+$warning = add_option( value: 'my_value', deprecated: '', autoload: 'auto', option: 'my_option' );
+$warning = add_option( 'my_option', 'my_value', '', 'YES' ); // the uppercase versions of the valid values are not supported.
+$warning = update_option( 'my_option', 'new_value' );
+$warning = update_option( 'my_option', 'new_value', 'auto' );
+$warning = update_option( 'my_option', 'new_value', 'auto-on' );
+$warning = update_option(
+    /* option name */ 'my_option',
+    'new_value' /* option value */,
+    /* autoload value */ 'auto-off' // phpcs:ignore Standard.Category.Sniff -- For test reasons.
+);
+$warning = update_option( 'my_option', 'new_value', 'invalid_value' );
+$warning = update_option( value: 'new_value', option: 'my_option' );
+$warning = update_option( value: 'new_value', autoload: 'auto', option: 'my_option' );
+$warning = update_option( $option_name, get_option( $option_name ) );
+$warning = wp_set_options_autoload( array( 'option1', 'option2' ), 'invalid_value' );
+$warning = wp_set_options_autoload( array( 'option1' ), null );
+$warning = wp_set_option_autoload( 'option1', 'invalid_value' );
+$warning = wp_set_option_autoload( 'option1', \NuLL );
+$warning = wp_set_option_autoload_values( ['option1' => null] );
+$warning = wp_set_option_autoload_values(
+    // phpcs:ignore Standard.Category.Sniff -- For test reasons.
+    [
+        'option1' => '',
+        'option2' => 'true',
+        'option3' => "false",
+        'option4' => array('some', 'array'),
+        'option5' => ['some', 'array'],
+        'option6' => 'YES',
+        'option7' => 'invalid_value',
+        'option8' => 'auto',
+        'option9' /* some comment */ => /* some comment */ 'auto-on',
+        'option10' => 'auto-off',
+        'option11',
+        /* some comment */ 'option12' /* some comment */,
+    ]
+);
+
+// Incorrect function calls, should be flagged by the sniff.
+$incorrect_but_warning = add_option();
+$incorrect_but_warning = update_OPTION();
+$incorrect_but_warning = update_option( 'my_option' );
+$incorrect_but_warning = update_option( autoloader: false, value: 'my_value', option: 'my_option' ); // Typo in the autoload parameter.
+$incorrect_but_warning = add_option( autoload: true, 'my_option' );
+$incorrect_but_warning = add_option( autoload: false );
+
+/*
+ * These should all be flagged with a warning and auto-fixed.
+ */
+$autofix_warning = add_option( 'my_option', 'my_value', '', true );
+$autofix_warning = add_option( 'my_option', 'my_value', '', false );
+$autofix_warning = add_option( 'my_option', 'my_value', '', true );
+$autofix_warning = add_option( 'my_option', 'my_value', '', false );
+$autofix_warning = add_option( 'my_option', 'my_value', '', true );
+$autofix_warning = add_option( 'my_option', 'my_value', '', false );
+$autofix_warning = add_option( 'my_option', 'my_value', '', /* weirdly placed comment */ false /* weirdly placed comment */ );
+$autofix_warning = add_option(
+    'my_option',
+    'my_value',
+    '',
+    // weirdly placed comment
+    false
+);
+$autofix_warning = add_option(
+    'my_option',
+    'my_value',
+    '',
+    // phpcs:ignore Standard.Category.Sniff -- For test reasons.
+    false
+);
+$autofix_warning = add_option( 'my_option', 'my_value', '', false );
+$autofix_warning = add_option( value: 'my_value', deprecated: '', autoload: true, option: 'my_option' );
+$autofix_warning = update_option( 'my_option', 'new_value', true );
+$autofix_warning = update_option( 'my_option', 'new_value', false );
+$autofix_warning = update_option( 'my_option', 'new_value', true );
+$autofix_warning = update_option( 'my_option', 'new_value', false );
+$autofix_warning = update_option( value: 'new_value', autoload: true, option: 'my_option' );
+
+$autofix_warning = wp_set_options_autoload( array( 'option1', 'option2' ), true );
+$autofix_warning = wp_set_options_autoload( array( 'option1', 'option2' ), false );
+$autofix_warning = wp_set_option_autoload( 'option1', true );
+$autofix_warning = wp_set_option_autoload( 'option1', false );
+$autofix_warning = WP_SET_OPTION_AUTOLOAD_VALUES(
+    array(
+        'option1' => true,
+        'option2' => false,
+        'option3' => true,
+        'option4' => false,
+    )
+);
+$autofix_warning = Wp_Set_Option_Autoload_Values(
+    options: array(
+        'option1' => true,
+    )
+);
+
+$mixed_autoload_values = wp_set_option_autoload_values(
+    array(
+        'option1' => true,
+        'option2' => false,
+        'option3' => true,
+        'option4' => true,
+        'option5' => $option_value,
+        'option6' => 'auto',
+    )
+);
diff --git a/WordPress/Tests/WP/OptionAutoloadUnitTest.php b/WordPress/Tests/WP/OptionAutoloadUnitTest.php
new file mode 100644
index 000000000..9cc076676
--- /dev/null
+++ b/WordPress/Tests/WP/OptionAutoloadUnitTest.php
@@ -0,0 +1,116 @@
+<?php
+/**
+ * Unit test class for WordPress Coding Standard.
+ *
+ * @package WPCS\WordPressCodingStandards
+ * @link    https://github.com/WordPress/WordPress-Coding-Standards
+ * @license https://opensource.org/licenses/MIT MIT
+ */
+
+namespace WordPressCS\WordPress\Tests\WP;
+
+use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest;
+
+/**
+ * Unit test class for the OptionAutoload sniff.
+ *
+ * @since 3.2.0
+ *
+ * @covers \WordPressCS\WordPress\Sniffs\WP\OptionAutoloadSniff
+ */
+final class OptionAutoloadUnitTest extends AbstractSniffUnitTest {
+
+	/**
+	 * Returns the lines where errors should occur.
+	 *
+	 * @return array<int, int> Key is the line number, value is the number of expected errors.
+	 */
+	public function getErrorList() {
+		return array();
+	}
+
+	/**
+	 * Returns the lines where warnings should occur.
+	 *
+	 * @return array<int, int> Key is the line number, value is the number of expected warnings.
+	 */
+	public function getWarningList() {
+		return array(
+			106 => 1,
+			107 => 1,
+			108 => 1,
+			109 => 1,
+			110 => 1,
+			115 => 1,
+			117 => 1,
+			118 => 1,
+			119 => 1,
+			120 => 1,
+			121 => 1,
+			122 => 1,
+			123 => 1,
+			124 => 1,
+			125 => 1,
+			126 => 1,
+			127 => 1,
+			128 => 1,
+			129 => 1,
+			133 => 1,
+			135 => 1,
+			136 => 1,
+			137 => 1,
+			138 => 1,
+			139 => 1,
+			140 => 1,
+			141 => 1,
+			142 => 1,
+			143 => 1,
+			147 => 1,
+			148 => 1,
+			149 => 1,
+			150 => 1,
+			151 => 1,
+			152 => 1,
+			153 => 1,
+			154 => 1,
+			155 => 1,
+			156 => 1,
+			157 => 1,
+			158 => 1,
+			163 => 1,
+			164 => 1,
+			165 => 1,
+			166 => 1,
+			167 => 1,
+			168 => 1,
+			173 => 1,
+			174 => 1,
+			175 => 1,
+			176 => 1,
+			177 => 1,
+			178 => 1,
+			179 => 1,
+			185 => 1,
+			192 => 1,
+			194 => 1,
+			195 => 1,
+			196 => 1,
+			197 => 1,
+			198 => 1,
+			199 => 1,
+			200 => 1,
+			202 => 1,
+			203 => 1,
+			204 => 1,
+			205 => 1,
+			208 => 1,
+			209 => 1,
+			210 => 1,
+			211 => 1,
+			216 => 1,
+			222 => 1,
+			224 => 1,
+			227 => 1,
+		);
+	}
+}