diff --git a/src/content/concepts/index.mdx b/src/content/concepts/index.mdx
index 6657460d2e15..7ab7f8c465f8 100644
--- a/src/content/concepts/index.mdx
+++ b/src/content/concepts/index.mdx
@@ -138,18 +138,21 @@ In order to use a plugin, you need to `import` it and add it to the `plugins` ar
 **webpack.config.js**
 
 ```js
-import HtmlWebpackPlugin from "html-webpack-plugin";
 import webpack from "webpack"; // to access built-in plugins
 
 export default {
+  entry: "./src/index.html",
+  experiments: {
+    html: true,
+  },
   module: {
     rules: [{ test: /\.js$/, use: "babel-loader" }],
   },
-  plugins: [new HtmlWebpackPlugin({ template: "./src/index.html" })],
+  plugins: [new webpack.ProgressPlugin()],
 };
 ```
 
-In the example above, the `html-webpack-plugin` generates an HTML file for your application and automatically injects all your generated bundles into this file.
+In the example above, the `ProgressPlugin` customizes how build progress is reported. Your `src/index.html` is the entry: webpack bundles the scripts and styles it references and rewrites those URLs to the built filenames, so no plugin is needed to produce the page — see [Native HTML](/guides/native-html/).
 
 T> There are many plugins that webpack provides out of the box! Check out the [list of plugins](/plugins).
 
diff --git a/src/content/concepts/loaders.mdx b/src/content/concepts/loaders.mdx
index 407fe23aea24..8d7232350e04 100644
--- a/src/content/concepts/loaders.mdx
+++ b/src/content/concepts/loaders.mdx
@@ -44,7 +44,7 @@ export default {
 };
 ```
 
-T> Plain `.css` files need no loader at all: webpack parses, extracts and minifies CSS itself — see [`experiments.css`](/configuration/experiments/#experimentscss) and the [Native CSS](/guides/native-css/) guide. A preprocessor still needs its loader, and `type: 'css/auto'` hands what the loader produces to webpack's CSS pipeline.
+T> Plain `.css` files need no loader at all: webpack has experimental built-in CSS support that parses, extracts and minifies CSS itself — see [`experiments.css`](/configuration/experiments/#experimentscss) and the [Native CSS](/guides/native-css/) guide. A preprocessor still needs its loader, and `type: 'css/auto'` hands what the loader produces to webpack's CSS pipeline.
 
 ## Using Loaders
 
diff --git a/src/content/concepts/plugins.mdx b/src/content/concepts/plugins.mdx
index 1df8c6c7b218..b163bc68dfcc 100644
--- a/src/content/concepts/plugins.mdx
+++ b/src/content/concepts/plugins.mdx
@@ -52,14 +52,16 @@ Depending on how you are using webpack, there are multiple ways to use plugins.
 ```js
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import HtmlWebpackPlugin from "html-webpack-plugin";
 import webpack from "webpack"; // to access built-in plugins
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 export default {
-  entry: "./path/to/my/entry/file.js",
+  entry: "./src/index.html",
+  experiments: {
+    html: true,
+  },
   output: {
     filename: "my-first-webpack.bundle.js",
     path: path.resolve(__dirname, "dist"),
@@ -72,14 +74,11 @@ export default {
       },
     ],
   },
-  plugins: [
-    new webpack.ProgressPlugin(),
-    new HtmlWebpackPlugin({ template: "./src/index.html" }),
-  ],
+  plugins: [new webpack.ProgressPlugin()],
 };
 ```
 
-The `ProgressPlugin` is used to customize how progress should be reported during compilation, and `HtmlWebpackPlugin` will generate a HTML file including the `my-first-webpack.bundle.js` file using a `script` tag.
+The `ProgressPlugin` is used to customize how progress should be reported during compilation. `src/index.html` is the entry, so webpack emits it as the page with the `<script src>` it references rewritten to the built chunk — no plugin is needed for that, see [Native HTML](/guides/native-html/).
 
 ### Node API
 
diff --git a/src/content/configuration/configuration-languages.mdx b/src/content/configuration/configuration-languages.mdx
index d43678e99775..02bbbfb115dc 100644
--- a/src/content/configuration/configuration-languages.mdx
+++ b/src/content/configuration/configuration-languages.mdx
@@ -186,7 +186,6 @@ and then proceed to write your configuration:
 ```coffeescript
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
-import HtmlWebpackPlugin from 'html-webpack-plugin'
 import webpack from 'webpack'
 
 __filename = fileURLToPath(import.meta.url)
