diff --git a/includes/sanitizers/class-amp-base-sanitizer.php b/includes/sanitizers/class-amp-base-sanitizer.php
index b98c645b88b..aba63e03f2b 100644
--- a/includes/sanitizers/class-amp-base-sanitizer.php
+++ b/includes/sanitizers/class-amp-base-sanitizer.php
@@ -436,6 +436,11 @@ public function prepare_validation_error( array $error = array(), array $data =
 			if ( ! isset( $error['code'] ) ) {
 				$error['code'] = AMP_Validation_Error_Taxonomy::INVALID_ELEMENT_CODE;
 			}
+
+			if ( ! isset( $error['type'] ) ) {
+				$error['type'] = 'script' === $node->nodeName ? AMP_Validation_Error_Taxonomy::JS_ERROR_TYPE : AMP_Validation_Error_Taxonomy::HTML_ELEMENT_ERROR_TYPE;
+			}
+
 			$error['node_attributes'] = array();
 			foreach ( $node->attributes as $attribute ) {
 				$error['node_attributes'][ $attribute->nodeName ] = $attribute->nodeValue;
@@ -456,6 +461,10 @@ public function prepare_validation_error( array $error = array(), array $data =
 			if ( ! isset( $error['code'] ) ) {
 				$error['code'] = AMP_Validation_Error_Taxonomy::INVALID_ATTRIBUTE_CODE;
 			}
+			if ( ! isset( $error['type'] ) ) {
+				// If this is an attribute that begins with on, like onclick, it should be a js_error.
+				$error['type'] = preg_match( '/^on\w+/', $node->nodeName ) ? AMP_Validation_Error_Taxonomy::JS_ERROR_TYPE : AMP_Validation_Error_Taxonomy::HTML_ATTRIBUTE_ERROR_TYPE;
+			}
 			$error['element_attributes'] = array();
 			if ( $node->parentNode && $node->parentNode->hasAttributes() ) {
 				foreach ( $node->parentNode->attributes as $attribute ) {
diff --git a/includes/sanitizers/class-amp-style-sanitizer.php b/includes/sanitizers/class-amp-style-sanitizer.php
index 050c24c69e1..6a7703f2dcf 100644
--- a/includes/sanitizers/class-amp-style-sanitizer.php
+++ b/includes/sanitizers/class-amp-style-sanitizer.php
@@ -673,6 +673,7 @@ private function process_link_element( DOMElement $element ) {
 				$this->remove_invalid_child( $element, array(
 					'code'    => $css_file_path->get_error_code(),
 					'message' => $css_file_path->get_error_message(),
+					'type'    => AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
 				) );
 				return;
 			} else {
@@ -682,6 +683,7 @@ private function process_link_element( DOMElement $element ) {
 			$this->remove_invalid_child( $element, array(
 				'code'    => $css_file_path->get_error_code(),
 				'message' => $css_file_path->get_error_message(),
+				'type'    => AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
 			) );
 			return;
 		} else {
@@ -691,6 +693,7 @@ private function process_link_element( DOMElement $element ) {
 		if ( false === $stylesheet ) {
 			$this->remove_invalid_child( $element, array(
 				'code' => 'stylesheet_file_missing',
+				'type' => AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
 			) );
 			return;
 		}
@@ -887,6 +890,7 @@ private function parse_import_stylesheet( Import $item, CSSList $css_list, $opti
 				$error     = array(
 					'code'    => $contents->get_error_code(),
 					'message' => $contents->get_error_message(),
+					'type'    => AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
 				);
 				$sanitized = $this->should_sanitize_validation_error( $error );
 				if ( $sanitized ) {
@@ -901,6 +905,7 @@ private function parse_import_stylesheet( Import $item, CSSList $css_list, $opti
 			$error     = array(
 				'code'    => $css_file_path->get_error_code(),
 				'message' => $css_file_path->get_error_message(),
+				'type'    => AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
 			);
 			$sanitized = $this->should_sanitize_validation_error( $error );
 			if ( $sanitized ) {
@@ -988,6 +993,7 @@ function ( $value ) {
 			$error = array(
 				'code'    => 'css_parse_error',
 				'message' => $exception->getMessage(),
+				'type'    => AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
 			);
 
 			/*
@@ -1239,6 +1245,7 @@ private function process_css_list( CSSList $css_list, $options ) {
 					$error     = array(
 						'code'    => 'illegal_css_at_rule',
 						'at_rule' => $css_item->atRuleName(),
+						'type'    => AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
 					);
 					$sanitized = $this->should_sanitize_validation_error( $error );
 					$results[] = compact( 'error', 'sanitized' );
@@ -1259,6 +1266,7 @@ private function process_css_list( CSSList $css_list, $options ) {
 					$error     = array(
 						'code'    => 'illegal_css_at_rule',
 						'at_rule' => $css_item->atRuleName(),
+						'type'    => AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
 					);
 					$sanitized = $this->should_sanitize_validation_error( $error );
 					$results[] = compact( 'error', 'sanitized' );
@@ -1275,6 +1283,7 @@ private function process_css_list( CSSList $css_list, $options ) {
 					$error     = array(
 						'code'    => 'illegal_css_at_rule',
 						'at_rule' => $css_item->atRuleName(),
+						'type'    => AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
 					);
 					$sanitized = $this->should_sanitize_validation_error( $error );
 					$results[] = compact( 'error', 'sanitized' );
@@ -1290,6 +1299,7 @@ private function process_css_list( CSSList $css_list, $options ) {
 				$error     = array(
 					'code'    => 'illegal_css_at_rule',
 					'at_rule' => $css_item->atRuleName(),
+					'type'    => AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
 				);
 				$sanitized = $this->should_sanitize_validation_error( $error );
 				$results[] = compact( 'error', 'sanitized' );
@@ -1297,6 +1307,7 @@ private function process_css_list( CSSList $css_list, $options ) {
 				$error     = array(
 					'code' => 'unrecognized_css',
 					'item' => get_class( $css_item ),
+					'type' => AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
 				);
 				$sanitized = $this->should_sanitize_validation_error( $error );
 				$results[] = compact( 'error', 'sanitized' );
@@ -1382,6 +1393,7 @@ private function process_css_declaration_block( RuleSet $ruleset, CSSList $css_l
 						'code'           => 'illegal_css_property',
 						'property_name'  => $property->getRule(),
 						'property_value' => $property->getValue(),
+						'type'           => AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
 					);
 					$sanitized = $this->should_sanitize_validation_error( $error );
 					if ( $sanitized ) {
@@ -1398,6 +1410,7 @@ private function process_css_declaration_block( RuleSet $ruleset, CSSList $css_l
 						'code'           => 'illegal_css_property',
 						'property_name'  => $property->getRule(),
 						'property_value' => (string) $property->getValue(),
+						'type'           => AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
 					);
 					$sanitized = $this->should_sanitize_validation_error( $error );
 					if ( $sanitized ) {
@@ -1556,6 +1569,7 @@ private function process_css_keyframes( KeyFrame $css_list, $options ) {
 					$error     = array(
 						'code' => 'unrecognized_css',
 						'item' => get_class( $rules ),
+						'type' => AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
 					);
 					$sanitized = $this->should_sanitize_validation_error( $error );
 					if ( $sanitized ) {
@@ -1578,6 +1592,7 @@ private function process_css_keyframes( KeyFrame $css_list, $options ) {
 							'code'           => 'illegal_css_property',
 							'property_name'  => $property->getRule(),
 							'property_value' => (string) $property->getValue(),
+							'type'           => AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
 						);
 						$sanitized = $this->should_sanitize_validation_error( $error );
 						if ( $sanitized ) {
@@ -1623,6 +1638,7 @@ private function transform_important_qualifiers( RuleSet $ruleset, CSSList $css_
 				} else {
 					$error     = array(
 						'code' => 'illegal_css_important',
+						'type' => AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
 					);
 					$sanitized = $this->should_sanitize_validation_error( $error );
 					if ( $sanitized ) {
@@ -1901,6 +1917,7 @@ private function finalize_styles() {
 			if ( ! $body ) {
 				$this->should_sanitize_validation_error( array(
 					'code' => 'missing_body_element',
+					'type' => AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
 				) );
 			} else {
 				$style_element = $this->dom->createElement( 'style' );
@@ -1997,6 +2014,7 @@ private function finalize_stylesheet_set( $stylesheet_set ) {
 		if ( $is_too_much_css && $should_tree_shake && empty( $this->args['accept_tree_shaking'] ) ) {
 			$should_tree_shake = $this->should_sanitize_validation_error( array(
 				'code' => self::TREE_SHAKING_ERROR_CODE,
+				'type' => AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
 			) );
 		}
 
@@ -2066,6 +2084,7 @@ private function finalize_stylesheet_set( $stylesheet_set ) {
 			if ( $final_size + $sheet_size > $stylesheet_set['cdata_spec']['max_bytes'] ) {
 				$validation_error = array(
 					'code' => 'excessive_css',
+					'type' => AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
 				);
 				if ( isset( $pending_stylesheet['sources'] ) ) {
 					$validation_error['sources'] = $pending_stylesheet['sources'];
diff --git a/includes/validation/class-amp-invalid-url-post-type.php b/includes/validation/class-amp-invalid-url-post-type.php
index 39b88dfe1a8..f99504d336f 100644
--- a/includes/validation/class-amp-invalid-url-post-type.php
+++ b/includes/validation/class-amp-invalid-url-post-type.php
@@ -131,8 +131,8 @@ public static function add_admin_hooks() {
 		add_action( 'add_meta_boxes', array( __CLASS__, 'add_meta_boxes' ) );
 		add_action( 'edit_form_top', array( __CLASS__, 'print_url_as_title' ) );
 		add_filter( 'the_title', array( __CLASS__, 'filter_the_title_in_post_list_table' ), 10, 2 );
+		add_action( 'restrict_manage_posts', array( __CLASS__, 'render_post_filters' ), 10, 2 );
 
-		add_filter( 'views_edit-' . self::POST_TYPE_SLUG, array( __CLASS__, 'filter_views_edit' ) );
 		add_filter( 'manage_' . self::POST_TYPE_SLUG . '_posts_columns', array( __CLASS__, 'add_post_columns' ) );
 		add_action( 'manage_posts_custom_column', array( __CLASS__, 'output_custom_column' ), 10, 2 );
 		add_filter( 'post_row_actions', array( __CLASS__, 'filter_row_actions' ), 10, 2 );
@@ -497,122 +497,6 @@ public static function get_post_staleness( $post ) {
 		return $staleness;
 	}
 
-	/**
-	 * Add views for filtering validation errors by status.
-	 *
-	 * @param array $views Views.
-	 * @return array Views
-	 */
-	public static function filter_views_edit( $views ) {
-		unset( $views['publish'] );
-
-		$args = array(
-			'post_type'              => self::POST_TYPE_SLUG,
-			'update_post_meta_cache' => false,
-			'update_post_term_cache' => false,
-		);
-
-		$with_new_query      = new WP_Query( array_merge(
-			$args,
-			array( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_STATUS_QUERY_VAR => AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_NEW_STATUS )
-		) );
-		$with_rejected_query = new WP_Query( array_merge(
-			$args,
-			array( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_STATUS_QUERY_VAR => AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_REJECTED_STATUS )
-		) );
-		$with_accepted_query = new WP_Query( array_merge(
-			$args,
-			array( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_STATUS_QUERY_VAR => AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACCEPTED_STATUS )
-		) );
-
-		$current_url = remove_query_arg(
-			array_merge(
-				wp_removable_query_args(),
-				array( 's' ) // For some reason behavior of posts list table is to not persist the search query.
-			),
-			wp_unslash( $_SERVER['REQUEST_URI'] )
-		);
-
-		$current_status = null;
-		if ( isset( $_GET[ AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_STATUS_QUERY_VAR ] ) ) { // WPCS: CSRF ok.
-			$value = intval( $_GET[ AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_STATUS_QUERY_VAR ] ); // WPCS: CSRF ok.
-			if ( in_array( $value, array( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_NEW_STATUS, AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACCEPTED_STATUS, AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_REJECTED_STATUS ), true ) ) {
-				$current_status = $value;
-			}
-		}
-
-		$views['new'] = sprintf(
-			'<a href="%s" class="%s">%s</a>',
-			esc_url(
-				add_query_arg(
-					AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_STATUS_QUERY_VAR,
-					AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_NEW_STATUS,
-					$current_url
-				)
-			),
-			AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_NEW_STATUS === $current_status ? 'current' : '',
-			sprintf(
-				/* translators: %s: the post count. */
-				_nx(
-					'With New Errors <span class="count">(%s)</span>',
-					'With New Errors <span class="count">(%s)</span>',
-					$with_new_query->found_posts,
-					'posts',
-					'amp'
-				),
-				number_format_i18n( $with_new_query->found_posts )
-			)
-		);
-
-		$views['rejected'] = sprintf(
-			'<a href="%s" class="%s">%s</a>',
-			esc_url(
-				add_query_arg(
-					AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_STATUS_QUERY_VAR,
-					AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_REJECTED_STATUS,
-					$current_url
-				)
-			),
-			AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_REJECTED_STATUS === $current_status ? 'current' : '',
-			sprintf(
-				/* translators: %s: the post count. */
-				_nx(
-					'With Rejected Errors <span class="count">(%s)</span>',
-					'With Rejected Errors <span class="count">(%s)</span>',
-					$with_rejected_query->found_posts,
-					'posts',
-					'amp'
-				),
-				number_format_i18n( $with_rejected_query->found_posts )
-			)
-		);
-
-		$views['accepted'] = sprintf(
-			'<a href="%s" class="%s">%s</a>',
-			esc_url(
-				add_query_arg(
-					AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_STATUS_QUERY_VAR,
-					AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACCEPTED_STATUS,
-					$current_url
-				)
-			),
-			AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACCEPTED_STATUS === $current_status ? 'current' : '',
-			sprintf(
-				/* translators: %s: the post count. */
-				_nx(
-					'With Accepted Errors <span class="count">(%s)</span>',
-					'With Accepted Errors <span class="count">(%s)</span>',
-					$with_accepted_query->found_posts,
-					'posts',
-					'amp'
-				),
-				number_format_i18n( $with_accepted_query->found_posts )
-			)
-		);
-
-		return $views;
-	}
-
 	/**
 	 * Adds post columns to the UI for the validation errors.
 	 *
@@ -1475,6 +1359,19 @@ public static function filter_the_title_in_post_list_table( $title, $post ) {
 		return $title;
 	}
 
+	/**
+	 * Renders the filters on the invalid URL post type edit.php page.
+	 *
+	 * @param string $post_type The slug of the post type.
+	 * @param string $which     The location for the markup, either 'top' or 'bottom'.
+	 */
+	public static function render_post_filters( $post_type, $which ) {
+		if ( self::POST_TYPE_SLUG === $post_type && 'top' === $which ) {
+			AMP_Validation_Error_Taxonomy::render_error_status_filter();
+			AMP_Validation_Error_Taxonomy::render_error_type_filter();
+		}
+	}
+
 	/**
 	 * Gets the URL to recheck the post for AMP validity.
 	 *
diff --git a/includes/validation/class-amp-validation-error-taxonomy.php b/includes/validation/class-amp-validation-error-taxonomy.php
index 8505e0f5669..f02c25ea56e 100644
--- a/includes/validation/class-amp-validation-error-taxonomy.php
+++ b/includes/validation/class-amp-validation-error-taxonomy.php
@@ -61,6 +61,30 @@ class AMP_Validation_Error_Taxonomy {
 	 */
 	const VALIDATION_ERROR_STATUS_QUERY_VAR = 'amp_validation_error_status';
 
+	/**
+	 * Query var used when filtering for the validation error type.
+	 *
+	 * @var string
+	 */
+	const VALIDATION_ERROR_TYPE_QUERY_VAR = 'amp_validation_error_type';
+
+	/**
+	 * The <option> value to not filter at all, like for 'All Statuses'.
+	 *
+	 * This is also used in WP_List_Table, like for the 'Bulk Actions' option.
+	 * When this is present, this ensures that this isn't filtered.
+	 *
+	 * @var int
+	 */
+	const NO_FILTER_VALUE = -1;
+
+	/**
+	 * The ID for the link to the Errors by URL.
+	 *
+	 * @var string
+	 */
+	const ID_LINK_ERRORS_BY_URL = 'link-errors-url';
+
 	/**
 	 * Validation code for an invalid element.
 	 *
@@ -75,6 +99,43 @@ class AMP_Validation_Error_Taxonomy {
 	 */
 	const INVALID_ATTRIBUTE_CODE = 'invalid_attribute';
 
+	/**
+	 * The 'type' of error for invalid HTML elements, like <frame>.
+	 *
+	 * These usually have the 'code' of 'invalid_element'.
+	 * Except for 'invalid_element' errors for a <script>, which have the JS_ERROR_TYPE.
+	 * This allows filtering by type in the taxonomy page, like displaying only HTML element errors, or only CSS errors.
+	 *
+	 * @var string
+	 */
+	const HTML_ELEMENT_ERROR_TYPE = 'html_element_error';
+
+	/**
+	 * The 'type' of error for invalid HTML attributes.
+	 *
+	 * These usually have the 'code' of 'invalid_attribute'.
+	 * Banned attributes include i-amp-*.
+	 * But on* attributes, like onclick, have the JS_ERROR_TYPE.
+	 *
+	 * @var string
+	 */
+	const HTML_ATTRIBUTE_ERROR_TYPE = 'html_attribute_error';
+
+	/**
+	 * The 'type' of error that applies to the error 'code' of 'invalid_element' when the node is a <script>.
+	 * This applies both when enqueuing a script, and when a <script> is echoed directly.
+	 *
+	 * @var string
+	 */
+	const JS_ERROR_TYPE = 'js_error';
+
+	/**
+	 * The 'type' of all CSS errors, no matter what the 'code'.
+	 *
+	 * @var string
+	 */
+	const CSS_ERROR_TYPE = 'css_error';
+
 	/**
 	 * The key for removed elements.
 	 *
@@ -122,13 +183,13 @@ public static function register() {
 
 		register_taxonomy( self::TAXONOMY_SLUG, AMP_Invalid_URL_Post_Type::POST_TYPE_SLUG, array(
 			'labels'             => array(
-				'name'                  => _x( 'AMP Validation Errors', 'taxonomy general name', 'amp' ),
+				'name'                  => _x( 'Errors by Type', 'taxonomy general name', 'amp' ),
 				'singular_name'         => _x( 'AMP Validation Error', 'taxonomy singular name', 'amp' ),
 				'search_items'          => __( 'Search AMP Validation Errors', 'amp' ),
 				'all_items'             => __( 'All AMP Validation Errors', 'amp' ),
 				'edit_item'             => __( 'Edit AMP Validation Error', 'amp' ),
 				'update_item'           => __( 'Update AMP Validation Error', 'amp' ),
-				'menu_name'             => __( 'Validation Errors', 'amp' ),
+				'menu_name'             => __( 'Errors by Type', 'amp' ),
 				'back_to_items'         => __( 'Back to AMP Validation Errors', 'amp' ),
 				'popular_items'         => __( 'Frequent Validation Errors', 'amp' ),
 				'view_item'             => __( 'View Validation Error', 'amp' ),
@@ -372,9 +433,10 @@ public static function get_validation_error_count( $args = array() ) {
 	}
 
 	/**
-	 * Add support for querying posts by amp_validation_error_status.
+	 * Add support for querying posts by amp_validation_error_status and by error type.
 	 *
 	 * Add recognition of amp_validation_error_status query var for amp_invalid_url post queries.
+	 * Also, conditionally filter for error type, like js_error or css_error.
 	 *
 	 * @see WP_Tax_Query::get_sql_for_clause()
 	 *
@@ -384,29 +446,59 @@ public static function get_validation_error_count( $args = array() ) {
 	 */
 	public static function filter_posts_where_for_validation_error_status( $where, WP_Query $query ) {
 		global $wpdb;
-		if (
-			in_array( AMP_Invalid_URL_Post_Type::POST_TYPE_SLUG, (array) $query->get( 'post_type' ), true )
-			&&
-			is_numeric( $query->get( self::VALIDATION_ERROR_STATUS_QUERY_VAR ) )
-		) {
-			$where .= $wpdb->prepare(
-				" AND (
-					SELECT 1
-					FROM $wpdb->term_relationships
-					INNER JOIN $wpdb->term_taxonomy ON $wpdb->term_taxonomy.term_taxonomy_id = $wpdb->term_relationships.term_taxonomy_id
-					INNER JOIN $wpdb->terms ON $wpdb->terms.term_id = $wpdb->term_taxonomy.term_id
-					WHERE
-						$wpdb->term_taxonomy.taxonomy = %s
-						AND
-						$wpdb->term_relationships.object_id = $wpdb->posts.ID
-						AND
-						$wpdb->terms.term_group = %d
-					LIMIT 1
-				)",
-				self::TAXONOMY_SLUG,
-				$query->get( self::VALIDATION_ERROR_STATUS_QUERY_VAR )
+
+		// If the post type is not correct, return the $where clause unchanged.
+		if ( ! in_array( AMP_Invalid_URL_Post_Type::POST_TYPE_SLUG, (array) $query->get( 'post_type' ), true ) ) {
+			return $where;
+		}
+
+		$error_status = sanitize_key( $query->get( self::VALIDATION_ERROR_STATUS_QUERY_VAR ) );
+		$error_type   = sanitize_key( $query->get( self::VALIDATION_ERROR_TYPE_QUERY_VAR ) );
+
+		/*
+		 * Selecting the 'All Statuses' <option> sends a value of '-1' to indicate that this should not filter.
+		 * So ensure that the value is_numeric(), and is not '-1'.
+		 */
+		$is_error_status_present = is_numeric( $error_status ) && self::NO_FILTER_VALUE !== intval( $error_status );
+		$is_error_type_present   = in_array( $error_type, self::get_error_types(), true );
+
+		// If neither the error status nor the type is present, there is no need to filter the $where clause.
+		if ( ! $is_error_status_present && ! $is_error_type_present ) {
+			return $where;
+		}
+
+		$sql_select = $wpdb->prepare(
+			"
+				SELECT 1
+				FROM $wpdb->term_relationships
+				INNER JOIN $wpdb->term_taxonomy ON $wpdb->term_taxonomy.term_taxonomy_id = $wpdb->term_relationships.term_taxonomy_id
+				INNER JOIN $wpdb->terms ON $wpdb->terms.term_id = $wpdb->term_taxonomy.term_id
+				WHERE
+					$wpdb->term_taxonomy.taxonomy = %s
+					AND
+					$wpdb->term_relationships.object_id = $wpdb->posts.ID
+			",
+			self::TAXONOMY_SLUG
+		);
+
+		if ( $is_error_status_present ) {
+			$sql_select .= $wpdb->prepare(
+				" AND $wpdb->terms.term_group = %s ",
+				$error_status
+			);
+		}
+
+		if ( $is_error_type_present ) {
+			$sql_select .= $wpdb->prepare(
+				" AND $wpdb->term_taxonomy.description LIKE %s ",
+				'%"type":"' . $wpdb->esc_like( $error_type ) . '"%'
 			);
 		}
+
+		$sql_select .= ' LIMIT 1 ';
+
+		$where .= " AND ( $sql_select ) ";
+
 		return $where;
 	}
 
@@ -465,7 +557,11 @@ public static function summarize_validation_errors( $validation_errors ) {
 	 * Add admin hooks.
 	 */
 	public static function add_admin_hooks() {
+		add_filter( 'redirect_term_location', array( __CLASS__, 'add_term_filter_query_var' ), 10, 2 );
 		add_action( 'load-edit-tags.php', array( __CLASS__, 'add_group_terms_clauses_filter' ) );
+		add_action( 'load-edit-tags.php', array( __CLASS__, 'add_error_type_clauses_filter' ) );
+		add_action( sprintf( 'after-%s-table', self::TAXONOMY_SLUG ), array( __CLASS__, 'render_taxonomy_filters' ) );
+		add_action( sprintf( 'after-%s-table', self::TAXONOMY_SLUG ), array( __CLASS__, 'render_link_to_errors_by_url' ) );
 		add_action( 'load-edit-tags.php', function() {
 			add_filter( 'user_has_cap', array( __CLASS__, 'filter_user_has_cap_for_hiding_term_list_table_checkbox' ), 10, 3 );
 		} );
@@ -476,7 +572,6 @@ public static function add_admin_hooks() {
 			add_action( 'admin_menu', array( __CLASS__, 'add_admin_menu_validation_error_item' ) );
 		}
 		add_filter( 'manage_' . self::TAXONOMY_SLUG . '_custom_column', array( __CLASS__, 'filter_manage_custom_columns' ), 10, 3 );
-		add_filter( 'views_edit-' . self::TAXONOMY_SLUG, array( __CLASS__, 'filter_views_edit' ) );
 		add_filter( 'posts_where', array( __CLASS__, 'filter_posts_where_for_validation_error_status' ), 10, 2 );
 		add_filter( 'handle_bulk_actions-edit-' . self::TAXONOMY_SLUG, array( __CLASS__, 'handle_validation_error_update' ), 10, 3 );
 		add_action( 'load-edit-tags.php', array( __CLASS__, 'handle_inline_edit_request' ) );
@@ -489,9 +584,10 @@ public static function add_admin_hooks() {
 			return $query_vars;
 		} );
 
-		// Add recognition of amp_validation_error_status query var (which will only apply in admin since post type is not publicly_queryable).
+		// Add recognition of amp_validation_error_status and type query vars (which will only apply in admin since post type is not publicly_queryable).
 		add_filter( 'query_vars', function( $query_vars ) {
 			$query_vars[] = AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_STATUS_QUERY_VAR;
+			$query_vars[] = AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_TYPE_QUERY_VAR;
 			return $query_vars;
 		} );
 
@@ -570,6 +666,70 @@ public static function add_admin_hooks() {
 		} );
 	}
 
+	/**
+	 * Filter the term redirect URL, to possibly add query vars to filter by term status or type.
+	 *
+	 * On clicking the 'Filter' button on the 'AMP Validation Errors' taxonomy page,
+	 * edit-tags.php processes the POST request that this submits.
+	 * Then, it redirects to a URL to display the page again.
+	 * This filter callback looks for a value for VALIDATION_ERROR_TYPE_QUERY_VAR in the $_POST request.
+	 * That means that the user filtered by error type, like 'js_error'.
+	 * It then passes that value to the redirect URL as a query var,
+	 * So that the taxonomy page will be filtered for that error type.
+	 *
+	 * @see AMP_Validation_Error_Taxonomy::add_error_type_clauses_filter() for the filtering of the 'where' clause, based on the query vars.
+	 * @param string      $url The $url to redirect to.
+	 * @param WP_Taxonomy $tax The WP_Taxonomy object.
+	 * @return string The filtered URL.
+	 */
+	public static function add_term_filter_query_var( $url, $tax ) {
+		if (
+			self::TAXONOMY_SLUG !== $tax->name
+			||
+			! isset( $_POST['post_type'] ) // WPCS: CSRF OK.
+			||
+			AMP_Invalid_URL_Post_Type::POST_TYPE_SLUG !== $_POST['post_type'] // WPCS: CSRF OK.
+		) {
+			return $url;
+		}
+
+		// If the error type query var is valid, pass it along in the redirect $url.
+		if (
+			isset( $_POST[ self::VALIDATION_ERROR_TYPE_QUERY_VAR ] ) // WPCS: CSRF OK.
+			&&
+			in_array(
+				$_POST[ self::VALIDATION_ERROR_TYPE_QUERY_VAR ], // WPCS: CSRF OK.
+				array_merge( self::get_error_types(), array( strval( self::NO_FILTER_VALUE ) ) ),
+				true
+			)
+		) {
+			$url = add_query_arg(
+				self::VALIDATION_ERROR_TYPE_QUERY_VAR,
+				sanitize_key( wp_unslash( $_POST[ self::VALIDATION_ERROR_TYPE_QUERY_VAR ] ) ), // WPCS: CSRF OK.
+				$url
+			);
+		}
+
+		// If the error status query var is valid, pass it along in the redirect $url.
+		if (
+			isset( $_POST[ self::VALIDATION_ERROR_STATUS_QUERY_VAR ] ) // WPCS: CSRF OK.
+			&&
+			in_array(
+				intval( $_POST[ self::VALIDATION_ERROR_STATUS_QUERY_VAR ] ), // WPCS: CSRF OK.
+				array( self::VALIDATION_ERROR_NEW_STATUS, self::VALIDATION_ERROR_ACCEPTED_STATUS, self::VALIDATION_ERROR_REJECTED_STATUS, self::NO_FILTER_VALUE ),
+				true
+			)
+		) {
+			$url = add_query_arg(
+				self::VALIDATION_ERROR_STATUS_QUERY_VAR,
+				intval( $_POST[ self::VALIDATION_ERROR_STATUS_QUERY_VAR ] ), // WPCS: CSRF OK.
+				$url
+			);
+		}
+
+		return $url;
+	}
+
 	/**
 	 * Filter amp_validation_error term query by term group when requested.
 	 */
@@ -591,6 +751,296 @@ public static function add_group_terms_clauses_filter() {
 		}, 10, 2 );
 	}
 
+	/**
+	 * Adds filter for amp_validation_error term query by type, like in the 'AMP Validation Errors' taxonomy page.
+	 * Allows viewing only a certain type at a time, like only JS errors.
+	 */
+	public static function add_error_type_clauses_filter() {
+		if ( self::TAXONOMY_SLUG !== get_current_screen()->taxonomy || ! isset( $_GET[ self::VALIDATION_ERROR_TYPE_QUERY_VAR ] ) ) { // WPCS: CSRF ok.
+			return;
+		}
+
+		$type = sanitize_key( wp_unslash( $_GET[ self::VALIDATION_ERROR_TYPE_QUERY_VAR ] ) ); // WPCS: CSRF ok.
+		if ( ! in_array( $type, self::get_error_types(), true ) ) {
+			return;
+		}
+		add_filter( 'terms_clauses', function( $clauses, $taxonomies ) use ( $type ) {
+			global $wpdb;
+			if ( AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG === $taxonomies[0] ) {
+				$clauses['where'] .= $wpdb->prepare( ' AND tt.description LIKE %s', '%"type":"' . $wpdb->esc_like( $type ) . '"%' );
+			}
+			return $clauses;
+		}, 10, 2 );
+	}
+
+	/**
+	 * Outputs the taxonomy filter UI for this taxonomy type.
+	 *
+	 * Similar to what appears on /wp-admin/edit.php for posts and pages,
+	 * this outputs <select> elements to choose the error status and type,
+	 * and a 'Filter' submit button that filters for them.
+	 *
+	 * @param string $taxonomy_name The name of the taxonomy.
+	 */
+	public static function render_taxonomy_filters( $taxonomy_name ) {
+		if ( self::TAXONOMY_SLUG !== $taxonomy_name ) {
+			return;
+		}
+
+		$div_id = 'amp-tax-filter';
+		?>
+		<div id="<?php echo esc_attr( $div_id ); ?>" class="alignleft actions">
+			<?php
+			self::render_error_status_filter();
+			self::render_error_type_filter();
+			?>
+			<input name="filter_action" type="submit" id="doaction" class="button action" value="<?php esc_html_e( 'Apply Filter', 'amp' ); ?>">
+		</div>
+
+		<script>
+			( function ( $ ) {
+				$( function() {
+					// Move the filter UI after the 'Bulk Actions' <select>, as it looks like there's no way to do this with only an action.
+					$( '#<?php echo $div_id; // WPCS: XSS OK. ?>' ).insertAfter( $( '.tablenav.top .bulkactions' ) );
+
+					// Move the link to 'View errors by URL' to after the heading, as it also looks like there's no action for this.
+					$( '#<?php echo self::ID_LINK_ERRORS_BY_URL; // WPCS: XSS OK. ?>' ).insertAfter( $( '.wp-heading-inline' ) );
+				} );
+			} )( jQuery );
+		</script>
+		<?php
+	}
+
+	/**
+	 * On the 'Errors by Type' taxonomy page, renders a link to the 'Errors by URL' page.
+	 *
+	 * @param string $taxonomy_name The name of the taxonomy.
+	 */
+	public static function render_link_to_errors_by_url( $taxonomy_name ) {
+		if ( self::TAXONOMY_SLUG !== $taxonomy_name ) {
+			return;
+		}
+
+		printf(
+			'<a href="%s" class="page-title-action" id="%s" style="margin-left: 1rem;">%s</a>',
+			esc_attr( add_query_arg(
+				'post_type',
+				AMP_Invalid_URL_Post_Type::POST_TYPE_SLUG,
+				admin_url( 'edit.php' )
+			) ),
+			esc_attr( self::ID_LINK_ERRORS_BY_URL ),
+			esc_html__( 'View errors by URL', 'amp' )
+		);
+	}
+
+	/**
+	 * Renders the error status filter <select> element.
+	 *
+	 * There is a difference how the errors are counted, depending on which screen this is on.
+	 * For example: Accepted Errors (10).
+	 * This status filter <select> element is rendered on the validation error post page (Errors by URL),
+	 * and the validation error taxonomy page (Errors by Type).
+	 * On the taxonomy page, this simply needs to count the number of terms with a given type.
+	 * On the post page, this needs to count the number of posts that have at least one error of a given type.
+	 */
+	public static function render_error_status_filter() {
+		global $wp_query;
+		$screen_base = get_current_screen()->base;
+
+		if ( 'edit-tags' === $screen_base ) {
+			$total_term_count    = self::get_validation_error_count();
+			$rejected_term_count = self::get_validation_error_count( array( 'group' => self::VALIDATION_ERROR_REJECTED_STATUS ) );
+			$accepted_term_count = self::get_validation_error_count( array( 'group' => self::VALIDATION_ERROR_ACCEPTED_STATUS ) );
+			$new_term_count      = $total_term_count - $rejected_term_count - $accepted_term_count;
+
+		} elseif ( 'edit' === $screen_base ) {
+			$args = array(
+				'post_type'              => AMP_Invalid_URL_Post_Type::POST_TYPE_SLUG,
+				'update_post_meta_cache' => false,
+				'update_post_term_cache' => false,
+			);
+
+			$error_type = sanitize_key( $wp_query->get( self::VALIDATION_ERROR_TYPE_QUERY_VAR ) );
+			if ( $error_type && in_array( $error_type, self::get_error_types(), true ) ) {
+				$args[ self::VALIDATION_ERROR_TYPE_QUERY_VAR ] = $error_type;
+			}
+
+			$with_new_query = new WP_Query( array_merge(
+				$args,
+				array( self::VALIDATION_ERROR_STATUS_QUERY_VAR => self::VALIDATION_ERROR_NEW_STATUS )
+			) );
+			$new_term_count = $with_new_query->found_posts;
+
+			$with_rejected_query = new WP_Query( array_merge(
+				$args,
+				array( self::VALIDATION_ERROR_STATUS_QUERY_VAR => self::VALIDATION_ERROR_REJECTED_STATUS )
+			) );
+			$rejected_term_count = $with_rejected_query->found_posts;
+
+			$with_accepted_query = new WP_Query( array_merge(
+				$args,
+				array( self::VALIDATION_ERROR_STATUS_QUERY_VAR => self::VALIDATION_ERROR_ACCEPTED_STATUS )
+			) );
+			$accepted_term_count = $with_accepted_query->found_posts;
+		} else {
+			return;
+		}
+
+		$error_status_filter_value = isset( $_GET[ self::VALIDATION_ERROR_STATUS_QUERY_VAR ] ) ? intval( $_GET[ self::VALIDATION_ERROR_STATUS_QUERY_VAR ] ) : ''; // WPCS: CSRF OK.
+
+		?>
+		<label for="<?php echo esc_attr( self::VALIDATION_ERROR_STATUS_QUERY_VAR ); ?>" class="screen-reader-text"><?php esc_html_e( 'Filter by error status', 'amp' ); ?></label>
+		<select name="<?php echo esc_attr( self::VALIDATION_ERROR_STATUS_QUERY_VAR ); ?>" id="<?php echo esc_attr( self::VALIDATION_ERROR_STATUS_QUERY_VAR ); ?>">
+			<option value="<?php echo esc_attr( self::NO_FILTER_VALUE ); ?>"><?php esc_html_e( 'All Statuses', 'amp' ); ?></option>
+			<?php
+			if ( 'edit' === $screen_base ) {
+				$new_term_text = sprintf(
+					/* translators: %s: the new term count. */
+					_nx(
+						'With New Error <span class="count">(%s)</span>',
+						'With New Errors <span class="count">(%s)</span>',
+						$new_term_count,
+						'terms',
+						'amp'
+					),
+					number_format_i18n( $new_term_count )
+				);
+			} else {
+				$new_term_text = sprintf(
+					/* translators: %s: the new term count. */
+					_nx(
+						'New Error <span class="count">(%s)</span>',
+						'New Errors <span class="count">(%s)</span>',
+						$new_term_count,
+						'terms',
+						'amp'
+					),
+					number_format_i18n( $new_term_count )
+				);
+			}
+			?>
+			<option value="<?php echo esc_attr( self::VALIDATION_ERROR_NEW_STATUS ); ?>" <?php selected( $error_status_filter_value, self::VALIDATION_ERROR_NEW_STATUS ); ?>><?php echo wp_kses_post( $new_term_text ); ?></option>
+			<?php
+			if ( 'edit' === $screen_base ) {
+				$accepted_term_text = sprintf(
+					/* translators: %s: the accepted term count. */
+					_nx(
+						'With Accepted Error <span class="count">(%s)</span>',
+						'With Accepted Errors <span class="count">(%s)</span>',
+						$accepted_term_count,
+						'terms',
+						'amp'
+					),
+					number_format_i18n( $accepted_term_count )
+				);
+			} else {
+				$accepted_term_text = sprintf(
+					/* translators: %s: the accepted term count. */
+					_nx(
+						'Accepted Error <span class="count">(%s)</span>',
+						'Accepted Errors <span class="count">(%s)</span>',
+						$accepted_term_count,
+						'terms',
+						'amp'
+					),
+					number_format_i18n( $accepted_term_count )
+				);
+			}
+			?>
+			<option value="<?php echo esc_attr( self::VALIDATION_ERROR_ACCEPTED_STATUS ); ?>" <?php selected( $error_status_filter_value, self::VALIDATION_ERROR_ACCEPTED_STATUS ); ?>><?php echo wp_kses_post( $accepted_term_text ); ?></option>
+			<?php
+			if ( 'edit' === $screen_base ) {
+				$rejected_term_text = sprintf(
+					/* translators: %s: the rejected term count. */
+					_nx(
+						'With Rejected Error <span class="count">(%s)</span>',
+						'With Rejected Errors <span class="count">(%s)</span>',
+						$rejected_term_count,
+						'terms',
+						'amp'
+					),
+					number_format_i18n( $rejected_term_count )
+				);
+			} else {
+				$rejected_term_text = sprintf(
+					/* translators: %s: the rejected term count. */
+					_nx(
+						'Rejected Error <span class="count">(%s)</span>',
+						'Rejected Errors <span class="count">(%s)</span>',
+						$rejected_term_count,
+						'terms',
+						'amp'
+					),
+					number_format_i18n( $rejected_term_count )
+				);
+			}
+			?>
+			<option value="<?php echo esc_attr( self::VALIDATION_ERROR_REJECTED_STATUS ); ?>" <?php selected( $error_status_filter_value, self::VALIDATION_ERROR_REJECTED_STATUS ); ?>><?php echo wp_kses_post( $rejected_term_text ); ?></option>
+		</select>
+		<?php
+	}
+
+	/**
+	 * Gets all of the possible error types.
+	 *
+	 * @return array Error types.
+	 */
+	public static function get_error_types() {
+		return array( self::HTML_ELEMENT_ERROR_TYPE, self::HTML_ATTRIBUTE_ERROR_TYPE, self::JS_ERROR_TYPE, self::CSS_ERROR_TYPE );
+	}
+
+	/**
+	 * Renders the filter for error type.
+	 *
+	 * This type filter <select> element is rendered on the validation error post page (Errors by URL),
+	 * and the validation error taxonomy page (Errors by Type).
+	 */
+	public static function render_error_type_filter() {
+		$error_type_filter_value = isset( $_GET[ self::VALIDATION_ERROR_TYPE_QUERY_VAR ] ) ? sanitize_key( wp_unslash( $_GET[ self::VALIDATION_ERROR_TYPE_QUERY_VAR ] ) ) : ''; // WPCS: CSRF OK.
+
+		/*
+		 * On the 'Errors by URL' page, the <option> text should be different.
+		 * For example, it should be 'With JS Errors' instead of 'JS Errors'.
+		 */
+		$screen_base = get_current_screen()->base;
+		?>
+		<label for="<?php echo esc_attr( self::VALIDATION_ERROR_TYPE_QUERY_VAR ); ?>" class="screen-reader-text"><?php esc_html_e( 'Filter by error type', 'amp' ); ?></label>
+		<select name="<?php echo esc_attr( self::VALIDATION_ERROR_TYPE_QUERY_VAR ); ?>" id="<?php echo esc_attr( self::VALIDATION_ERROR_TYPE_QUERY_VAR ); ?>">
+			<option value="<?php echo esc_attr( self::NO_FILTER_VALUE ); ?>">
+				<?php esc_html_e( 'All Error Types', 'amp' ); ?>
+			</option>
+			<option value="<?php echo esc_attr( self::HTML_ELEMENT_ERROR_TYPE ); ?>" <?php selected( $error_type_filter_value, self::HTML_ELEMENT_ERROR_TYPE ); ?>>
+				<?php if ( 'edit' === $screen_base ) : ?>
+					<?php esc_html_e( 'With HTML (Element) Errors', 'amp' ); ?>
+				<?php else : ?>
+					<?php esc_html_e( 'HTML (Element) Errors', 'amp' ); ?>
+				<?php endif; ?>
+			</option>
+			<option value="<?php echo esc_attr( self::HTML_ATTRIBUTE_ERROR_TYPE ); ?>" <?php selected( $error_type_filter_value, self::HTML_ATTRIBUTE_ERROR_TYPE ); ?>>
+				<?php if ( 'edit' === $screen_base ) : ?>
+					<?php esc_html_e( 'With HTML (Attribute) Errors', 'amp' ); ?>
+				<?php else : ?>
+					<?php esc_html_e( 'HTML (Attribute) Errors', 'amp' ); ?>
+				<?php endif; ?>
+			</option>
+			<option value="<?php echo esc_attr( self::JS_ERROR_TYPE ); ?>" <?php selected( $error_type_filter_value, self::JS_ERROR_TYPE ); ?>>
+				<?php if ( 'edit' === $screen_base ) : ?>
+					<?php esc_html_e( 'With JS Errors', 'amp' ); ?>
+				<?php else : ?>
+					<?php esc_html_e( 'JS Errors', 'amp' ); ?>
+				<?php endif; ?>
+			</option>
+			<option value="<?php echo esc_attr( self::CSS_ERROR_TYPE ); ?>" <?php selected( $error_type_filter_value, self::CSS_ERROR_TYPE ); ?>>
+				<?php if ( 'edit' === $screen_base ) : ?>
+					<?php esc_html_e( 'With CSS Errors', 'amp' ); ?>
+				<?php else : ?>
+					<?php esc_html_e( 'CSS Errors', 'amp' ); ?>
+				<?php endif; ?>
+			</option>
+		</select>
+		<?php
+	}
+
 	/**
 	 * Prevent user from being able to delete validation errors in order to disable the checkbox on the post list table.
 	 *
@@ -724,7 +1174,7 @@ public static function filter_tag_row_actions( $actions, WP_Term $tag ) {
 	 * Show AMP validation errors under AMP admin menu.
 	 */
 	public static function add_admin_menu_validation_error_item() {
-		$menu_item_label = esc_html__( 'Validation Errors', 'amp' );
+		$menu_item_label = esc_html__( 'Errors by Type', 'amp' );
 		$new_error_count = self::get_validation_error_count( array(
 			'group' => self::VALIDATION_ERROR_NEW_STATUS,
 		) );
@@ -735,7 +1185,7 @@ public static function add_admin_menu_validation_error_item() {
 		$taxonomy_caps = (object) get_taxonomy( self::TAXONOMY_SLUG )->cap; // Yes, cap is an object not an array.
 		add_submenu_page(
 			AMP_Options_Manager::OPTION_NAME,
-			esc_html__( 'Validation Errors', 'amp' ),
+			$menu_item_label,
 			$menu_item_label,
 			$taxonomy_caps->manage_terms,
 			// The following esc_attr() is sadly needed due to <https://github.com/WordPress/wordpress-develop/blob/4.9.5/src/wp-admin/menu-header.php#L201>.
@@ -743,122 +1193,6 @@ public static function add_admin_menu_validation_error_item() {
 		);
 	}
 
-	/**
-	 * Add views for filtering validation errors by status.
-	 *
-	 * @param array $views Views.
-	 * @return array Views.
-	 */
-	public static function filter_views_edit( $views ) {
-		$total_term_count    = self::get_validation_error_count();
-		$rejected_term_count = self::get_validation_error_count( array( 'group' => self::VALIDATION_ERROR_REJECTED_STATUS ) );
-		$accepted_term_count = self::get_validation_error_count( array( 'group' => self::VALIDATION_ERROR_ACCEPTED_STATUS ) );
-		$new_term_count      = $total_term_count - $rejected_term_count - $accepted_term_count;
-
-		$current_url = remove_query_arg(
-			array_merge(
-				wp_removable_query_args(),
-				array( 's' ) // For some reason behavior of posts list table is to not persist the search query.
-			),
-			wp_unslash( $_SERVER['REQUEST_URI'] )
-		);
-
-		$current_status = null;
-		if ( isset( $_GET[ self::VALIDATION_ERROR_STATUS_QUERY_VAR ] ) ) { // WPCS: CSRF ok.
-			$value = intval( $_GET[ self::VALIDATION_ERROR_STATUS_QUERY_VAR ] ); // WPCS: CSRF ok.
-			if ( in_array( $value, array( self::VALIDATION_ERROR_NEW_STATUS, self::VALIDATION_ERROR_ACCEPTED_STATUS, self::VALIDATION_ERROR_REJECTED_STATUS ), true ) ) {
-				$current_status = $value;
-			}
-		}
-
-		$views['all'] = sprintf(
-			'<a href="%s" class="%s">%s</a>',
-			esc_url( remove_query_arg( self::VALIDATION_ERROR_STATUS_QUERY_VAR, $current_url ) ),
-			null === $current_status ? 'current' : '',
-			sprintf(
-				/* translators: %s: the term count. */
-				_nx(
-					'All <span class="count">(%s)</span>',
-					'All <span class="count">(%s)</span>',
-					$total_term_count,
-					'terms',
-					'amp'
-				),
-				number_format_i18n( $total_term_count )
-			)
-		);
-
-		$views['new'] = sprintf(
-			'<a href="%s" class="%s">%s</a>',
-			esc_url(
-				add_query_arg(
-					self::VALIDATION_ERROR_STATUS_QUERY_VAR,
-					self::VALIDATION_ERROR_NEW_STATUS,
-					$current_url
-				)
-			),
-			self::VALIDATION_ERROR_NEW_STATUS === $current_status ? 'current' : '',
-			sprintf(
-				/* translators: %s: the term count. */
-				_nx(
-					'New <span class="count">(%s)</span>',
-					'New <span class="count">(%s)</span>',
-					$new_term_count,
-					'terms',
-					'amp'
-				),
-				number_format_i18n( $new_term_count )
-			)
-		);
-
-		$views['rejected'] = sprintf(
-			'<a href="%s" class="%s">%s</a>',
-			esc_url(
-				add_query_arg(
-					self::VALIDATION_ERROR_STATUS_QUERY_VAR,
-					self::VALIDATION_ERROR_REJECTED_STATUS,
-					$current_url
-				)
-			),
-			self::VALIDATION_ERROR_REJECTED_STATUS === $current_status ? 'current' : '',
-			sprintf(
-				/* translators: %s: the term count. */
-				_nx(
-					'Rejected <span class="count">(%s)</span>',
-					'Rejected <span class="count">(%s)</span>',
-					$rejected_term_count,
-					'terms',
-					'amp'
-				),
-				number_format_i18n( $rejected_term_count )
-			)
-		);
-
-		$views['accepted'] = sprintf(
-			'<a href="%s" class="%s">%s</a>',
-			esc_url(
-				add_query_arg(
-					self::VALIDATION_ERROR_STATUS_QUERY_VAR,
-					self::VALIDATION_ERROR_ACCEPTED_STATUS,
-					$current_url
-				)
-			),
-			self::VALIDATION_ERROR_ACCEPTED_STATUS === $current_status ? 'current' : '',
-			sprintf(
-				/* translators: %s: the term count. */
-				_nx(
-					'Accepted <span class="count">(%s)</span>',
-					'Accepted <span class="count">(%s)</span>',
-					$accepted_term_count,
-					'terms',
-					'amp'
-				),
-				number_format_i18n( $accepted_term_count )
-			)
-		);
-		return $views;
-	}
-
 	/**
 	 * Supply the content for the custom columns.
 	 *
diff --git a/tests/test-class-amp-base-sanitizer.php b/tests/test-class-amp-base-sanitizer.php
index b6afcc8ebc5..5f898b8aafd 100644
--- a/tests/test-class-amp-base-sanitizer.php
+++ b/tests/test-class-amp-base-sanitizer.php
@@ -221,6 +221,7 @@ public function test_remove_invalid_child() {
 			),
 			'foo'             => 'bar',
 			'sources'         => null,
+			'type'            => AMP_Validation_Error_Taxonomy::JS_ERROR_TYPE,
 		);
 
 		// Test sanitized.
@@ -250,6 +251,7 @@ public function test_remove_invalid_child() {
 		$expected_error['node_name'] = 'link';
 		unset( $expected_error['node_attributes']['src'] );
 		$expected_error['node_attributes']['href'] = 'http://example.com/bad.css?ver=__normalized__';
+		$expected_error['type']                    = AMP_Validation_Error_Taxonomy::HTML_ELEMENT_ERROR_TYPE;
 		add_filter( 'amp_validation_error_sanitized', '__return_false' );
 		AMP_Validation_Manager::reset_validation_results();
 		$parent->appendChild( $child );
@@ -294,6 +296,7 @@ public function test_remove_invalid_attribute() {
 								'id'     => 'bar',
 								'onload' => 'someFunc()',
 							),
+						'type'               => AMP_Validation_Error_Taxonomy::JS_ERROR_TYPE,
 					),
 					$error
 				);
@@ -320,6 +323,7 @@ public function test_remove_invalid_attribute() {
 								'id'     => 'bar',
 								'onload' => 'someFunc()',
 							),
+						'type'               => AMP_Validation_Error_Taxonomy::JS_ERROR_TYPE,
 					),
 					$error
 				);
diff --git a/tests/test-tag-and-attribute-sanitizer.php b/tests/test-tag-and-attribute-sanitizer.php
index 3eb250a3063..00dc35195f3 100644
--- a/tests/test-tag-and-attribute-sanitizer.php
+++ b/tests/test-tag-and-attribute-sanitizer.php
@@ -1114,7 +1114,8 @@ public function test_replace_node_with_children_validation_errors() {
 			$sanitizer = new AMP_Tag_And_Attribute_Sanitizer( $dom, array(
 				'validation_error_callback' => function( $error, $context ) use ( $that, $expected_errors, &$error_index ) {
 					$expected = $expected_errors[ $error_index ];
-					$tag      = $expected['node_name'];
+					$expected['type'] = AMP_Validation_Error_Taxonomy::HTML_ELEMENT_ERROR_TYPE;
+					$tag = $expected['node_name'];
 					$that->assertEquals( $expected, $error );
 					$that->assertInstanceOf( 'DOMElement', $context['node'] );
 					$that->assertEquals( $tag, $context['node']->tagName );
diff --git a/tests/validation/test-class-amp-invalid-url-post-type.php b/tests/validation/test-class-amp-invalid-url-post-type.php
index ea2196c2b4a..b7297fab178 100644
--- a/tests/validation/test-class-amp-invalid-url-post-type.php
+++ b/tests/validation/test-class-amp-invalid-url-post-type.php
@@ -86,8 +86,8 @@ public function test_add_admin_hooks() {
 		$this->assertEquals( 10, has_action( 'add_meta_boxes', array( self::TESTED_CLASS, 'add_meta_boxes' ) ) );
 		$this->assertEquals( 10, has_action( 'edit_form_top', array( self::TESTED_CLASS, 'print_url_as_title' ) ) );
 		$this->assertEquals( 10, has_filter( 'the_title', array( self::TESTED_CLASS, 'filter_the_title_in_post_list_table' ) ) );
+		$this->assertEquals( 10, has_filter( 'restrict_manage_posts', array( self::TESTED_CLASS, 'render_post_filters' ), 10, 2 ) );
 
-		$this->assertEquals( 10, has_filter( 'views_edit-' . AMP_Invalid_URL_Post_Type::POST_TYPE_SLUG, array( self::TESTED_CLASS, 'filter_views_edit' ) ) );
 		$this->assertEquals( 10, has_filter( 'manage_' . AMP_Invalid_URL_Post_Type::POST_TYPE_SLUG . '_posts_columns', array( self::TESTED_CLASS, 'add_post_columns' ) ) );
 		$this->assertEquals( 10, has_action( 'manage_posts_custom_column', array( self::TESTED_CLASS, 'output_custom_column' ) ) );
 		$this->assertEquals( 10, has_filter( 'post_row_actions', array( self::TESTED_CLASS, 'filter_row_actions' ) ) );
@@ -433,66 +433,6 @@ public function test_get_post_staleness() {
 		$this->assertEmpty( AMP_Invalid_URL_Post_Type::get_post_staleness( $invalid_url_post_id ) );
 	}
 
-	/**
-	 * Test filter_views_edit.
-	 *
-	 * @covers \AMP_Invalid_URL_Post_Type::filter_views_edit()
-	 */
-	public function test_filter_views_edit() {
-		$_SERVER['REQUEST_URI'] = '/wp-admin/edit.php?post_type=amp_invalid_url&amp_validation_error_status=0';
-
-		add_theme_support( 'amp', array( 'paired' => true ) );
-		AMP_Validation_Manager::init();
-		AMP_Validation_Error_Taxonomy::add_admin_hooks();
-		$post = $this->factory()->post->create();
-		$this->assertEmpty( AMP_Invalid_URL_Post_Type::get_invalid_url_validation_errors( get_permalink( $post ) ) );
-
-		add_filter( 'amp_validation_error_sanitized', function( $sanitized, $error ) {
-			if ( 'accepted' === $error['code'] ) {
-				$sanitized = true;
-			} elseif ( 'rejected' === $error['code'] ) {
-				$sanitized = false;
-			}
-			return $sanitized;
-		}, 10, 2 );
-
-		$errors = array(
-			array( 'code' => 'accepted' ),
-			array( 'code' => 'rejected' ),
-			array( 'code' => 'new' ),
-		);
-
-		$invalid_url_post_id = AMP_Invalid_URL_Post_Type::store_validation_errors(
-			$errors,
-			get_permalink( $post )
-		);
-		$this->assertNotInstanceOf( 'WP_Error', $invalid_url_post_id );
-
-		$views = AMP_Invalid_URL_Post_Type::filter_views_edit( array(
-			'publish' => 'Published',
-		) );
-
-		$this->assertArrayNotHasKey( 'publish', $views );
-		$this->assertContains( '(1)', $views['new'] );
-		$this->assertContains( '(1)', $views['rejected'] );
-		$this->assertContains( '(1)', $views['accepted'] );
-
-		$terms = get_terms( array( 'taxonomy' => AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG ) );
-		foreach ( $terms as $term ) {
-			wp_update_term( $term->term_id, AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG, array(
-				'term_group' => AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACCEPTED_STATUS,
-			) );
-		}
-
-		$views = AMP_Invalid_URL_Post_Type::filter_views_edit( array(
-			'publish' => 'Published',
-		) );
-		$this->assertArrayNotHasKey( 'publish', $views );
-		$this->assertContains( '(0)', $views['new'] );
-		$this->assertContains( '(0)', $views['rejected'] );
-		$this->assertContains( '(1)', $views['accepted'] );
-	}
-
 	/**
 	 * Test for add_post_columns()
 	 *
@@ -1135,6 +1075,55 @@ public function test_filter_the_title_in_post_list_table() {
 		$this->assertEquals( '/baz', AMP_Invalid_URL_Post_Type::filter_the_title_in_post_list_table( $title, $post_correct_post_type ) );
 	}
 
+	/**
+	 * Test render_post_filters.
+	 *
+	 * @covers \AMP_Validation_Error_Taxonomy::render_post_filters()
+	 */
+	public function test_render_post_filters() {
+		set_current_screen( 'edit.php' );
+		$number_of_errors = 20;
+		for ( $i = 0; $i < $number_of_errors; $i++ ) {
+			$invalid_url_post      = $this->factory()->post->create( array( 'post_type' => AMP_Invalid_URL_Post_Type::POST_TYPE_SLUG ) );
+			$validation_error_term = $this->factory()->term->create( array(
+				'taxonomy'    => AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG,
+				'description' => wp_json_encode( $this->get_mock_errors() ),
+				'term_group'  => AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_NEW_STATUS,
+			) );
+
+			// Associate the validation error term with a URL.
+			wp_set_post_terms(
+				$invalid_url_post,
+				$validation_error_term,
+				AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG
+			);
+		}
+
+		$new_error_count               = sprintf(
+			'New Errors <span class="count">(%d)</span>',
+			$number_of_errors
+		);
+		$correct_post_type             = AMP_Invalid_URL_Post_Type::POST_TYPE_SLUG;
+		$wrong_post_type               = 'page';
+		$correct_which_second_argument = 'top';
+		$wrong_which_second_argument   = 'bottom';
+
+		// This has an incorrect post type as the first argument, so it should not output anything.
+		ob_start();
+		AMP_Invalid_URL_Post_Type::render_post_filters( $wrong_post_type, $correct_which_second_argument );
+		$this->assertEmpty( ob_get_clean() );
+
+		// This has an incorrect second argument, so again it should not output anything.
+		ob_start();
+		AMP_Invalid_URL_Post_Type::render_post_filters( $correct_post_type, $wrong_which_second_argument );
+		$this->assertEmpty( ob_get_clean() );
+
+		// This is now on the invalid URL post type edit.php screen, so it should output a <select> element.
+		ob_start();
+		AMP_Invalid_URL_Post_Type::render_post_filters( $correct_post_type, $correct_which_second_argument );
+		$this->assertContains( $new_error_count, ob_get_clean() );
+	}
+
 	/**
 	 * Test for get_recheck_url()
 	 *
diff --git a/tests/validation/test-class-amp-validation-error-taxonomy.php b/tests/validation/test-class-amp-validation-error-taxonomy.php
index d18d0618f4d..775240046dd 100644
--- a/tests/validation/test-class-amp-validation-error-taxonomy.php
+++ b/tests/validation/test-class-amp-validation-error-taxonomy.php
@@ -56,18 +56,18 @@ public function test_register() {
 		$this->assertFalse( $taxonomy_object->hierarchical );
 		$this->assertTrue( $taxonomy_object->show_in_menu );
 		$this->assertFalse( $taxonomy_object->meta_box_cb );
-		$this->assertEquals( 'AMP Validation Errors', $taxonomy_object->label );
+		$this->assertEquals( 'Errors by Type', $taxonomy_object->label );
 		$this->assertEquals( 'do_not_allow', $taxonomy_object->cap->assign_terms );
 		$this->assertEquals( array( AMP_Invalid_URL_Post_Type::POST_TYPE_SLUG ), $taxonomy_object->object_type );
 
 		$labels = $taxonomy_object->labels;
-		$this->assertEquals( 'AMP Validation Errors', $labels->name );
+		$this->assertEquals( 'Errors by Type', $labels->name );
 		$this->assertEquals( 'AMP Validation Error', $labels->singular_name );
 		$this->assertEquals( 'Search AMP Validation Errors', $labels->search_items );
 		$this->assertEquals( 'All AMP Validation Errors', $labels->all_items );
 		$this->assertEquals( 'Edit AMP Validation Error', $labels->edit_item );
 		$this->assertEquals( 'Update AMP Validation Error', $labels->update_item );
-		$this->assertEquals( 'Validation Errors', $labels->menu_name );
+		$this->assertEquals( 'Errors by Type', $labels->menu_name );
 		$this->assertEquals( 'Back to AMP Validation Errors', $labels->back_to_items );
 		$this->assertEquals( 'Frequent Validation Errors', $labels->popular_items );
 		$this->assertEquals( 'View Validation Error', $labels->view_item );
@@ -276,12 +276,23 @@ public function test_filter_posts_where_for_validation_error_status() {
 		$this->assertEquals( $initial_where, AMP_Validation_Error_Taxonomy::filter_posts_where_for_validation_error_status( $initial_where, $wp_query ) );
 
 		// The entire conditional should now be true, so this should filter the WHERE clause.
-		$wp_query->set( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_STATUS_QUERY_VAR, 1 );
+		$error_status = 1;
+		$wp_query->set( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_STATUS_QUERY_VAR, $error_status );
 		$filtered_where = AMP_Validation_Error_Taxonomy::filter_posts_where_for_validation_error_status( $initial_where, $wp_query );
 		$this->assertContains( 'SELECT 1', $filtered_where );
 		$this->assertContains( 'INNER JOIN', $filtered_where );
 		$this->assertContains( $wpdb->term_relationships, $filtered_where );
 		$this->assertContains( $wpdb->term_taxonomy, $filtered_where );
+		$this->assertContains( strval( $error_status ), $filtered_where );
+
+		// Now that there is a query var for error type, that should also appear in the filtered WHERE clause.
+		$error_type         = 'js_error';
+		$escaped_error_type = 'js\\\\_error';
+		$wp_query->set( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_TYPE_QUERY_VAR, $error_type );
+		$filtered_where = AMP_Validation_Error_Taxonomy::filter_posts_where_for_validation_error_status( $initial_where, $wp_query );
+		$this->assertContains( 'SELECT 1', $filtered_where );
+		$this->assertContains( strval( $error_status ), $filtered_where );
+		$this->assertContains( $escaped_error_type, $filtered_where );
 	}
 
 	/**
@@ -345,17 +356,26 @@ public function test_add_admin_hooks() {
 		AMP_Validation_Error_Taxonomy::add_admin_hooks();
 		do_action( 'load-edit-tags.php' ); // phpcs:ignore WordPress.NamingConventions.ValidHookName.UseUnderscores
 
+		$this->assertEquals( 10, has_action( 'redirect_term_location', array( self::TESTED_CLASS, 'add_term_filter_query_var' ) ) );
 		$this->assertEquals( 10, has_action( 'load-edit-tags.php', array( self::TESTED_CLASS, 'add_group_terms_clauses_filter' ) ) );
+		$this->assertEquals( 10, has_action( 'load-edit-tags.php', array( self::TESTED_CLASS, 'add_error_type_clauses_filter' ) ) );
+		$this->assertEquals( 10, has_action( sprintf( 'after-%s-table', AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG, array( self::TESTED_CLASS, 'render_taxonomy_filters' ) ) ) );
+		$this->assertEquals( 10, has_action( sprintf( 'after-%s-table', AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG, array( self::TESTED_CLASS, 'render_link_to_errors_by_url' ) ) ) );
 		$this->assertEquals( 10, has_filter( 'user_has_cap', array( self::TESTED_CLASS, 'filter_user_has_cap_for_hiding_term_list_table_checkbox' ) ) );
 		$this->assertEquals( 10, has_filter( 'terms_clauses', array( self::TESTED_CLASS, 'filter_terms_clauses_for_description_search' ) ) );
 		$this->assertEquals( 10, has_action( 'admin_notices', array( self::TESTED_CLASS, 'add_admin_notices' ) ) );
 		$this->assertEquals( 10, has_filter( 'tag_row_actions', array( self::TESTED_CLASS, 'filter_tag_row_actions' ) ) );
 		$this->assertEquals( 10, has_action( 'admin_menu', array( self::TESTED_CLASS, 'add_admin_menu_validation_error_item' ) ) );
 		$this->assertEquals( 10, has_filter( 'manage_' . AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG . '_custom_column', array( self::TESTED_CLASS, 'filter_manage_custom_columns' ) ) );
-		$this->assertEquals( 10, has_filter( 'views_edit-' . AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG, array( self::TESTED_CLASS, 'filter_views_edit' ) ) );
 		$this->assertEquals( 10, has_filter( 'posts_where', array( self::TESTED_CLASS, 'filter_posts_where_for_validation_error_status' ) ) );
 		$this->assertEquals( 10, has_filter( 'handle_bulk_actions-edit-' . AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG, array( self::TESTED_CLASS, 'handle_validation_error_update' ) ) );
 		$this->assertEquals( 10, has_action( 'load-edit-tags.php', array( self::TESTED_CLASS, 'handle_inline_edit_request' ) ) );
+
+		// Assert that the 'query_vars' callback adds these query vars.
+		$this->assertEmpty( array_diff(
+			array( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_STATUS_QUERY_VAR, AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_TYPE_QUERY_VAR ),
+			apply_filters( 'query_vars', array() )
+		) );
 	}
 
 	/**
@@ -383,6 +403,264 @@ public function test_add_group_terms_clauses_filter() {
 		$this->assertTrue( has_filter( $tested_filter ) );
 	}
 
+	/**
+	 * Test add_term_filter_query_var.
+	 *
+	 * @covers \AMP_Validation_Error_Taxonomy::add_term_filter_query_var()
+	 */
+	public function test_add_term_filter_query_var() {
+		$initial_url      = admin_url( 'edit-tags.php' );
+		$correct_taxonomy = new WP_Taxonomy( AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG, AMP_Invalid_URL_Post_Type::POST_TYPE_SLUG );
+		$wrong_taxonomy   = new WP_Taxonomy( 'category', 'post' );
+
+		// Because the VALIDATION_ERROR_TYPE_QUERY_VAR isn't present in the POST request, this should return the $initial_url unchanged, without adding the query var.
+		$this->assertEquals( $initial_url, AMP_Validation_Error_Taxonomy::add_term_filter_query_var( $initial_url, $wrong_taxonomy ) );
+
+		// The $_POST does not have a value for VALIDATION_ERROR_TYPE_QUERY_VAR, so this should again return $initial_url unchanged.
+		$wrong_query_var           = 'amp_incorrect_var';
+		$_POST[ $wrong_query_var ] = '1';
+		$this->assertEquals( $initial_url, AMP_Validation_Error_Taxonomy::add_term_filter_query_var( $initial_url, $wrong_taxonomy ) );
+
+		// The $_POST has the VALIDATION_ERROR_TYPE_QUERY_VAR, but does not have a $taxonomy of AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG.
+		$type_query_var_value = AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE;
+		$_POST[ AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_TYPE_QUERY_VAR ] = $type_query_var_value;
+		$this->assertEquals( $initial_url, AMP_Validation_Error_Taxonomy::add_term_filter_query_var( $initial_url, $wrong_taxonomy ) );
+
+		// The $_POST has the taxonomy, but does not have the right 'post_type'.
+		$_POST['taxonomy']  = AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG;
+		$_POST['post_type'] = 'post';
+		$this->assertEquals( $initial_url, AMP_Validation_Error_Taxonomy::add_term_filter_query_var( $initial_url, $correct_taxonomy ) );
+
+		// The $_POST has correct 'post_type', so this should add the VALIDATION_ERROR_TYPE_QUERY_VAR to the $initial_url.
+		$_POST['post_type'] = AMP_Invalid_URL_Post_Type::POST_TYPE_SLUG;
+		$expected_url       = add_query_arg(
+			AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_TYPE_QUERY_VAR,
+			$type_query_var_value,
+			$initial_url
+		);
+		$this->assertEquals( $expected_url, AMP_Validation_Error_Taxonomy::add_term_filter_query_var( $initial_url, $correct_taxonomy ) );
+
+		// The $_POST has a value for the accepted status, so this method should pass that to the redirect URL as a query var.
+		$status_query_var_value = AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_ACCEPTED_STATUS;
+		$_POST[ AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_STATUS_QUERY_VAR ] = $status_query_var_value;
+		$_POST[ AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_TYPE_QUERY_VAR ]   = null;
+		$expected_url = add_query_arg(
+			AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_STATUS_QUERY_VAR,
+			$status_query_var_value,
+			$initial_url
+		);
+		$this->assertEquals( $expected_url, AMP_Validation_Error_Taxonomy::add_term_filter_query_var( $initial_url, $correct_taxonomy ) );
+	}
+
+	/**
+	 * Test add_error_type_clauses_filter.
+	 *
+	 * @covers \AMP_Validation_Error_Taxonomy::add_error_type_clauses_filter()
+	 */
+	public function test_add_error_type_clauses_filter() {
+		global $current_screen;
+
+		$initial_where   = 'foo';
+		$initial_clauses = array( 'where' => $initial_where );
+		$type            = AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE;
+		$taxonomies      = array( AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG );
+
+		set_current_screen( 'front' );
+		$tested_filter = 'terms_clauses';
+		remove_all_filters( $tested_filter );
+		AMP_Validation_Error_Taxonomy::add_error_type_clauses_filter();
+		$this->assertFalse( has_filter( $tested_filter ) );
+
+		// The VALIDATION_ERROR_TYPE_QUERY_VAR isn't present, so this should not add the filter.
+		$current_screen->taxonomy = AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG;
+		AMP_Validation_Error_Taxonomy::add_error_type_clauses_filter();
+		$this->assertFalse( has_filter( $tested_filter ) );
+
+		// Both parts of the conditional should be true, and this should add the filter.
+		$_GET[ AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_TYPE_QUERY_VAR ] = $type;
+		AMP_Validation_Error_Taxonomy::add_error_type_clauses_filter();
+		$this->assertTrue( has_filter( $tested_filter ) );
+
+		// Assert that the filter works as expected.
+		$filtered_clauses = apply_filters( $tested_filter, $initial_clauses, $taxonomies );
+		$this->assertContains( $initial_where, $filtered_clauses['where'] );
+		$this->assertContains( 'AND tt.description LIKE', $filtered_clauses['where'] );
+
+		// If $taxonomies does not have the AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG, the filter should return the clauses unchanged.
+		$taxonomies = array( 'post_tag' );
+		$this->assertEquals( $initial_clauses, apply_filters( $tested_filter, $initial_clauses, $taxonomies ) );
+	}
+
+	/**
+	 * Test render_taxonomy_filters.
+	 *
+	 * @covers \AMP_Validation_Error_Taxonomy::render_taxonomy_filters()
+	 */
+	public function test_render_taxonomy_filters() {
+		AMP_Validation_Error_Taxonomy::register();
+		set_current_screen( 'edit-tags.php' );
+		// Create one new error.
+		$this->factory()->term->create( array(
+			'taxonomy'    => AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG,
+			'description' => wp_json_encode( $this->get_mock_error() ),
+			'term_group'  => AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_NEW_STATUS,
+		) );
+
+		// When passing the wrong $taxonomy_name to the method, it should not output anything.
+		ob_start();
+		AMP_Validation_Error_Taxonomy::render_taxonomy_filters( 'category' );
+		$this->assertEmpty( ob_get_clean() );
+
+		// When there are two new errors, the <option> text should be plural, and have a count of (2).
+		$this->factory()->term->create( array(
+			'taxonomy'    => AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG,
+			'description' => wp_json_encode( $this->get_mock_error() ),
+			'term_group'  => AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_NEW_STATUS,
+		) );
+		ob_start();
+		AMP_Validation_Error_Taxonomy::render_taxonomy_filters( AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG );
+		$this->assertContains( 'New Errors <span class="count">(2)</span>', ob_get_clean() );
+	}
+
+	/**
+	 * Test render_link_to_errors_by_url.
+	 *
+	 * @covers \AMP_Validation_Error_Taxonomy::render_link_to_errors_by_url()
+	 */
+	public function test_render_link_to_errors_by_url() {
+		// When passing the wrong $taxomomy argument, this should not render anything.
+		ob_start();
+		AMP_Validation_Error_Taxonomy::render_link_to_errors_by_url( 'category' );
+		$this->assertEmpty( ob_get_clean() );
+
+		// When passing the correct taxonomy, this should render the link.
+		ob_start();
+		AMP_Validation_Error_Taxonomy::render_link_to_errors_by_url( AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG );
+		$output = ob_get_clean();
+		$this->assertContains( 'View errors by URL', $output );
+		$this->assertContains(
+			add_query_arg(
+				'post_type',
+				AMP_Invalid_URL_Post_Type::POST_TYPE_SLUG,
+				admin_url( 'edit.php' )
+			),
+			$output
+		);
+	}
+
+	/**
+	 * Test render_error_status_filter.
+	 *
+	 * @covers \AMP_Validation_Error_Taxonomy::render_error_status_filter()
+	 */
+	public function test_render_error_status_filter() {
+		AMP_Validation_Error_Taxonomy::register();
+		set_current_screen( 'post.php' );
+
+		// When this is not on the correct screen, this should not render anything.
+		ob_start();
+		AMP_Validation_Error_Taxonomy::render_error_status_filter();
+		$this->assertEmpty( ob_get_clean() );
+
+		set_current_screen( 'edit.php' );
+		$number_of_errors = 10;
+		for ( $i = 0; $i < $number_of_errors; $i++ ) {
+			$invalid_url_post      = $this->factory()->post->create( array( 'post_type' => AMP_Invalid_URL_Post_Type::POST_TYPE_SLUG ) );
+			$validation_error_term = $this->factory()->term->create( array(
+				'taxonomy'    => AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG,
+				'description' => wp_json_encode( $this->get_mock_error() ),
+				'term_group'  => AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_NEW_STATUS,
+			) );
+
+			// Associate the validation error term with a URL so that it appears in a query.
+			wp_set_post_terms(
+				$invalid_url_post,
+				$validation_error_term,
+				AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG
+			);
+		}
+
+		/*
+		 * This is on another accepted screen, so this should again render markup.
+		 * When there are 10 accepted errors, the <option> element for it should end with (10).
+		 */
+		set_current_screen( 'edit-tags.php' );
+		ob_start();
+		AMP_Validation_Error_Taxonomy::render_error_status_filter();
+		$this->assertContains(
+			sprintf(
+				'New Errors <span class="count">(%d)</span>',
+				$number_of_errors
+			),
+			ob_get_clean()
+		);
+	}
+
+	/**
+	 * Test get_error_types.
+	 *
+	 * @covers \AMP_Validation_Error_Taxonomy::get_error_types()
+	 */
+	public function test_get_error_types() {
+		$this->assertEquals(
+			array( 'html_element_error', 'html_attribute_error', 'js_error', 'css_error' ),
+			AMP_Validation_Error_Taxonomy::get_error_types()
+		);
+	}
+
+	/**
+	 * Test render_error_type_filter.
+	 *
+	 * @covers \AMP_Validation_Error_Taxonomy::render_error_type_filter()
+	 */
+	public function test_render_error_type_filter() {
+		set_current_screen( 'edit-tags.php' );
+		$number_of_errors = 10;
+		for ( $i = 0; $i < $number_of_errors; $i++ ) {
+			$this->factory()->term->create( array(
+				'taxonomy'    => AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG,
+				'description' => wp_json_encode( $this->get_mock_error() ),
+				'term_group'  => AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_NEW_STATUS,
+			) );
+		}
+
+		// The strings below should be present.
+		ob_start();
+		AMP_Validation_Error_Taxonomy::render_taxonomy_filters( AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG );
+		$markup = ob_get_clean();
+
+		$expected_to_contain = array(
+			AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_TYPE_QUERY_VAR,
+			AMP_Validation_Error_Taxonomy::HTML_ELEMENT_ERROR_TYPE,
+			AMP_Validation_Error_Taxonomy::HTML_ATTRIBUTE_ERROR_TYPE,
+			AMP_Validation_Error_Taxonomy::JS_ERROR_TYPE,
+			AMP_Validation_Error_Taxonomy::CSS_ERROR_TYPE,
+			'<script>',
+		);
+
+		foreach ( $expected_to_contain as $expected ) {
+			$this->assertContains( $expected, $markup );
+		}
+
+		// When there are 10 errors with this status, its <option> element should have (10).
+		$this->assertContains(
+			sprintf(
+				'New Errors <span class="count">(%d)</span>',
+				$number_of_errors
+			),
+			$markup
+		);
+
+		// On the edit-tags.php page, the <option> text should not have 'With', like 'With JS Errors'.
+		$this->assertNotContains( 'With', $markup );
+
+		// On the edit.php page (Errors by URL), the <option> text should have 'With', like 'With JS Errors'.
+		set_current_screen( 'edit.php' );
+		ob_start();
+		AMP_Validation_Error_Taxonomy::render_taxonomy_filters( AMP_Validation_Error_Taxonomy::TAXONOMY_SLUG );
+		$this->assertContains( 'With', ob_get_clean() );
+	}
+
 	/**
 	 * Test filter_user_has_cap_for_hiding_term_list_table_checkbox.
 	 *
@@ -509,38 +787,15 @@ public function test_add_admin_menu_validation_error_item() {
 		wp_set_current_user( $this->factory()->user->create( array( 'role' => 'administrator' ) ) );
 		AMP_Validation_Error_Taxonomy::add_admin_menu_validation_error_item();
 		$expected_submenu = array(
-			'Validation Errors',
+			'Errors by Type',
 			'manage_categories',
 			'edit-tags.php?taxonomy=amp_validation_error&amp;post_type=amp_invalid_url',
-			'Validation Errors',
+			'Errors by Type',
 		);
 		$amp_options      = $submenu[ AMP_Options_Manager::OPTION_NAME ];
 		$this->assertEquals( $expected_submenu, end( $amp_options ) );
 	}
 
-	/**
-	 * Test filter_views_edit.
-	 *
-	 * @covers \AMP_Validation_Error_Taxonomy::filter_views_edit()
-	 */
-	public function test_filter_views_edit() {
-		AMP_Validation_Error_Taxonomy::register();
-		$views = AMP_Validation_Error_Taxonomy::filter_views_edit( array() );
-		$this->assertContains( 'Accepted', $views['accepted'] );
-		$this->assertContains( '(0)', $views['accepted'] );
-
-		$this->assertContains( 'All', $views['all'] );
-		$this->assertContains( '(0)', $views['all'] );
-
-		$this->assertContains( 'New', $views['new'] );
-		$this->assertContains( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_STATUS_QUERY_VAR, $views['new'] );
-		$this->assertContains( '(0)', $views['new'] );
-
-		$this->assertContains( 'Rejected', $views['rejected'] );
-		$this->assertContains( AMP_Validation_Error_Taxonomy::VALIDATION_ERROR_STATUS_QUERY_VAR, $views['rejected'] );
-		$this->assertContains( '(0)', $views['rejected'] );
-	}
-
 	/**
 	 * Test filter_manage_custom_columns.
 	 *