diff --git a/DEPS b/DEPS
index 8a6fa31..8fd4882 100644
--- a/DEPS
+++ b/DEPS
@@ -102,7 +102,7 @@
   "boringssl_rev": "d24a38200fef19150eef00cad35b138936c08767",
   "browser-compat-data_tag": "ac8cae697014da1ff7124fba33b0b4245cc6cd1b", # v1.0.22
   "cpu_features_rev": "936b9ab5515dead115606559502e3864958f7f6e",
-  "devtools_rev": "486dae7785dc0bda5cc0c463ab704e469bb03f1a",
+  "devtools_rev": "73489f91e37c8f51161b3c63ffced83318e14424",
   "icu_rev": "81d656878ec611cb0b42d52c82e9dae93920d9ba",
   "jinja2_rev": "2222b31554f03e62600cd7e383376a7c187967a1",
   "libcxx_rev": "44079a4cc04cdeffb9cfe8067bfb3c276fb2bab0",
diff --git a/pkg/analysis_server/lib/src/plugin/plugin_manager.dart b/pkg/analysis_server/lib/src/plugin/plugin_manager.dart
index 96bb7b6..59afafd 100644
--- a/pkg/analysis_server/lib/src/plugin/plugin_manager.dart
+++ b/pkg/analysis_server/lib/src/plugin/plugin_manager.dart
@@ -5,7 +5,7 @@
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
-import 'dart:io' show Platform, Process;
+import 'dart:io' show Platform, Process, ProcessResult;
 
 import 'package:analysis_server/src/analytics/percentile_calculator.dart';
 import 'package:analysis_server/src/plugin/notification_manager.dart';
@@ -13,7 +13,6 @@
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
-import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/test_utilities/package_config_file_builder.dart';
 import 'package:analyzer/src/util/file_paths.dart' as file_paths;
@@ -492,7 +491,7 @@
         try {
           plugin.stop();
         } catch (e, st) {
-          AnalysisEngine.instance.instrumentationService
+          instrumentationService
               .logException(SilentException('Issue stopping a plugin', e, st));
         }
       }
@@ -594,7 +593,7 @@
       try {
         await info.stop();
       } catch (e, st) {
-        AnalysisEngine.instance.instrumentationService.logException(e, st);
+        instrumentationService.logException(e, st);
       }
     }));
   }