@@ -194,7 +193,9 @@ __dirname = path.dirname(__filename)
 
 config =
   mode: 'production'
-  entry: './path/to/my/entry/file.js'
+  entry: './src/index.html'
+  experiments:
+    html: true
   output:
     path: path.resolve(__dirname, 'dist')
     filename: 'my-first-webpack.bundle.js'
@@ -206,7 +207,7 @@ config =
       }
     ]
   plugins: [
-    new HtmlWebpackPlugin(template: './src/index.html')
+    new webpack.ProgressPlugin()
   ]
 
 export default config
diff --git a/src/content/guides/asset-management.mdx b/src/content/guides/asset-management.mdx
index 317bf3d574a5..f2b9ff60318b 100644
--- a/src/content/guides/asset-management.mdx
+++ b/src/content/guides/asset-management.mdx
@@ -70,7 +70,7 @@ Webpack understands CSS on its own, so you can `import` a CSS file from a JavaSc
 import "./style.css";
 ```
 
-Webpack parses the file — resolving its `@import` and `url()` references — and extracts it into a `.css` output file next to your bundle. CSS Modules, minification and content hashes all come from the same built-in support; the [Native CSS](/guides/native-css/) guide covers the whole feature set.
+Webpack parses the file — resolving its `@import` and `url()` references — and extracts it into a `.css` output file next to your bundle. CSS Modules, minification and content hashes all come from the same built-in support, which is still experimental; [What's built-in](/guides/native-css/#whats-built-in) states what it covers and what still needs a loader.
 
 T> Built-in CSS is controlled by [`experiments.css`](/configuration/experiments/#experimentscss), which defaults to `'auto'`: it turns itself on unless a `module.rules` entry with a loader already matches your `.css` files. That means an existing `css-loader` / `style-loader` setup keeps working untouched — see [migrating off the CSS loaders](/guides/native-css/#migration-guide).
 
diff --git a/src/content/guides/caching.mdx b/src/content/guides/caching.mdx
index dc23e2f68576..d64ac6dac844 100644
--- a/src/content/guides/caching.mdx
+++ b/src/content/guides/caching.mdx
@@ -31,6 +31,8 @@ We can use the `output.filename` [substitutions](/configuration/output/#outputfi
 
 Let's get our project set up using the example from [getting started](/guides/getting-started) with the `plugins` from [output management](/guides/output-management), so we don't have to deal with maintaining our `index.html` file manually:
 
+T> Webpack can generate the page itself with [`output.html`](/configuration/output/#outputhtml) — see [Native HTML](/guides/native-html/). This guide keeps `HtmlWebpackPlugin` because the generated page re-enters the entry's script under an internal chunk name, which would obscure the bundle filenames this guide is about.
+
 **project**
 
 ```diff
diff --git a/src/content/guides/development.mdx b/src/content/guides/development.mdx
index 5a949c145a29..e67357b979fe 100644
--- a/src/content/guides/development.mdx
+++ b/src/content/guides/development.mdx
@@ -201,6 +201,8 @@ The only downside is that you have to refresh your browser in order to see the c
 
 ### Using webpack-dev-server
 
