diff --git a/WordPress-Extra/ruleset.xml b/WordPress-Extra/ruleset.xml
index f2b1b9e5ba..409dc9e2b6 100644
--- a/WordPress-Extra/ruleset.xml
+++ b/WordPress-Extra/ruleset.xml
@@ -193,6 +193,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 0000000000..4297afecb5
--- /dev/null
+++ b/WordPress/Docs/WP/OptionAutoloadStandard.xml
@@ -0,0 +1,100 @@
+<?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.
+    The autoload flag determines whether the option is automatically loaded on every page load,
+    which can impact site performance.
+    ]]>
+    </standard>
+    <standard>
+    <![CDATA[
+    Even though the autoload parameter is optional for `add_option()` and `update_option()`, it is
+    strongly 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>
+    <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. Plugin/theme code should also not use
+    values for the parameter which are for WP core 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[
+wp_set_options_autoload(
+    array('option1', 'option2'),
+    <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>
+</documentation>
diff --git a/WordPress/Sniffs/WP/OptionAutoloadSniff.php b/WordPress/Sniffs/WP/OptionAutoloadSniff.php
new file mode 100644
index 0000000000..aa127f8926
--- /dev/null
+++ b/WordPress/Sniffs/WP/OptionAutoloadSniff.php
@@ -0,0 +1,442 @@
+<?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
+ * @link https://felix-arntz.me/blog/autoloading-wordpress-options-efficiently-and-responsibly/ For more information on how to use the autoload flag.
+ *
+ * @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_wp_set_option_functions = array(
+		'true'  => 'true',
+		'false' => 'false',
+	);
+
+	/**
+	 * Deprecated values for the `$autoload` parameter.
+	 *
+	 * @since 3.2.0
+	 *
+	 * @var array<string, true> The key is the name of the deprecated value. The array value is irrelevant.
+	 */
+	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> The key is the non-fixable value. The array value is irrelevant.
+	 */
+	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> The key is the fixable value. The array value is irrelevant.
+	 */
+	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> The key is the function name. The value is irrelevant.
+	 */
+	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<int, array<string, int|string>> $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 );
+			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<string, int|string> $options_param Options parameter information.
+	 *
+	 * @return void
+	 */
+	private function handle_wp_set_option_autoload_values( array $options_param ) {
+		$array_token = $this->phpcsFile->findNext(
+			Tokens::$emptyTokens,
+			$options_param['start'],
+			( $options_param['end'] + 1 ),
+			true
+		);
+
+		if ( false === $array_token || 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 ) {
+		// Only display a warning for the functions in which the `$autoload` parameter is optional.
+		if ( isset( $this->autoload_is_optional[ $function_name ] ) ) {
+			$this->phpcsFile->recordMetric( $stackPtr, self::METRIC_NAME, 'param missing' );
+
+			$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<string, int|string> $autoload_info Information about the autoload value (start and end tokens, the
+	 *                                                 clean value and potentially the "raw" value - which isn't used).
+	 * @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'] && is_int( $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_wp_set_option_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.
+			 *
+			 * Exception for `null`: when FQN `\null` is used, PHPCS tokenizes it as T_STRING. Since
+			 * `null` is a known invalid value for the `$autoload` parameter in some functions (not
+			 * an undetermined value), we shouldn't bail in this case.
+			 *
+			 * Similar special treatment for FQN `\true` and `\false` is not needed as these values
+			 * are always valid and already handled in the condition above.
+			 */
+			$this->phpcsFile->recordMetric( $param_first_token, self::METRIC_NAME, 'undetermined value' );
+			return;
+		}
+
+		if ( is_int( $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 first 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 = $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 = 'InternalUseOnlyOnOff';
+			$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 = 'InternalUseOnlyAuto';
+			$data       = array( $autoload_info['clean'] );
+		} else {
+			$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 ( true === $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.1.inc b/WordPress/Tests/WP/OptionAutoloadUnitTest.1.inc
new file mode 100644
index 0000000000..7cbe4e9281
--- /dev/null
+++ b/WordPress/Tests/WP/OptionAutoloadUnitTest.1.inc
@@ -0,0 +1,230 @@
+<?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 );
+$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.1.inc.fixed b/WordPress/Tests/WP/OptionAutoloadUnitTest.1.inc.fixed
new file mode 100644
index 0000000000..f5ee9e161e
--- /dev/null
+++ b/WordPress/Tests/WP/OptionAutoloadUnitTest.1.inc.fixed
@@ -0,0 +1,230 @@
+<?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 );
+$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.2.inc b/WordPress/Tests/WP/OptionAutoloadUnitTest.2.inc
new file mode 100644
index 0000000000..2d8b8fba02
--- /dev/null
+++ b/WordPress/Tests/WP/OptionAutoloadUnitTest.2.inc
@@ -0,0 +1,8 @@
+<?php
+
+/*
+ * Intentional parse error (missing parameter value after parameter name).
+ * This should be the only test in this file.
+ */
+
+wp_set_option_autoload_values(options:);
diff --git a/WordPress/Tests/WP/OptionAutoloadUnitTest.3.inc b/WordPress/Tests/WP/OptionAutoloadUnitTest.3.inc
new file mode 100644
index 0000000000..9e7f9a7145
--- /dev/null
+++ b/WordPress/Tests/WP/OptionAutoloadUnitTest.3.inc
@@ -0,0 +1,8 @@
+<?php
+
+/*
+ * Intentional parse error (just a namespace separator as the third parameter).
+ * This should be the only test in this file.
+ */
+
+update_option('my_option', 'new_value', \);
diff --git a/WordPress/Tests/WP/OptionAutoloadUnitTest.php b/WordPress/Tests/WP/OptionAutoloadUnitTest.php
new file mode 100644
index 0000000000..30f6208b0f
--- /dev/null
+++ b/WordPress/Tests/WP/OptionAutoloadUnitTest.php
@@ -0,0 +1,129 @@
+<?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.
+	 *
+	 * @param string $testFile The name of the file being tested.
+	 *
+	 * @return array<int, int> Key is the line number, value is the number of expected warnings.
+	 */
+	public function getWarningList( $testFile = '' ) {
+		switch ( $testFile ) {
+			case 'OptionAutoloadUnitTest.1.inc':
+				return array(
+					107 => 1,
+					108 => 1,
+					109 => 1,
+					110 => 1,
+					111 => 1,
+					116 => 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,
+					130 => 1,
+					134 => 1,
+					136 => 1,
+					137 => 1,
+					138 => 1,
+					139 => 1,
+					140 => 1,
+					141 => 1,
+					142 => 1,
+					143 => 1,
+					144 => 1,
+					148 => 1,
+					149 => 1,
+					150 => 1,
+					151 => 1,
+					152 => 1,
+					153 => 1,
+					154 => 1,
+					155 => 1,
+					156 => 1,
+					157 => 1,
+					158 => 1,
+					159 => 1,
+					164 => 1,
+					165 => 1,
+					166 => 1,
+					167 => 1,
+					168 => 1,
+					169 => 1,
+					174 => 1,
+					175 => 1,
+					176 => 1,
+					177 => 1,
+					178 => 1,
+					179 => 1,
+					180 => 1,
+					186 => 1,
+					193 => 1,
+					195 => 1,
+					196 => 1,
+					197 => 1,
+					198 => 1,
+					199 => 1,
+					200 => 1,
+					201 => 1,
+					203 => 1,
+					204 => 1,
+					205 => 1,
+					206 => 1,
+					209 => 1,
+					210 => 1,
+					211 => 1,
+					212 => 1,
+					217 => 1,
+					223 => 1,
+					225 => 1,
+					228 => 1,
+				);
+
+			case 'OptionAutoloadUnitTest.3.inc':
+				return array(
+					8 => 1,
+				);
+
+			default:
+				return array();
+		}
+	}
+}