@@ -616,12 +615,7 @@
         .getChildAssumingFolder(file_paths.dotDartTool)
         .getChildAssumingFile(file_paths.packageConfigJson);
     if (pubCommand != null) {
-      var result = Process.runSync(
-          Platform.executable, <String>['pub', pubCommand],
-          stderrEncoding: utf8,
-          stdoutEncoding: utf8,
-          workingDirectory: pluginFolder.path,
-          environment: {_pubEnvironmentKey: _getPubEnvironmentValue()});
+      var result = _runPubCommand(pubCommand, pluginFolder);
       if (result.exitCode != 0) {
         var buffer = StringBuffer();
         buffer.writeln('Failed to run pub $pubCommand');
@@ -762,6 +756,31 @@
     return const <String>[];
   }
 
+  /// Runs (and records timing to the instrumentation log) a Pub command
+  /// [pubCommand] in [folder].
+  ProcessResult _runPubCommand(String pubCommand, Folder folder) {
+    instrumentationService.logInfo(
+      'Running "pub $pubCommand" in "${folder.path}"',
+    );
+
+    var stopwatch = Stopwatch()..start();
+    var result = Process.runSync(
+      Platform.executable,
+      <String>['pub', pubCommand],
+      stderrEncoding: utf8,
+      stdoutEncoding: utf8,
+      workingDirectory: folder.path,
+      environment: {_pubEnvironmentKey: _getPubEnvironmentValue()},
+    );
+    stopwatch.stop();
+
+    instrumentationService.logInfo(
+      'Running "pub $pubCommand" took ${stopwatch.elapsed}',
+    );
+
+    return result;
+  }
+
   /// Return a hex-encoded MD5 signature of the given file [path].
   String _uniqueDirectoryName(String path) {
     var bytes = md5.convert(path.codeUnits).bytes;
diff --git a/pkg/linter/lib/src/rules/avoid_annotating_with_dynamic.dart b/pkg/linter/lib/src/rules/avoid_annotating_with_dynamic.dart
index 7a4782d..7700059 100644
--- a/pkg/linter/lib/src/rules/avoid_annotating_with_dynamic.dart
+++ b/pkg/linter/lib/src/rules/avoid_annotating_with_dynamic.dart
@@ -9,10 +9,10 @@
 import '../analyzer.dart';
 import '../extensions.dart';
 
-const _desc = r'Avoid annotating with dynamic when not required.';
+const _desc = r'Avoid annotating with `dynamic` when not required.';
 
 const _details = r'''
-**AVOID** annotating with dynamic when not required.
+**AVOID** annotating with `dynamic` when not required.
 
 As `dynamic` is the assumed return value of a function or method, it is usually
 not necessary to annotate it.
diff --git a/pkg/linter/lib/src/rules/avoid_bool_literals_in_conditional_expressions.dart b/pkg/linter/lib/src/rules/avoid_bool_literals_in_conditional_expressions.dart
index 58982a4..2769e24 100644
--- a/pkg/linter/lib/src/rules/avoid_bool_literals_in_conditional_expressions.dart
+++ b/pkg/linter/lib/src/rules/avoid_bool_literals_in_conditional_expressions.dart
@@ -7,10 +7,10 @@
 
 import '../analyzer.dart';
 
-const _desc = r'Avoid bool literals in conditional expressions.';
+const _desc = r'Avoid `bool` literals in conditional expressions.';
 
 const _details = r'''
-**AVOID** bool literals in conditional expressions.
+**AVOID** `bool` literals in conditional expressions.
 
 **BAD:**
 ```dart
diff --git a/pkg/linter/lib/src/rules/avoid_catching_errors.dart b/pkg/linter/lib/src/rules/avoid_catching_errors.dart
index 38a9f36..e628028 100644
--- a/pkg/linter/lib/src/rules/avoid_catching_errors.dart
+++ b/pkg/linter/lib/src/rules/avoid_catching_errors.dart
@@ -8,10 +8,10 @@
 import '../analyzer.dart';
 import '../extensions.dart';
 
-const _desc = r"Don't explicitly catch Error or types that implement it.";
+const _desc = r"Don't explicitly catch `Error` or types that implement it.";
 
 const _details = r'''
-**DON'T** explicitly catch Error or types that implement it.
+**DON'T** explicitly catch `Error` or types that implement it.
 
 Errors differ from Exceptions in that Errors can be analyzed and prevented prior
 to runtime.  It should almost never be necessary to catch an error at runtime.
diff --git a/pkg/linter/lib/src/rules/avoid_double_and_int_checks.dart b/pkg/linter/lib/src/rules/avoid_double_and_int_checks.dart
index 2771724..52e52a2 100644
--- a/pkg/linter/lib/src/rules/avoid_double_and_int_checks.dart
+++ b/pkg/linter/lib/src/rules/avoid_double_and_int_checks.dart
@@ -8,10 +8,10 @@
 
 import '../analyzer.dart';
 
-const _desc = r'Avoid double and int checks.';
+const _desc = r'Avoid `double` and `int` checks.';
 
 const _details = r'''
-**AVOID** to check if type is double or int.
+**AVOID** to check if type is `double` or `int`.
 
 When compiled to JS, integer values are represented as floats. That can lead to
 some unexpected behavior when using either `is` or `is!` where the type is
diff --git a/pkg/linter/lib/src/rules/avoid_dynamic_calls.dart b/pkg/linter/lib/src/rules/avoid_dynamic_calls.dart
index 597da7f..f231ff1 100644
--- a/pkg/linter/lib/src/rules/avoid_dynamic_calls.dart
+++ b/pkg/linter/lib/src/rules/avoid_dynamic_calls.dart
@@ -9,31 +9,31 @@
 
 import '../analyzer.dart';
 
-const _desc = r'Avoid method calls or property accesses on a "dynamic" target.';
+const _desc = r'Avoid method calls or property accesses on a `dynamic` target.';
 
 const _details = r'''
 **DO** avoid method calls or accessing properties on an object that is either
-explicitly or implicitly statically typed "dynamic". Dynamic calls are treated
+explicitly or implicitly statically typed `dynamic`. Dynamic calls are treated
 slightly different in every runtime environment and compiler, but most
 production modes (and even some development modes) have both compile size and
 runtime performance penalties associated with dynamic calls.
 
-Additionally, targets typed "dynamic" disables most static analysis, meaning it
-is easier to lead to a runtime "NoSuchMethodError" or "NullError" than properly
+Additionally, targets typed `dynamic` disables most static analysis, meaning it
+is easier to lead to a runtime `NoSuchMethodError` or `TypeError` than properly
 statically typed Dart code.
 
-There is an exception to methods and properties that exist on "Object?":
-- a.hashCode
-- a.runtimeType
-- a.noSuchMethod(someInvocation)
-- a.toString()
+There is an exception to methods and properties that exist on `Object?`:
+- `a.hashCode`
+- `a.runtimeType`
+- `a.noSuchMethod(someInvocation)`
+- `a.toString()`
 
 ... these members are dynamically dispatched in the web-based runtimes, but not
 in the VM-based ones. Additionally, they are so common that it would be very
 punishing to disallow `any.toString()` or `any == true`, for example.
 
-Note that despite "Function" being a type, the semantics are close to identical
-to "dynamic", and calls to an object that is typed "Function" will also trigger
+Note that despite `Function` being a type, the semantics are close to identical
+to `dynamic`, and calls to an object that is typed `Function` will also trigger
 this lint.
 
 Dynamic calls are allowed on cast expressions (`as dynamic` or `as Function`).
diff --git a/pkg/linter/lib/src/rules/avoid_final_parameters.dart b/pkg/linter/lib/src/rules/avoid_final_parameters.dart
index 606ed4a..ffe4712 100644
--- a/pkg/linter/lib/src/rules/avoid_final_parameters.dart
+++ b/pkg/linter/lib/src/rules/avoid_final_parameters.dart
@@ -7,13 +7,13 @@
 
 import '../analyzer.dart';
 
-const _desc = r'Avoid final for parameter declarations.';
+const _desc = r'Avoid `final` for parameter declarations.';
 
 const _details = r'''
-**AVOID** declaring parameters as final.
+**AVOID** declaring parameters as `final`.
 
-Declaring parameters as final can lead to unnecessarily verbose code, especially
-when using the "parameter_assignments" rule.
+Declaring parameters as `final` can lead to unnecessarily verbose code,
+especially when using the "parameter_assignments" rule.
 
 **BAD:**
 ```dart
diff --git a/pkg/linter/lib/src/rules/avoid_init_to_null.dart b/pkg/linter/lib/src/rules/avoid_init_to_null.dart
index 013da2e..f38d55f 100644
--- a/pkg/linter/lib/src/rules/avoid_init_to_null.dart
+++ b/pkg/linter/lib/src/rules/avoid_init_to_null.dart
@@ -10,19 +10,19 @@
 import '../analyzer.dart';
 import '../extensions.dart';
 
-const _desc = r"Don't explicitly initialize variables to null.";
+const _desc = r"Don't explicitly initialize variables to `null`.";
 
 const _details = r'''
 From [Effective Dart](https://dart.dev/effective-dart/usage#dont-explicitly-initialize-variables-to-null):
 
 **DON'T** explicitly initialize variables to `null`.
 
-If a variable has a non-nullable type or is `final`, 
+If a variable has a non-nullable type or is `final`,
 Dart reports a compile error if you try to use it
-before it has been definitely initialized. 
-If the variable is nullable and not `const` or `final`, 
-then it is implicitly initialized to `null` for you. 
-There's no concept of "uninitialized memory" in Dart 
+before it has been definitely initialized.
+If the variable is nullable and not `const` or `final`,
+then it is implicitly initialized to `null` for you.
+There's no concept of "uninitialized memory" in Dart
 and no need to explicitly initialize a variable to `null` to be "safe".
 Adding `= null` is redundant and unneeded.
 
diff --git a/pkg/linter/lib/src/rules/avoid_null_checks_in_equality_operators.dart b/pkg/linter/lib/src/rules/avoid_null_checks_in_equality_operators.dart
index da81b5a..8d42468 100644
--- a/pkg/linter/lib/src/rules/avoid_null_checks_in_equality_operators.dart
+++ b/pkg/linter/lib/src/rules/avoid_null_checks_in_equality_operators.dart
@@ -11,14 +11,14 @@
 import '../analyzer.dart';
 import '../extensions.dart';
 
-const _desc = r"Don't check for null in custom == operators.";
+const _desc = r"Don't check for `null` in custom `==` operators.";
 
 const _details = r'''
-**DON'T** check for null in custom == operators.
+**DON'T** check for `null` in custom `==` operators.
 
-As null is a special value, no instance of any class (other than `Null`) can be
-equivalent to it.  Thus, it is redundant to check whether the other instance is
-null.
+As `null` is a special value, no instance of any class (other than `Null`) can
+be equivalent to it.  Thus, it is redundant to check whether the other instance
+is `null`.
 
 **BAD:**
 ```dart
diff --git a/pkg/linter/lib/src/rules/avoid_returning_null_for_void.dart b/pkg/linter/lib/src/rules/avoid_returning_null_for_void.dart
index 9fbfe21..f0aa126 100644
--- a/pkg/linter/lib/src/rules/avoid_returning_null_for_void.dart
+++ b/pkg/linter/lib/src/rules/avoid_returning_null_for_void.dart
@@ -8,10 +8,10 @@
 
 import '../analyzer.dart';
 
-const _desc = r'Avoid returning null for void.';
+const _desc = r'Avoid returning `null` for `void`.';
 
 const _details = r'''
-**AVOID** returning null for void.
+**AVOID** returning `null` for `void`.
 
 In a large variety of languages `void` as return type is used to indicate that
 a function doesn't return anything. Dart allows returning `null` in functions
diff --git a/pkg/linter/lib/src/rules/avoid_slow_async_io.dart b/pkg/linter/lib/src/rules/avoid_slow_async_io.dart
index 5b3d746..d95920a 100644
--- a/pkg/linter/lib/src/rules/avoid_slow_async_io.dart
+++ b/pkg/linter/lib/src/rules/avoid_slow_async_io.dart
@@ -10,7 +10,7 @@
 import '../analyzer.dart';
 import '../extensions.dart';
 
-const _desc = r'Avoid slow async `dart:io` methods.';
+const _desc = r'Avoid slow asynchronous `dart:io` methods.';
 
 const _details = r'''
 **AVOID** using the following asynchronous file I/O methods because they are
diff --git a/pkg/linter/lib/src/rules/avoid_void_async.dart b/pkg/linter/lib/src/rules/avoid_void_async.dart
index 201f5a8..f93b948 100644
--- a/pkg/linter/lib/src/rules/avoid_void_async.dart
+++ b/pkg/linter/lib/src/rules/avoid_void_async.dart
@@ -10,12 +10,12 @@
 
 import '../analyzer.dart';
 
-const _desc = r'Avoid async functions that return void.';
+const _desc = r'Avoid `async` functions that return `void`.';
 
 const _details = r'''
-**DO** mark async functions as returning `Future<void>`.
+**DO** mark `async` functions as returning `Future<void>`.
 
-When declaring an async method or function which does not return a value,
+When declaring an `async` method or function which does not return a value,
 declare that it returns `Future<void>` and not just `void`.
 
 **BAD:**
diff --git a/pkg/linter/lib/src/rules/cancel_subscriptions.dart b/pkg/linter/lib/src/rules/cancel_subscriptions.dart
index 7c23370..37726e3 100644
--- a/pkg/linter/lib/src/rules/cancel_subscriptions.dart
+++ b/pkg/linter/lib/src/rules/cancel_subscriptions.dart
@@ -8,10 +8,10 @@
 import '../extensions.dart';
 import '../util/leak_detector_visitor.dart';
 
-const _desc = r'Cancel instances of dart.async.StreamSubscription.';
+const _desc = r'Cancel instances of `dart:async` `StreamSubscription`.';
 
 const _details = r'''
-**DO** invoke `cancel` on instances of `dart.async.StreamSubscription`.
+**DO** invoke `cancel` on instances of `dart:async` `StreamSubscription`.
 
 Cancelling instances of StreamSubscription prevents memory leaks and unexpected
 behavior.
diff --git a/pkg/linter/lib/src/rules/close_sinks.dart b/pkg/linter/lib/src/rules/close_sinks.dart
index 02f0545..70fbae6 100644
--- a/pkg/linter/lib/src/rules/close_sinks.dart
+++ b/pkg/linter/lib/src/rules/close_sinks.dart
@@ -8,10 +8,10 @@
 import '../extensions.dart';
 import '../util/leak_detector_visitor.dart';
 
-const _desc = r'Close instances of `dart.core.Sink`.';
+const _desc = r'Close instances of `dart:core` `Sink`.';
 
 const _details = r'''
-**DO** invoke `close` on instances of `dart.core.Sink`.
+**DO** invoke `close` on instances of `dart:core` `Sink`.
 
 Closing instances of Sink prevents memory leaks and unexpected behavior.
 
diff --git a/pkg/linter/lib/src/rules/control_flow_in_finally.dart b/pkg/linter/lib/src/rules/control_flow_in_finally.dart
index 8b7820e..442da39 100644
--- a/pkg/linter/lib/src/rules/control_flow_in_finally.dart
+++ b/pkg/linter/lib/src/rules/control_flow_in_finally.dart
@@ -7,12 +7,12 @@
 
 import '../analyzer.dart';
 
-const _desc = r'Avoid control flow in finally blocks.';
+const _desc = r'Avoid control flow in `finally` blocks.';
 
 const _details = r'''
-**AVOID** control flow leaving finally blocks.
+**AVOID** control flow leaving `finally` blocks.
 
-Using control flow in finally blocks will inevitably cause unexpected behavior
+Using control flow in `finally` blocks will inevitably cause unexpected behavior
 that is hard to debug.
 
 **BAD:**
diff --git a/pkg/linter/lib/src/rules/discarded_futures.dart b/pkg/linter/lib/src/rules/discarded_futures.dart
index 6801053..f5e9219 100644
--- a/pkg/linter/lib/src/rules/discarded_futures.dart
+++ b/pkg/linter/lib/src/rules/discarded_futures.dart
@@ -9,7 +9,7 @@
 
 import '../analyzer.dart';
 
-const _desc = r"Don't invoke asynchronous functions in non-async blocks.";
+const _desc = r"Don't invoke asynchronous functions in non-`async` blocks.";
 
 const _details = r'''
 Making asynchronous calls in non-`async` functions is usually the sign of a
diff --git a/pkg/linter/lib/src/rules/iterable_contains_unrelated_type.dart b/pkg/linter/lib/src/rules/iterable_contains_unrelated_type.dart
index a836bfa..8655a07 100644
--- a/pkg/linter/lib/src/rules/iterable_contains_unrelated_type.dart
+++ b/pkg/linter/lib/src/rules/iterable_contains_unrelated_type.dart
@@ -4,8 +4,8 @@
 
 import '../analyzer.dart';
 
-const _desc = r'Invocation of Iterable<E>.contains with references of unrelated'
-    r' types.';
+const _desc = r'Invocation of `Iterable<E>.contains` with references of'
+    r' unrelated types.';
 
 const _details = r'''
 NOTE: This rule is removed in Dart 3.3.0; it is no longer functional.
diff --git a/pkg/linter/lib/src/rules/no_runtimeType_toString.dart b/pkg/linter/lib/src/rules/no_runtimeType_toString.dart
index c4d86e9..0ee4a3f 100644
--- a/pkg/linter/lib/src/rules/no_runtimeType_toString.dart
+++ b/pkg/linter/lib/src/rules/no_runtimeType_toString.dart
@@ -10,7 +10,7 @@
 
 import '../analyzer.dart';
 
-const _desc = r'Avoid calling toString() on runtimeType.';
+const _desc = r'Avoid calling `toString()` on `runtimeType`.';
 
 const _details = r'''
 Calling `toString` on a runtime type is a non-trivial operation that can
diff --git a/pkg/linter/lib/src/rules/null_check_on_nullable_type_parameter.dart b/pkg/linter/lib/src/rules/null_check_on_nullable_type_parameter.dart
index 340dae3..659a760 100644
--- a/pkg/linter/lib/src/rules/null_check_on_nullable_type_parameter.dart
+++ b/pkg/linter/lib/src/rules/null_check_on_nullable_type_parameter.dart
@@ -10,13 +10,14 @@
 import '../analyzer.dart';
 import 'unnecessary_null_checks.dart';
 
-const _desc = r"Don't use null check on a potentially nullable type parameter.";
+const _desc =
+    r"Don't use `null` check on a potentially nullable type parameter.";
 
 const _details = r'''
-**DON'T** use null check on a potentially nullable type parameter.
+**DON'T** use `null` check on a potentially nullable type parameter.
 
-Given a generic type parameter `T` which has a nullable bound (e.g. the default
-bound of `Object?`), it is very easy to introduce erroneous null checks when
+Given a generic type parameter `T` which has a nullable bound (e.g., the default
+bound of `Object?`), it is very easy to introduce erroneous `null` checks when
 working with a variable of type `T?`. Specifically, it is not uncommon to have
 `T? x;` and want to assert that `x` has been set to a valid value of type `T`.
 A common mistake is to do so using `x!`. This is almost always incorrect, since
@@ -26,7 +27,7 @@
 ```dart
 T run<T>(T callback()) {
   T? result;
-   (() { result = callback(); })();
+  (() { result = callback(); })();
   return result!;
 }
 ```
@@ -35,7 +36,7 @@
 ```dart
 T run<T>(T callback()) {
   T? result;
-   (() { result = callback(); })();
+  (() { result = callback(); })();
   return result as T;
 }
 ```
diff --git a/pkg/linter/lib/src/rules/prefer_conditional_assignment.dart b/pkg/linter/lib/src/rules/prefer_conditional_assignment.dart
index 2ce482f..3e9de1e 100644
--- a/pkg/linter/lib/src/rules/prefer_conditional_assignment.dart
+++ b/pkg/linter/lib/src/rules/prefer_conditional_assignment.dart
@@ -10,10 +10,10 @@
 import '../extensions.dart';
 import '../util/dart_type_utilities.dart' as type_utils;
 
-const _desc = r'Prefer using `??=` over testing for null.';
+const _desc = r'Prefer using `??=` over testing for `null`.';
 
 const _details = r'''
-**PREFER** using `??=` over testing for null.
+**PREFER** using `??=` over testing for `null`.
 
 As Dart has the `??=` operator, it is advisable to use it where applicable to
 improve the brevity of your code.
diff --git a/pkg/linter/lib/src/rules/prefer_const_constructors.dart b/pkg/linter/lib/src/rules/prefer_const_constructors.dart
index 13d22b0..74095b2 100644
--- a/pkg/linter/lib/src/rules/prefer_const_constructors.dart
+++ b/pkg/linter/lib/src/rules/prefer_const_constructors.dart
@@ -11,7 +11,7 @@
 import '../analyzer.dart';
 import '../extensions.dart';
 
-const _desc = r'Prefer const with constant constructors.';
+const _desc = r'Prefer `const` with constant constructors.';
 
 const _details = r'''
 **PREFER** using `const` for instantiating constant constructors.
diff --git a/pkg/linter/lib/src/rules/prefer_const_constructors_in_immutables.dart b/pkg/linter/lib/src/rules/prefer_const_constructors_in_immutables.dart
index 97aeb57..f52de28 100644
--- a/pkg/linter/lib/src/rules/prefer_const_constructors_in_immutables.dart
+++ b/pkg/linter/lib/src/rules/prefer_const_constructors_in_immutables.dart
@@ -10,13 +10,13 @@
 
 import '../analyzer.dart';
 
-const _desc = r'Prefer declaring const constructors on `@immutable` classes.';
+const _desc = r'Prefer declaring `const` constructors on `@immutable` classes.';
 
 const _details = r'''
-**PREFER** declaring const constructors on `@immutable` classes.
+**PREFER** declaring `const` constructors on `@immutable` classes.
 
 If a class is immutable, it is usually a good idea to make its constructor a
-const constructor.
+`const` constructor.
 
 **BAD:**
 ```dart
diff --git a/pkg/linter/lib/src/rules/prefer_const_declarations.dart b/pkg/linter/lib/src/rules/prefer_const_declarations.dart
index 0f442d8..ccfe415 100644
--- a/pkg/linter/lib/src/rules/prefer_const_declarations.dart
+++ b/pkg/linter/lib/src/rules/prefer_const_declarations.dart
@@ -9,13 +9,13 @@
 import '../analyzer.dart';
 import '../ast.dart';
 
-const _desc = r'Prefer const over final for declarations.';
+const _desc = r'Prefer `const` over `final` for declarations.';
 
 const _details = r'''
-**PREFER** using `const` for const declarations.
+**PREFER** using `const` for constant-valued declarations.
 
-Const declarations are more hot-reload friendly and allow to use const
-constructors if an instantiation references this declaration.
+Constant declarations are more hot-reload friendly and allows
+the value to be used in other constant expressions.
 
 **BAD:**
 ```dart
diff --git a/pkg/linter/lib/src/rules/prefer_final_fields.dart b/pkg/linter/lib/src/rules/prefer_final_fields.dart
index fc86e96..2ca5082 100644
--- a/pkg/linter/lib/src/rules/prefer_final_fields.dart
+++ b/pkg/linter/lib/src/rules/prefer_final_fields.dart
@@ -10,13 +10,13 @@
 import '../analyzer.dart';
 import '../extensions.dart';
 
-const _desc = r'Private field could be final.';
+const _desc = r'Private field could be `final`.';
 
 const _details = r'''
-**DO** prefer declaring private fields as final if they are not reassigned later
-in the library.
+**DO** prefer declaring private fields as `final` if they are not reassigned
+later in the library.
 
-Declaring fields as final when possible is a good practice because it helps
+Declaring fields as `final` when possible is a good practice because it helps
 avoid accidental reassignments and allows the compiler to do optimizations.
 
 **BAD:**
diff --git a/pkg/linter/lib/src/rules/prefer_for_elements_to_map_fromIterable.dart b/pkg/linter/lib/src/rules/prefer_for_elements_to_map_fromIterable.dart
index 1faf7bf..8a79684 100644
--- a/pkg/linter/lib/src/rules/prefer_for_elements_to_map_fromIterable.dart
+++ b/pkg/linter/lib/src/rules/prefer_for_elements_to_map_fromIterable.dart
@@ -8,10 +8,10 @@
 
 import '../analyzer.dart';
 
-const _desc = r"Prefer 'for' elements when building maps from iterables.";
+const _desc = r'Prefer `for` elements when building maps from iterables.';
 
 const _details = r'''
-When building maps from iterables, it is preferable to use 'for' elements.
+When building maps from iterables, it is preferable to use `for` elements.
 
 Using 'for' elements brings several benefits including:
 
diff --git a/pkg/linter/lib/src/rules/prefer_if_null_operators.dart b/pkg/linter/lib/src/rules/prefer_if_null_operators.dart
index d6748be..ba5a412 100644
--- a/pkg/linter/lib/src/rules/prefer_if_null_operators.dart
+++ b/pkg/linter/lib/src/rules/prefer_if_null_operators.dart
@@ -8,10 +8,10 @@
 
 import '../analyzer.dart';
 
-const _desc = r'Prefer using if null operators.';
+const _desc = r'Prefer using `??` operators.';
 
 const _details = r'''
-**PREFER** using if null operators instead of null checks in conditional
+**PREFER** using `??` operators instead of `null` checks and conditional
 expressions.
 
 **BAD:**
diff --git a/pkg/linter/lib/src/rules/prefer_is_empty.dart b/pkg/linter/lib/src/rules/prefer_is_empty.dart
index 02298a6..654c3e3 100644
--- a/pkg/linter/lib/src/rules/prefer_is_empty.dart
+++ b/pkg/linter/lib/src/rules/prefer_is_empty.dart
@@ -11,7 +11,7 @@
 import '../ast.dart';
 import '../extensions.dart';
 
-const _desc = r'Use `isEmpty` for Iterables and Maps.';
+const _desc = r'Use `isEmpty` for `Iterable`s and `Map`s.';
 const _details = r'''
 **DON'T** use `length` to see if a collection is empty.
 
diff --git a/pkg/linter/lib/src/rules/prefer_is_not_empty.dart b/pkg/linter/lib/src/rules/prefer_is_not_empty.dart
index 5b1407f..60afa97 100644
--- a/pkg/linter/lib/src/rules/prefer_is_not_empty.dart
+++ b/pkg/linter/lib/src/rules/prefer_is_not_empty.dart
@@ -10,7 +10,7 @@
 import '../analyzer.dart';
 import '../ast.dart';
 
-const _desc = r'Use `isNotEmpty` for Iterables and Maps.';
+const _desc = r'Use `isNotEmpty` for `Iterable`s and `Map`s.';
 
 const _details = r'''
 **PREFER** `x.isNotEmpty` to `!x.isEmpty` for `Iterable` and `Map` instances.
diff --git a/pkg/linter/lib/src/rules/prefer_iterable_whereType.dart b/pkg/linter/lib/src/rules/prefer_iterable_whereType.dart
index 00787c8..c1106e1 100644
--- a/pkg/linter/lib/src/rules/prefer_iterable_whereType.dart
+++ b/pkg/linter/lib/src/rules/prefer_iterable_whereType.dart
@@ -9,7 +9,7 @@
 import '../analyzer.dart';
 import '../extensions.dart';
 
-const _desc = r'Prefer to use whereType on iterable.';
+const _desc = r'Prefer to use `whereType` on iterable.';
 
 const _details = r'''
 **PREFER** `iterable.whereType<T>()` over `iterable.where((e) => e is T)`.
diff --git a/pkg/linter/lib/src/rules/prefer_null_aware_method_calls.dart b/pkg/linter/lib/src/rules/prefer_null_aware_method_calls.dart
index deefbaa..ae8e7ce 100644
--- a/pkg/linter/lib/src/rules/prefer_null_aware_method_calls.dart
+++ b/pkg/linter/lib/src/rules/prefer_null_aware_method_calls.dart
@@ -8,11 +8,11 @@
 
 import '../analyzer.dart';
 
-const _desc = r'Prefer null aware method calls.';
+const _desc = r'Prefer `null`-aware method calls.';
 
 const _details = r'''
-Instead of checking nullability of a function/method `f` before calling it you
-can use `f?.call()`.
+Instead of checking nullability of a function/method `f` before calling it,
+you can use `f?.call()`.
 
 **BAD:**
 ```dart
diff --git a/pkg/linter/lib/src/rules/prefer_null_aware_operators.dart b/pkg/linter/lib/src/rules/prefer_null_aware_operators.dart
index 5628f8c..0b610c3 100644
--- a/pkg/linter/lib/src/rules/prefer_null_aware_operators.dart
+++ b/pkg/linter/lib/src/rules/prefer_null_aware_operators.dart
@@ -8,10 +8,10 @@
 
 import '../analyzer.dart';
 
-const _desc = r'Prefer using null aware operators.';
+const _desc = r'Prefer using `null`-aware operators.';
 
 const _details = r'''
-**PREFER** using null aware operators instead of null checks in conditional
+**PREFER** using `null`-aware operators instead of `null` checks in conditional
 expressions.
 
 **BAD:**
diff --git a/pkg/linter/lib/src/rules/provide_deprecation_message.dart b/pkg/linter/lib/src/rules/provide_deprecation_message.dart
index 2b0c54f..7d135ca 100644
--- a/pkg/linter/lib/src/rules/provide_deprecation_message.dart
+++ b/pkg/linter/lib/src/rules/provide_deprecation_message.dart
@@ -7,11 +7,11 @@
 
 import '../analyzer.dart';
 
-const _desc = r'Provide a deprecation message, via @Deprecated("message").';
+const _desc = r'Provide a deprecation message, via `@Deprecated("message")`.';
 
 const _details = r'''
 **DO** specify a deprecation message (with migration instructions and/or a
-removal schedule) in the Deprecation constructor.
+removal schedule) in the `Deprecated` constructor.
 
 **BAD:**
 ```dart
diff --git a/pkg/linter/lib/src/rules/pub/package_names.dart b/pkg/linter/lib/src/rules/pub/package_names.dart
index 8e040f1..1e02c33 100644
--- a/pkg/linter/lib/src/rules/pub/package_names.dart
+++ b/pkg/linter/lib/src/rules/pub/package_names.dart
@@ -13,7 +13,7 @@
 **DO** use `lowercase_with_underscores` for package names.
 
 Package names should be all lowercase, with underscores to separate words,
-`just_like_this`.  Use only basic Latin letters and Arabic digits: [a-z0-9_].
+`just_like_this`.  Use only basic Latin letters and Arabic digits: \[a-z0-9\_\].
 Also, make sure the name is a valid Dart identifier -- that it doesn't start
 with digits and isn't a reserved word.
 
diff --git a/pkg/linter/lib/src/rules/sized_box_for_whitespace.dart b/pkg/linter/lib/src/rules/sized_box_for_whitespace.dart
index 771c006..4bd2405 100644
--- a/pkg/linter/lib/src/rules/sized_box_for_whitespace.dart
+++ b/pkg/linter/lib/src/rules/sized_box_for_whitespace.dart
@@ -8,10 +8,10 @@
 import '../analyzer.dart';
 import '../util/flutter_utils.dart';
 
-const _desc = r'SizedBox for whitespace.';
+const _desc = r'`SizedBox` for whitespace.';
 
 const _details = r'''
-Use SizedBox to add whitespace to a layout.
+Use `SizedBox` to add whitespace to a layout.
 
 A `Container` is a heavier Widget than a `SizedBox`, and as bonus, `SizedBox`
 has a `const` constructor.
diff --git a/pkg/linter/lib/src/rules/slash_for_doc_comments.dart b/pkg/linter/lib/src/rules/slash_for_doc_comments.dart
index 72b6333..d54a24f 100644
--- a/pkg/linter/lib/src/rules/slash_for_doc_comments.dart
+++ b/pkg/linter/lib/src/rules/slash_for_doc_comments.dart
@@ -7,7 +7,7 @@
 
 import '../analyzer.dart';
 
-const _desc = r'Prefer using /// for doc comments.';
+const _desc = r'Prefer using `///` for doc comments.';
 
 const _details = r'''
 From [Effective Dart](https://dart.dev/effective-dart/documentation#do-use--doc-comments-to-document-members-and-types):
diff --git a/pkg/linter/lib/src/rules/test_types_in_equals.dart b/pkg/linter/lib/src/rules/test_types_in_equals.dart
index 0dd7dd2..023e00e 100644
--- a/pkg/linter/lib/src/rules/test_types_in_equals.dart
+++ b/pkg/linter/lib/src/rules/test_types_in_equals.dart
@@ -7,12 +7,12 @@
 
 import '../analyzer.dart';
 
-const _desc = r'Test type arguments in operator ==(Object other).';
+const _desc = r'Test type of argument in `operator ==(Object other)`.';
 
 const _details = r'''
-**DO** test type arguments in operator ==(Object other).
+**DO** test type of argument in `operator ==(Object other)`.
 
-Not testing types might result in null pointer exceptions which will be
+Not testing the type might result in runtime type errors which will be
 unexpected for consumers of your class.
 
 **BAD:**
diff --git a/pkg/linter/lib/src/rules/throw_in_finally.dart b/pkg/linter/lib/src/rules/throw_in_finally.dart
index 0c7aa53..b074b96 100644
--- a/pkg/linter/lib/src/rules/throw_in_finally.dart
+++ b/pkg/linter/lib/src/rules/throw_in_finally.dart
@@ -8,13 +8,13 @@
 import '../analyzer.dart';
 import '../rules/control_flow_in_finally.dart';
 
-const _desc = r'Avoid `throw` in finally block.';
+const _desc = r'Avoid `throw` in `finally` block.';
 
 const _details = r'''
-**AVOID** throwing exceptions in finally blocks.
+**AVOID** throwing exceptions in `finally` blocks.
 
-Throwing exceptions in finally blocks will inevitably cause unexpected behavior
-that is hard to debug.
+Throwing exceptions in `finally` blocks will inevitably cause unexpected
+behavior that is hard to debug.
 
 **BAD:**
 ```dart
diff --git a/pkg/linter/lib/src/rules/unnecessary_await_in_return.dart b/pkg/linter/lib/src/rules/unnecessary_await_in_return.dart
index d1059e4..c1632db 100644
--- a/pkg/linter/lib/src/rules/unnecessary_await_in_return.dart
+++ b/pkg/linter/lib/src/rules/unnecessary_await_in_return.dart
@@ -8,7 +8,7 @@
 
 import '../analyzer.dart';
 
-const _desc = r'Unnecessary await keyword in return.';
+const _desc = r'Unnecessary `await` keyword in return.';
 
 const _details = r'''
 Avoid returning an awaited expression when the expression type is assignable to
diff --git a/pkg/linter/lib/src/rules/unnecessary_const.dart b/pkg/linter/lib/src/rules/unnecessary_const.dart
index 4a33dca..7092555 100644
--- a/pkg/linter/lib/src/rules/unnecessary_const.dart
+++ b/pkg/linter/lib/src/rules/unnecessary_const.dart
@@ -8,10 +8,10 @@
 
 import '../analyzer.dart';
 
-const _desc = r'Avoid const keyword.';
+const _desc = r'Avoid `const` keyword.';
 
 const _details = r'''
-**AVOID** repeating const keyword in a const context.
+**AVOID** repeating `const` keyword in a `const` context.
 
 **BAD:**
 ```dart
diff --git a/pkg/linter/lib/src/rules/unnecessary_null_aware_assignments.dart b/pkg/linter/lib/src/rules/unnecessary_null_aware_assignments.dart
index 6ecfe6f..0964fa5 100644
--- a/pkg/linter/lib/src/rules/unnecessary_null_aware_assignments.dart
+++ b/pkg/linter/lib/src/rules/unnecessary_null_aware_assignments.dart
@@ -10,13 +10,13 @@
 import '../analyzer.dart';
 import '../extensions.dart';
 
-const _desc = r'Avoid null in null-aware assignment.';
+const _desc = r'Avoid `null` in `null`-aware assignment.';
 
 const _details = r'''
-**AVOID** `null` in null-aware assignment.
+**AVOID** `null` in `null`-aware assignment.
 
-Using `null` on the right-hand side of a null-aware assignment effectively makes
-the assignment redundant.
+Using `null` on the right-hand side of a `null`-aware assignment effectively
+makes the assignment redundant.
 
 **BAD:**
 ```dart
diff --git a/pkg/linter/lib/src/rules/unnecessary_null_checks.dart b/pkg/linter/lib/src/rules/unnecessary_null_checks.dart
index cfad8db..2de35f1 100644
--- a/pkg/linter/lib/src/rules/unnecessary_null_checks.dart
+++ b/pkg/linter/lib/src/rules/unnecessary_null_checks.dart
@@ -9,10 +9,10 @@
 
 import '../analyzer.dart';
 
-const _desc = r'Unnecessary null checks.';
+const _desc = r'Unnecessary `null` checks.';
 
 const _details = r'''
-**DON'T** apply a null check when a nullable value is accepted.
+**DON'T** apply a `null` check where a nullable value is accepted.
 
 **BAD:**
 ```dart
diff --git a/pkg/linter/lib/src/rules/unnecessary_null_in_if_null_operators.dart b/pkg/linter/lib/src/rules/unnecessary_null_in_if_null_operators.dart
index b519368..f01e3a7 100644
--- a/pkg/linter/lib/src/rules/unnecessary_null_in_if_null_operators.dart
+++ b/pkg/linter/lib/src/rules/unnecessary_null_in_if_null_operators.dart
@@ -9,10 +9,10 @@
 import '../analyzer.dart';
 import '../extensions.dart';
 
-const _desc = r'Avoid using `null` in `if null` operators.';
+const _desc = r'Avoid using `null` in `??` operators.';
 
 const _details = r'''
-**AVOID** using `null` as an operand in `if null` operators.
+**AVOID** using `null` as an operand in `??` operators.
 
 Using `null` in an `if null` operator is redundant, regardless of which side
 `null` is used on.
diff --git a/pkg/linter/lib/src/rules/unnecessary_to_list_in_spreads.dart b/pkg/linter/lib/src/rules/unnecessary_to_list_in_spreads.dart
index aaac575..092864f 100644
--- a/pkg/linter/lib/src/rules/unnecessary_to_list_in_spreads.dart
+++ b/pkg/linter/lib/src/rules/unnecessary_to_list_in_spreads.dart
@@ -8,7 +8,7 @@
 import '../analyzer.dart';
 import '../extensions.dart';
 
-const _desc = r'Unnecessary toList() in spreads.';
+const _desc = r'Unnecessary `toList()` in spreads.';
 
 const _details = r'''
 Unnecessary `toList()` in spreads.
diff --git a/pkg/linter/lib/src/rules/use_build_context_synchronously.dart b/pkg/linter/lib/src/rules/use_build_context_synchronously.dart
index 39df5df..02a80a8 100644
--- a/pkg/linter/lib/src/rules/use_build_context_synchronously.dart
+++ b/pkg/linter/lib/src/rules/use_build_context_synchronously.dart
@@ -15,10 +15,10 @@
 import '../analyzer.dart';
 import '../util/flutter_utils.dart';
 
-const _desc = r'Do not use BuildContexts across async gaps.';
+const _desc = r'Do not use `BuildContext` across asynchronous gaps.';
 
 const _details = r'''
-**DON'T** use BuildContext across asynchronous gaps.
+**DON'T** use `BuildContext` across asynchronous gaps.
 
 Storing `BuildContext` for later usage can easily lead to difficult to diagnose
 crashes. Asynchronous gaps are implicitly storing `BuildContext` and are some of
diff --git a/pkg/linter/lib/src/rules/use_if_null_to_convert_nulls_to_bools.dart b/pkg/linter/lib/src/rules/use_if_null_to_convert_nulls_to_bools.dart
index 28d0307..077a47f 100644
--- a/pkg/linter/lib/src/rules/use_if_null_to_convert_nulls_to_bools.dart
+++ b/pkg/linter/lib/src/rules/use_if_null_to_convert_nulls_to_bools.dart
@@ -9,12 +9,12 @@
 
 import '../analyzer.dart';
 
-const _desc = r'Use if-null operators to convert nulls to bools.';
+const _desc = r'Use `??` operators to convert `null`s to `bool`s.';
 
 const _details = r'''
 From [Effective Dart](https://dart.dev/effective-dart/usage#prefer-using--to-convert-null-to-a-boolean-value):
 
-Use if-null operators to convert nulls to bools.
+Use `??` operators to convert `null`s to `bool`s.
 
 **BAD:**
 ```dart
diff --git a/pkg/linter/lib/src/rules/void_checks.dart b/pkg/linter/lib/src/rules/void_checks.dart
index 69bf1a6..1562e18 100644
--- a/pkg/linter/lib/src/rules/void_checks.dart
+++ b/pkg/linter/lib/src/rules/void_checks.dart
@@ -9,10 +9,10 @@
 
 import '../analyzer.dart';
 
-const _desc = r"Don't assign to void.";
+const _desc = r"Don't assign to `void`.";
 
 const _details = r'''
-**DON'T** assign to void.
+**DON'T** assign to `void`.
 
 **BAD:**
 ```dart
diff --git a/tools/VERSION b/tools/VERSION
index a1e88e5..db56202 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 3
 MINOR 5
 PATCH 0
-PRERELEASE 134
+PRERELEASE 135
 PRERELEASE_PATCH 0