+T> Webpack can generate the page itself with [`output.html`](/configuration/output/#outputhtml) — see [Native HTML](/guides/native-html/). This guide keeps `HtmlWebpackPlugin` because it emits one page per entrypoint rather than a single page carrying every entry's script, so the output here would not be the same.
+
 The `webpack-dev-server` provides you with a rudimentary web server and the ability to use live reloading. Let's set it up:
 
 ```bash
diff --git a/src/content/guides/hot-module-replacement.mdx b/src/content/guides/hot-module-replacement.mdx
index 0db246e82d23..64cf42c8fa08 100644
--- a/src/content/guides/hot-module-replacement.mdx
+++ b/src/content/guides/hot-module-replacement.mdx
@@ -38,6 +38,8 @@ W> **HMR** is not intended for use in production, meaning it should only be used
 
 ## Enabling HMR
 
+T> Webpack can generate the page itself with [`output.html`](/configuration/output/#outputhtml) — see [Native HTML](/guides/native-html/). This guide keeps `HtmlWebpackPlugin` because it emits one page per entrypoint rather than a single page carrying every entry's script, so the output here would not be the same.
+
 This feature is great for productivity. All we need to do is update our [webpack-dev-server](https://github.com/webpack/webpack-dev-server) configuration, and use webpack's built-in HMR plugin. We'll also remove the entry point for `print.js` as it will now be consumed by the `index.js` module.
 
 Since `webpack-dev-server` v4.0.0, Hot Module Replacement is enabled by default.
diff --git a/src/content/guides/modern-web-platform.mdx b/src/content/guides/modern-web-platform.mdx
index ba31c73fab32..c2532d0a0388 100644
--- a/src/content/guides/modern-web-platform.mdx
+++ b/src/content/guides/modern-web-platform.mdx
@@ -160,7 +160,6 @@ npm install workbox-webpack-plugin workbox-precaching --save-dev
 ```js
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import HtmlWebpackPlugin from "html-webpack-plugin";
 import { InjectManifest } from "workbox-webpack-plugin";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -168,13 +167,23 @@ const __dirname = path.dirname(__filename);
 
 export default {
   entry: "./src/index.js",
+  experiments: {
+    html: true,
+  },
   output: {
     filename: "[name].[contenthash].js",
+    htmlFilename: "index.html",
     path: path.resolve(__dirname, "dist"),
     clean: true,
+    html: {
+      title: "PWA + content hashes",
+      meta: {
+        charset: "utf8",
+        viewport: "width=device-width, initial-scale=1",
+      },
+    },
   },
   plugins: [
-    new HtmlWebpackPlugin({ title: "PWA + content hashes" }),
     new InjectManifest({
       swSrc: path.resolve(__dirname, "src/service-worker.js"),
       swDest: "service-worker.js",
diff --git a/src/content/guides/native-css.mdx b/src/content/guides/native-css.mdx
index f1a2828a6466..ac880f168295 100644
--- a/src/content/guides/native-css.mdx
+++ b/src/content/guides/native-css.mdx
@@ -25,7 +25,22 @@ export default {
 };
 ```
 
-With this option enabled, webpack understands `.css` files as first-class modules — parsing `@import` and `url()`, extracting stylesheets, generating content hashes, minifying, and supporting CSS Modules — without `css-loader`, `style-loader`, `mini-css-extract-plugin`, or `css-minimizer-webpack-plugin`.
+With this option enabled, webpack understands `.css` files as first-class modules: it parses them itself instead of handing them to a loader.
+
+## What's built-in
+
+"Built-in" means webpack does the work itself, with no loader in the chain — not that it covers everything the CSS loaders do. The scope is exactly this:
+
+| Built in                                                                                           | Still needs a loader or plugin                                                                           |
+| -------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
+| Parsing `.css`; resolving `@import` and `url()` / `image-set()` / `src()` / `image()`              | **Preprocessors** — Sass, Less, Stylus and PostCSS always keep their loaders                             |
+| [CSS Modules](#css-modules): `composes`, `@value`, `:export`, `:local()` / `:global()`             | `css-loader`'s `importLoaders`, `localIdentRegExp`, `getJSON`, and the `url` / `import` filter callbacks |
+| [Extracting](#output-modes-exporttype) a `.css` file, or injecting a `<style>` tag at runtime      | `style-loader`'s `insert`, `attributes`, `styleTagTransform`, and its lazy / singleton injection modes   |
+| Content hashes, [minification](#minification) and browserslist [vendor prefixes](#vendor-prefixes) | Anything a PostCSS plugin does beyond `@custom-media` / `@custom-selector`                               |
+| [`@custom-media` and `@custom-selector`](#custom-media-and-custom-selectors)                       |                                                                                                          |
+| Hot Module Replacement for stylesheets                                                             |                                                                                                          |
+
+So a project whose CSS setup is `css-loader` + `style-loader` (or `mini-css-extract-plugin`) with default options needs no CSS loader at all. A project that reaches for the options in the right-hand column keeps that loader for the files that need it — the two can coexist, rule by rule.
 
 T> Since webpack 5.109.0 the option defaults to `'auto'`: built-in CSS support turns on unless a [`module.rules`](/configuration/module/#modulerules) entry with a loader (or an explicit module type) already matches `.css` files. An existing `css-loader` setup therefore keeps working untouched, and you can migrate one rule at a time. Set it to `true` to force the native support, or `false` to switch it off.
 
diff --git a/src/content/guides/native-html.mdx b/src/content/guides/native-html.mdx
index 8f8903d2e35d..6ab588ba6987 100644
--- a/src/content/guides/native-html.mdx
+++ b/src/content/guides/native-html.mdx
@@ -24,7 +24,22 @@ export default {
 };
 ```
 
-With this option enabled, webpack understands `.html` files as first-class modules — parsing tags, resolving every URL they reference, bundling inline `<script>` and `<style>` bodies, emitting hashed assets, and writing the rewritten HTML back out — without `html-loader` or `html-webpack-plugin`.
+With this option enabled, webpack understands `.html` files as first-class modules: it parses them itself instead of handing them to a loader.
+
+## What's built-in
+
+"Built-in" means webpack does the work itself, with no loader or plugin in the chain — not that it covers everything `html-loader` and `html-webpack-plugin` do. The scope is exactly this:
+
+| Built in                                                                                                                | Still needs a loader or plugin                                                                                                        |
+| ----------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
+| Parsing `.html`, as an [entry point](#1-html-as-an-entry-point) or [imported from JS](#3-html-imported-from-javascript) | **Template engines** — Pug, EJS, Handlebars and friends, unless a synchronous [`template`](#templating) hook is enough                |
+| [Extracting every URL a page references](#what-webpack-bundles-from-a-page) and rewriting it to the built filename      | `html-loader`'s `sources.scriptingEnabled` and `postprocessor`                                                                        |
+| Bundling inline `<script>` and `<style>` bodies, and `style=""` attributes                                              | `html-webpack-plugin`'s `chunksSortMode`, `xhtml`, `showErrors` and `cache`                                                           |
+| [Generating a page](#2-a-generated-page-for-a-javascript-entry) per entrypoint with its chunks injected                 | The third-party plugins that tap `html-webpack-plugin`'s hooks, which have no counterpart on [`HtmlModulesPlugin`](#plugin-hooks) yet |
+| [`title`, `meta`, `base`, `favicon`, `manifest`, `integrity`, `csp`, inlining](#configuring-the-generated-page)         |                                                                                                                                       |
+| [Minification](#minification) and Hot Module Replacement                                                                |                                                                                                                                       |
+
+So a project using `html-webpack-plugin` to scaffold a document around its bundles, or `html-loader` to import a partial, needs neither. A project that renders its page through a template engine, or depends on a plugin that hooks into `html-webpack-plugin`, keeps that plugin.
 
 T> Since webpack 5.109.0 the option defaults to `'auto'`: built-in HTML support turns on unless a [`module.rules`](/configuration/module/#modulerules) entry with a loader (or an explicit module type) already matches `.html` files. An existing `html-loader` setup therefore keeps working untouched, and you can migrate one rule at a time. [`experiments.futureDefaults`](/configuration/experiments/#experimentsfuturedefaults) resolves it to `true`.
 
@@ -335,7 +350,9 @@ export default {
 };
 ```
 
-Every icon — including the ones named inside the manifest — is emitted as a hashed asset through the normal pipeline, so `favicons-webpack-plugin` and friends are no longer needed. Both apply to webpack-generated pages only: an authored page is left exactly as written, so add the `<link>` tags to the page itself when you own its markup. Both options also accept a function receiving the page name, which is how you give each page of a multi-page build its own icon set.
+Every icon — including the ones named inside the manifest — is emitted as a hashed asset through the normal pipeline. Both options also accept a function receiving the page name, which is how you give each page of a multi-page build its own icon set.
+
+Two limits are worth knowing. Webpack emits the icons you point it at; it does not generate the size and format variants a dedicated plugin such as `favicons-webpack-plugin` produces from one source image. And both options apply to webpack-generated pages only — an authored page is left exactly as written, so add the `<link>` tags to the page yourself when you own its markup.
 
 ### Subresource Integrity and CSP
 
diff --git a/src/content/guides/output-management.mdx b/src/content/guides/output-management.mdx
index 84b48ff7d73e..6384f2de787f 100644
--- a/src/content/guides/output-management.mdx
+++ b/src/content/guides/output-management.mdx
@@ -141,6 +141,8 @@ Multiple entry points are used here solely to demonstrate output management and
 
 ## Setting up HtmlWebpackPlugin
 
+T> Webpack can generate the page itself with [`output.html`](/configuration/output/#outputhtml) — see [Native HTML](/guides/native-html/). This guide keeps `HtmlWebpackPlugin` because the generated page re-enters the entry's script under an internal chunk name, which would obscure the bundle filenames this guide is about.
+
 First install the plugin and adjust the `webpack.config.js` file:
 
 ```bash
diff --git a/src/content/guides/production.mdx b/src/content/guides/production.mdx
index 4b3c4f379b4c..12f7fac7e455 100644
--- a/src/content/guides/production.mdx
+++ b/src/content/guides/production.mdx
@@ -65,7 +65,6 @@ npm install --save-dev webpack-merge
 ```diff
 + import path from 'node:path';
 + import { fileURLToPath } from 'node:url';
-+ import HtmlWebpackPlugin from 'html-webpack-plugin';
 +
 + const __filename = fileURLToPath(import.meta.url);
 + const __dirname = path.dirname(__filename);
@@ -74,15 +73,21 @@ npm install --save-dev webpack-merge
 +   entry: {
 +     app: './src/index.js',
 +   },
-+   plugins: [
-+     new HtmlWebpackPlugin({
-+       title: 'Production',
-+     }),
-+   ],
++   experiments: {
++     html: true,
++   },
 +   output: {
 +     filename: '[name].bundle.js',
++     htmlFilename: 'index.html',
 +     path: path.resolve(__dirname, 'dist'),
 +     clean: true,
++     html: {
++       meta: {
++         charset: 'UTF-8',
++         viewport: 'width=device-width, initial-scale=1',
++       },
++       title: 'Production',
++     },
 +   },
 + };
 ```
@@ -142,7 +147,6 @@ Now, let's modify our npm scripts to use the new configuration files. For the `s
       "css-loader": "^7.1.3",
       "csv-loader": "^3.0.5",
       "express": "^5.2.1",
-      "html-webpack-plugin": "^5.6.6",
       "style-loader": "^4.0.0",
       "webpack": "^5.105.0",
       "webpack-cli": "^7.0.0",
diff --git a/src/content/guides/progressive-web-application.mdx b/src/content/guides/progressive-web-application.mdx
index 29b52a2b5f62..6658f3c03d68 100644
--- a/src/content/guides/progressive-web-application.mdx
+++ b/src/content/guides/progressive-web-application.mdx
@@ -56,6 +56,8 @@ This is what we aim to change. Once we reach the end of this module we should be
 
 ## Adding Workbox
 
+T> Webpack can generate the page itself with [`output.html`](/configuration/output/#outputhtml) — see [Native HTML](/guides/native-html/). This guide keeps `HtmlWebpackPlugin` because it emits one page per entrypoint rather than a single page carrying every entry's script, so the output here would not be the same.
+
 Let's add the Workbox webpack plugin and adjust the `webpack.config.js` file:
 
 ```bash
diff --git a/src/content/loaders/index.mdx b/src/content/loaders/index.mdx
index a4a6a52f0af8..e1fad406b7d2 100644
--- a/src/content/loaders/index.mdx
+++ b/src/content/loaders/index.mdx
@@ -13,7 +13,19 @@ contributors:
   - chenxsan
 ---
 
-Webpack enables use of [loaders](/concepts/loaders) to preprocess files. This allows you to bundle any static resource way beyond JavaScript. You can easily write your own loaders using Node.js.
+## What needs no loader
+
+Webpack handles these itself — install a loader only for what is _not_ on this list:
+
+- **JavaScript**, ESM and CommonJS
+- **JSON**
+- **Images, fonts, media and text files** — [Asset Modules](/guides/asset-modules/), which replace `file-loader`, `url-loader` and `raw-loader`
+- **WebAssembly** — [`experiments.asyncWebAssembly`](/configuration/experiments/#experiments)
+- **CSS** — [`experiments.css`](/configuration/experiments/#experimentscss), experimental; see [what it covers](/guides/native-css/#whats-built-in)
+- **HTML** — [`experiments.html`](/configuration/experiments/#experimentshtml), experimental; see [what it covers](/guides/native-html/#whats-built-in)
+- **TypeScript** — [`experiments.typescript`](/configuration/experiments/#experimentstypescript), experimental; erases types on Node.js 22.6+, but does not type-check or handle JSX
+
+Webpack enables use of [loaders](/concepts/loaders) to preprocess everything else. This allows you to bundle any static resource way beyond JavaScript. You can easily write your own loaders using Node.js.
 Loaders are separate packages that extend webpack's capabilities and are maintained within the broader ecosystem.
 Loaders are activated by using `loadername!` prefixes in `import .. from "mod";`/`require()` statements, or are automatically applied via regex from your webpack configuration – see [configuration](/concepts/loaders/#configuration).
 
@@ -38,9 +50,9 @@ Loaders are activated by using `loadername!` prefixes in `import .. from "mod";`
 
 ## Templating
 
-W> Webpack bundles HTML on its own — see [`experiments.html`](/configuration/experiments/#experimentshtml) and the [Native HTML](/guides/native-html/) guide, which also covers migrating off `html-loader`.
+T> Webpack has experimental built-in HTML support ([`experiments.html`](/configuration/experiments/#experimentshtml)) that covers the common setup. Template engines still need their loader — see [What's built-in](/guides/native-html/#whats-built-in).
 
-- [`html-loader`](/loaders/html-loader) **Deprecated** — superseded by webpack's [built-in HTML support](/guides/native-html/). Exports HTML as string, require references to static resources
+- [`html-loader`](/loaders/html-loader) Exports HTML as string, require references to static resources ([built-in alternative](/guides/native-html/#whats-built-in))
 - [`pug-loader`](https://github.com/pugjs/pug-loader) Loads Pug and Jade templates and returns a function
 - [`markdown-loader`](https://github.com/peerigon/markdown-loader) Compiles Markdown to HTML
 - [`react-markdown-loader`](https://github.com/javiercf/react-markdown-loader) Compiles Markdown to a React Component using the markdown-parse parser
@@ -52,10 +64,10 @@ W> Webpack bundles HTML on its own — see [`experiments.html`](/configuration/e
 
 ## Styling
 
-W> Webpack parses, extracts and minifies CSS on its own — see [`experiments.css`](/configuration/experiments/#experimentscss) and the [Native CSS](/guides/native-css/) guide, which also covers migrating off the loaders marked below. Preprocessor loaders (Sass, Less, PostCSS, Stylus) stay: pair them with a `css/auto` rule.
+T> Webpack has experimental built-in CSS support ([`experiments.css`](/configuration/experiments/#experimentscss)) that covers the common setup. It does not replace preprocessors, and a few loader options have no equivalent — see [What's built-in](/guides/native-css/#whats-built-in).
 
-- [`style-loader`](/loaders/style-loader) **Deprecated** — superseded by webpack's [built-in CSS support](/guides/native-css/). Add exports of a module as style to DOM
-- [`css-loader`](/loaders/css-loader) **Deprecated** — superseded by webpack's [built-in CSS support](/guides/native-css/). Loads CSS file with resolved imports and returns CSS code
+- [`style-loader`](/loaders/style-loader) Add exports of a module as style to DOM ([built-in alternative](/guides/native-css/#whats-built-in))
+- [`css-loader`](/loaders/css-loader) Loads CSS file with resolved imports and returns CSS code ([built-in alternative](/guides/native-css/#whats-built-in))
 - [`css-utility-loader`](https://github.com/SahilKhanWDC/css-utility-loader-webpack-.git) - Automatically parses and translates legacy CSS properties into modern utility classes (Tailwind) at build-time.
 - [`less-loader`](/loaders/less-loader) Loads and compiles a LESS file
 - [`sass-loader`](/loaders/sass-loader) Loads and compiles a SASS/SCSS file
diff --git a/src/content/plugins/index.mdx b/src/content/plugins/index.mdx
index 61e438d05272..5fcde04b90d8 100644
--- a/src/content/plugins/index.mdx
+++ b/src/content/plugins/index.mdx
@@ -16,33 +16,33 @@ contributors:
 
 Webpack has a rich plugin interface. Most of the features within webpack itself use this plugin interface. This makes webpack **flexible**.
 
-W> Webpack now bundles CSS and HTML itself, so the plugins marked **Deprecated** below are no longer needed — see the [Native CSS](/guides/native-css/) and [Native HTML](/guides/native-html/) guides for the built-in equivalents and how to migrate.
+T> Webpack has experimental built-in CSS and HTML support, so two plugins below have a built-in alternative for the common case — see what each still covers for [CSS](/guides/native-css/#whats-built-in) and [HTML](/guides/native-html/#whats-built-in).
 
-| Name                                                                            | Description                                                                                                                                                                |
-| ------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| [`BannerPlugin`](/plugins/banner-plugin)                                        | Add a banner to the top of each generated chunk                                                                                                                            |
-| [`ChunksWebpackPlugin`](/plugins/chunks-webpack-plugin/)                        | Create HTML files with entrypoints and chunks relations to serve your bundles                                                                                              |
-| [`CompressionWebpackPlugin`](/plugins/compression-webpack-plugin)               | Prepare compressed versions of assets to serve them with Content-Encoding                                                                                                  |
-| [`ContextReplacementPlugin`](/plugins/context-replacement-plugin)               | Override the inferred context of a `require` expression                                                                                                                    |
-| [`CopyWebpackPlugin`](/plugins/copy-webpack-plugin)                             | Copies individual files or entire directories to the build directory                                                                                                       |
-| [`DefinePlugin`](/plugins/define-plugin)                                        | Allow global constants configured at compile time                                                                                                                          |
-| [`DllPlugin`](/plugins/dll-plugin)                                              | Split bundles in order to drastically improve build time                                                                                                                   |
-| [`EnvironmentPlugin`](/plugins/environment-plugin)                              | Shorthand for using the [`DefinePlugin`](/plugins/define-plugin) on `process.env` keys                                                                                     |
-| [`EslintWebpackPlugin`](/plugins/eslint-webpack-plugin)                         | A ESLint plugin for webpack                                                                                                                                                |
-| [`HotModuleReplacementPlugin`](/plugins/hot-module-replacement-plugin)          | Enable Hot Module Replacement (HMR)                                                                                                                                        |
-| [`HtmlWebpackPlugin`](/plugins/html-webpack-plugin)                             | **Deprecated** — superseded by [`output.html`](/configuration/output/#outputhtml); see [Native HTML](/guides/native-html/). Easily create HTML files to serve your bundles |
-| [`IgnorePlugin`](/plugins/ignore-plugin)                                        | Exclude certain modules from bundles                                                                                                                                       |
-| [`LimitChunkCountPlugin`](/plugins/limit-chunk-count-plugin)                    | Set min/max limits for chunking to better control chunking                                                                                                                 |
-| [`MergeDuplicateChunksPlugin`](/plugins/merge-duplicate-chunks-plugin)          | Merge chunks that contain the same modules                                                                                                                                 |
-| [`MinChunkSizePlugin`](/plugins/min-chunk-size-plugin)                          | Keep chunk size above the specified limit                                                                                                                                  |
-| [`MiniCssExtractPlugin`](/plugins/mini-css-extract-plugin)                      | **Deprecated** — superseded by webpack's [built-in CSS support](/guides/native-css/). Creates a CSS file per JS file which requires CSS                                    |
-| [`NoEmitOnErrorsPlugin`](/configuration/optimization/#optimizationemitonerrors) | Skip the emitting phase when there are compilation errors                                                                                                                  |
-| [`NormalModuleReplacementPlugin`](/plugins/normal-module-replacement-plugin)    | Replace resource(s) that matches a regexp                                                                                                                                  |
-| [`ProgressPlugin`](/plugins/progress-plugin)                                    | Report compilation progress                                                                                                                                                |
-| [`ProvidePlugin`](/plugins/provide-plugin)                                      | Use modules without having to use import/require                                                                                                                           |
-| [`SourceMapDevToolPlugin`](/plugins/source-map-dev-tool-plugin)                 | Enables a more fine grained control of source maps                                                                                                                         |
-| [`EvalSourceMapDevToolPlugin`](/plugins/eval-source-map-dev-tool-plugin)        | Enables a more fine grained control of eval source maps                                                                                                                    |
-| [`SvgChunkWebpackPlugin`](/plugins/svg-chunk-webpack-plugin/)                   | Generate SVG sprites optimized by SVGO based on your entry point dependencies                                                                                              |
-| [`MinimizerPlugin`](/plugins/minimizer-webpack-plugin/)                         | Uses Terser (or other) to minify the JS/CSS/HTML/JSON/etc in your project                                                                                                  |
+| Name                                                                            | Description                                                                                                    |
+| ------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
+| [`BannerPlugin`](/plugins/banner-plugin)                                        | Add a banner to the top of each generated chunk                                                                |
+| [`ChunksWebpackPlugin`](/plugins/chunks-webpack-plugin/)                        | Create HTML files with entrypoints and chunks relations to serve your bundles                                  |
+| [`CompressionWebpackPlugin`](/plugins/compression-webpack-plugin)               | Prepare compressed versions of assets to serve them with Content-Encoding                                      |
+| [`ContextReplacementPlugin`](/plugins/context-replacement-plugin)               | Override the inferred context of a `require` expression                                                        |
+| [`CopyWebpackPlugin`](/plugins/copy-webpack-plugin)                             | Copies individual files or entire directories to the build directory                                           |
+| [`DefinePlugin`](/plugins/define-plugin)                                        | Allow global constants configured at compile time                                                              |
+| [`DllPlugin`](/plugins/dll-plugin)                                              | Split bundles in order to drastically improve build time                                                       |
+| [`EnvironmentPlugin`](/plugins/environment-plugin)                              | Shorthand for using the [`DefinePlugin`](/plugins/define-plugin) on `process.env` keys                         |
+| [`EslintWebpackPlugin`](/plugins/eslint-webpack-plugin)                         | A ESLint plugin for webpack                                                                                    |
+| [`HotModuleReplacementPlugin`](/plugins/hot-module-replacement-plugin)          | Enable Hot Module Replacement (HMR)                                                                            |
+| [`HtmlWebpackPlugin`](/plugins/html-webpack-plugin)                             | Easily create HTML files to serve your bundles ([built-in alternative](/guides/native-html/#whats-built-in))   |
+| [`IgnorePlugin`](/plugins/ignore-plugin)                                        | Exclude certain modules from bundles                                                                           |
+| [`LimitChunkCountPlugin`](/plugins/limit-chunk-count-plugin)                    | Set min/max limits for chunking to better control chunking                                                     |
+| [`MergeDuplicateChunksPlugin`](/plugins/merge-duplicate-chunks-plugin)          | Merge chunks that contain the same modules                                                                     |
+| [`MinChunkSizePlugin`](/plugins/min-chunk-size-plugin)                          | Keep chunk size above the specified limit                                                                      |
+| [`MiniCssExtractPlugin`](/plugins/mini-css-extract-plugin)                      | Creates a CSS file per JS file which requires CSS ([built-in alternative](/guides/native-css/#whats-built-in)) |
+| [`NoEmitOnErrorsPlugin`](/configuration/optimization/#optimizationemitonerrors) | Skip the emitting phase when there are compilation errors                                                      |
+| [`NormalModuleReplacementPlugin`](/plugins/normal-module-replacement-plugin)    | Replace resource(s) that matches a regexp                                                                      |
+| [`ProgressPlugin`](/plugins/progress-plugin)                                    | Report compilation progress                                                                                    |
+| [`ProvidePlugin`](/plugins/provide-plugin)                                      | Use modules without having to use import/require                                                               |
+| [`SourceMapDevToolPlugin`](/plugins/source-map-dev-tool-plugin)                 | Enables a more fine grained control of source maps                                                             |
+| [`EvalSourceMapDevToolPlugin`](/plugins/eval-source-map-dev-tool-plugin)        | Enables a more fine grained control of eval source maps                                                        |
+| [`SvgChunkWebpackPlugin`](/plugins/svg-chunk-webpack-plugin/)                   | Generate SVG sprites optimized by SVGO based on your entry point dependencies                                  |
+| [`MinimizerPlugin`](/plugins/minimizer-webpack-plugin/)                         | Uses Terser (or other) to minify the JS/CSS/HTML/JSON/etc in your project                                      |
 
 For more third-party plugins, see the list from [awesome-webpack](/awesome-webpack/#webpack-plugins).