diff --git a/src/System.CommandLine/Argument.cs b/src/System.CommandLine/Argument.cs
index f1c915045e..af2937f055 100644
--- a/src/System.CommandLine/Argument.cs
+++ b/src/System.CommandLine/Argument.cs
@@ -10,7 +10,7 @@
 namespace System.CommandLine
 {
     /// <summary>
-    /// A symbol defining a value that can be passed on the command line to a <see cref="Command">command</see> or <see cref="Option">option</see>.
+    /// Represents a symbol that defines a value that can be passed on the command line to a <see cref="Command">command</see> or <see cref="Option">option</see>.
     /// </summary>
     public abstract class Argument : Symbol
     {
@@ -22,7 +22,7 @@ public abstract class Argument : Symbol
         /// <summary>
         /// Initializes a new instance of the Argument class.
         /// </summary>
-        /// <param name="name">The name of the argument. This can be used to look up the parsed value and is displayed in help</param>
+        /// <param name="name">The name of the argument. This value can be used to look up the parsed value and is displayed in help if <see cref="HelpName" /> is null.</param>
         protected Argument(string name) : base(name, allowWhitespace: true)
         {
         }
@@ -48,8 +48,11 @@ public ArgumentArity Arity
         /// Gets or sets the placeholder name shown in usage help for the argument's value.
         /// The value will be wrapped in angle brackets (<c>&lt;</c> and <c>&gt;</c>).
         /// </summary>
+        /// <value>
+        /// The name to show as the placeholder for the argument's value.
+        /// </value>
         /// <remarks>
-        /// If <c>null</c>, the <see cref="Symbol.Name"/> of the argument will be used.
+        /// If <c>null</c>, the <see cref="Symbol.Name"/> of the argument is used.
         /// </remarks>
         /// <example>
         /// An argument with <see cref="Symbol.Name"/> of <c>argument</c> and a
@@ -57,9 +60,6 @@ public ArgumentArity Arity
         /// <c>&lt;Value&gt;</c>. If <see cref="HelpName"/> is not set,
         /// help output will show: <c>&lt;argument&gt;</c>.
         /// </example>
-        /// <value>
-        /// The name to show as the placeholder for the argument's value.
-        /// </value>
         public string? HelpName { get; set; }
 
         internal TryConvertArgument? ConvertArguments
@@ -107,12 +107,12 @@ public List<Func<CompletionContext, IEnumerable<CompletionItem>>> CompletionSour
         }
 
         /// <summary>
-        /// Gets or sets the <see cref="Type" /> that the argument's parsed tokens will be converted to.
+        /// Gets the type that the argument's parsed tokens will be converted to.
         /// </summary>
         public abstract Type ValueType { get; }
 
         /// <summary>
-        /// Provides a list of argument validators. Validators can be used
+        /// Gets a list of argument validators. Validators can be used
         /// to provide custom errors based on user input.
         /// </summary>
         public List<Action<ArgumentResult>> Validators => _validators ??= new ();
@@ -122,7 +122,7 @@ public List<Func<CompletionContext, IEnumerable<CompletionItem>>> CompletionSour
         /// <summary>
         /// Gets the default value for the argument.
         /// </summary>
-        /// <returns>Returns the default value for the argument, if defined. Null otherwise.</returns>
+        /// <returns>The default value for the argument, if defined; otherwise, <see langword="null" />.</returns>
         public object? GetDefaultValue()
         {
             var command = Parents.FlattenBreadthFirst(x => x.Parents)
@@ -135,7 +135,7 @@ public List<Func<CompletionContext, IEnumerable<CompletionItem>>> CompletionSour
         internal abstract object? GetDefaultValue(ArgumentResult argumentResult);
 
         /// <summary>
-        /// Specifies if a default value is defined for the argument.
+        /// Gets a value that indicates if a default value is defined for the argument.
         /// </summary>
         public abstract bool HasDefaultValue { get; }
 
diff --git a/src/System.CommandLine/Argument{T}.cs b/src/System.CommandLine/Argument{T}.cs
index 2a9dd55592..999ac5604f 100644
--- a/src/System.CommandLine/Argument{T}.cs
+++ b/src/System.CommandLine/Argument{T}.cs
@@ -15,17 +15,17 @@ public class Argument<T> : Argument
         /// <summary>
         /// Initializes a new instance of the Argument class.
         /// </summary>
-        /// <param name="name">The name of the argument. This can be used to look up the parsed value and is displayed in help</param>
+        /// <param name="name">The name of the argument. This name can be used to look up the parsed value and is displayed in help.</param>
         public Argument(string name) : base(name)
         {
         }
 
         /// <summary>
-        /// The delegate to invoke to create the default value.
+        /// Gets or sets the delegate to invoke to create the default value.
         /// </summary>
         /// <remarks>
-        /// It's invoked when there was no parse input provided for given Argument.
-        /// The same instance can be set as <see cref="CustomParser"/>, in such case
+        /// This delegate is invoked when there was no parse input provided for given Argument.
+        /// The same instance can be set as <see cref="CustomParser"/>. In that case,
         /// the delegate is also invoked when an input was provided.
         /// </remarks>
         public Func<ArgumentResult, T>? DefaultValueFactory
@@ -45,11 +45,11 @@ public Func<ArgumentResult, T>? DefaultValueFactory
         }
 
         /// <summary>
-        /// A custom argument parser.
+        /// Gets or sets a custom argument parser.
         /// </summary>
         /// <remarks>
-        /// It's invoked when there was parse input provided for given Argument.
-        /// The same instance can be set as <see cref="DefaultValueFactory"/>, in such case
+        /// The custom parser is invoked when there was parse input provided for a given Argument.
+        /// The same instance can be set as <see cref="DefaultValueFactory"/>; in that case,
         /// the delegate is also invoked when no input was provided.
         /// </remarks>
         public Func<ArgumentResult, T?>? CustomParser
diff --git a/src/System.CommandLine/Command.cs b/src/System.CommandLine/Command.cs
index be565651d2..a44f9789e0 100644
--- a/src/System.CommandLine/Command.cs
+++ b/src/System.CommandLine/Command.cs
@@ -18,9 +18,9 @@ namespace System.CommandLine
     /// Represents a specific action that the application performs.
     /// </summary>
     /// <remarks>
-    /// Use the Command object for actions that correspond to a specific string (the command name). See
-    /// <see cref="RootCommand"/> for simple applications that only have one action. For example, <c>dotnet run</c>
-    /// uses <c>run</c> as the command.
+    /// Use the Command object for actions that correspond to a specific string (the command name).
+    /// For simple applications that only have one action, see <see cref="RootCommand"/>.
+    /// For example, <c>dotnet run</c> uses <c>run</c> as the command.
     /// </remarks>
     public class Command : Symbol, IEnumerable
     {
@@ -57,28 +57,31 @@ public IEnumerable<Symbol> Children
         }
 
         /// <summary>
-        /// Represents all of the arguments for the command.
+        /// Gets all of the arguments for the command.
         /// </summary>
         public IList<Argument> Arguments => _arguments ??= new(this);
 
         internal bool HasArguments => _arguments?.Count > 0 ;
 
         /// <summary>
-        /// Represents all of the options for the command, inherited options that have been applied to any of the command's ancestors.
+        /// Gets all of the options for the command.
         /// </summary>
+        /// <remarks>
+        /// This collection doesn't include options on parent commands where <see cref="Option.Recursive">Option.Recursive</see> is <see langword="true" />. Those options are valid under the current command but don't appear in this collection.
+        /// </remarks>
         public IList<Option> Options => _options ??= new (this);
 
         internal bool HasOptions => _options?.Count > 0;
 
         /// <summary>
-        /// Represents all of the subcommands for the command.
+        /// Gets all of the subcommands for the command.
         /// </summary>
         public IList<Command> Subcommands => _subcommands ??= new(this);
 
         internal bool HasSubcommands => _subcommands is not null && _subcommands.Count > 0;
 
         /// <summary>
-        /// Validators to the command. Validators can be used
+        /// Gets the validators to the command. Validators can be used
         /// to create custom validation logic.
         /// </summary>
         public List<Action<CommandResult>> Validators => _validators ??= new ();
@@ -215,9 +218,9 @@ public void SetAction(Func<ParseResult, CancellationToken, Task<int>> action)
         /// </summary>
         /// <param name="argument">The option to add to the command.</param>
         public void Add(Argument argument) =>  Arguments.Add(argument);
-        
+
         /// <summary>
-        /// Adds a <see cref="Option"/> to the command.
+        /// Adds an <see cref="Option"/> to the command.
         /// </summary>
         /// <param name="option">The option to add to the command.</param>
         public void Add(Option option) =>  Options.Add(option);
@@ -226,17 +229,17 @@ public void SetAction(Func<ParseResult, CancellationToken, Task<int>> action)
         /// Adds a <see cref="Command"/> to the command.
         /// </summary>
         /// <param name="command">The Command to add to the command.</param>
-        public void Add(Command command) =>  Subcommands.Add(command);
+        public void Add(Command command) => Subcommands.Add(command);
 
         /// <summary>
-        /// Gets or sets a value that indicates whether unmatched tokens should be treated as errors. For example,
-        /// if set to <see langword="true"/> and an extra command or argument is provided, validation will fail.
+        /// Gets or sets a value that indicates whether unmatched tokens should be treated as errors.
         /// </summary>
+        /// <value><see langword="true"/> to fail validation when an extra command or argument is provided; otherwise, <see langword="false"/>.</value>
         public bool TreatUnmatchedTokensAsErrors { get; set; } = true;
 
         /// <inheritdoc />
         [DebuggerStepThrough]
-        [EditorBrowsable(EditorBrowsableState.Never)] // hide from intellisense, it's public for C# collection initializer 
+        [EditorBrowsable(EditorBrowsableState.Never)] // hide from intellisense, it's public for C# collection initializer
         IEnumerator IEnumerable.GetEnumerator() => Children.GetEnumerator();
 
         /// <summary>
diff --git a/src/System.CommandLine/Completions/SuggestDirective.cs b/src/System.CommandLine/Completions/SuggestDirective.cs
index f52a011ebe..088c16b759 100644
--- a/src/System.CommandLine/Completions/SuggestDirective.cs
+++ b/src/System.CommandLine/Completions/SuggestDirective.cs
@@ -3,7 +3,7 @@
 namespace System.CommandLine.Completions;
 
 /// <summary>
-/// Enables the use of the <c>[suggest]</c> directive which when specified in command line input short circuits normal command handling and writes a newline-delimited list of suggestions suitable for use by most shells to provide command line completions.
+/// Enables the use of the <c>[suggest]</c> directive, which, when specified in command-line input, short circuits normal command handling and writes a newline-delimited list of suggestions suitable for use by most shells to provide command line completions.
 /// </summary>
 /// <remarks>The <c>dotnet-suggest</c> tool requires the suggest directive to be enabled for an application to provide completions.</remarks>
 public sealed class SuggestDirective : Directive
@@ -22,4 +22,4 @@ public override CommandLineAction? Action
         set => _action = value ?? throw new ArgumentNullException(nameof(value));
     }
 
-}
\ No newline at end of file
+}
diff --git a/src/System.CommandLine/Directive.cs b/src/System.CommandLine/Directive.cs
index a779585bd1..558fd986e1 100644
--- a/src/System.CommandLine/Directive.cs
+++ b/src/System.CommandLine/Directive.cs
@@ -8,14 +8,16 @@
 namespace System.CommandLine
 {
     /// <summary>
-    /// The purpose of directives is to provide cross-cutting functionality that can apply across command-line apps.
+    /// Provides cross-cutting functionality that can apply across command-line apps.
+    /// </summary>
+    /// <remarks>
     /// Because directives are syntactically distinct from the app's own syntax, they can provide functionality that applies across apps.
-    /// 
+    ///
     /// A directive must conform to the following syntax rules:
     /// * It's a token on the command line that comes after the app's name but before any subcommands or options.
     /// * It's enclosed in square brackets.
     /// * It doesn't contain spaces.
-    /// </summary>
+    /// </remarks>
     public class Directive : Symbol
     {
         /// <summary>
diff --git a/src/System.CommandLine/Help/HelpAction.cs b/src/System.CommandLine/Help/HelpAction.cs
index 5566380d7e..815499c7ea 100644
--- a/src/System.CommandLine/Help/HelpAction.cs
+++ b/src/System.CommandLine/Help/HelpAction.cs
@@ -3,7 +3,7 @@
 namespace System.CommandLine.Help
 {
     /// <summary>
-    /// Provides command line help.
+    /// Provides command-line help.
     /// </summary>
     public sealed class HelpAction : SynchronousCommandLineAction
     {
@@ -11,11 +11,11 @@ public sealed class HelpAction : SynchronousCommandLineAction
         private int _maxWidth = -1;
 
         /// <summary>
-        /// The maximum width in characters after which help output is wrapped.
+        /// Gets or sets the maximum width in characters after which help output is wrapped.
         /// </summary>
-        /// <remarks>It defaults to <see cref="Console.WindowWidth"/>.</remarks>
+        /// <value>The maximum width in characters after which help output is wrapped. The default is <see cref="Console.WindowWidth"/>.</value>
         public int MaxWidth
-        { 
+        {
             get
             {
                 if (_maxWidth < 0)
@@ -44,7 +44,7 @@ public int MaxWidth
         }
 
         /// <summary>
-        /// Specifies an <see cref="Builder"/> to be used to format help output when help is requested.
+        /// Gets or sets the <see cref="Builder"/> to use to format help output.
         /// </summary>
         internal HelpBuilder Builder
         {
@@ -68,4 +68,4 @@ public override int Invoke(ParseResult parseResult)
 
         public override bool ClearsParseErrors => true;
     }
-}
\ No newline at end of file
+}
diff --git a/src/System.CommandLine/Invocation/ParseErrorAction.cs b/src/System.CommandLine/Invocation/ParseErrorAction.cs
index 3f35c2cc1e..fd939ccfea 100644
--- a/src/System.CommandLine/Invocation/ParseErrorAction.cs
+++ b/src/System.CommandLine/Invocation/ParseErrorAction.cs
@@ -10,20 +10,20 @@
 namespace System.CommandLine.Invocation;
 
 /// <summary>
-/// Provides command line output with error details in the case of a parsing error.
+/// Provides command-line output with error details in the case of a parsing error.
 /// </summary>
 public sealed class ParseErrorAction : SynchronousCommandLineAction
 {
     /// <summary>
-    /// Indicates whether to show help along with error details when an error is found during parsing.
+    /// Gets or sets a value that indicates whether to show help along with error details when an error is found during parsing.
     /// </summary>
-    /// <remarks>When set to <see langword="true" />, indicates that help will be shown along with parse error details. When set to false, help will not be shown.</remarks>
+    /// <value><see langword="true" /> to show help along with parse error details. <see langword="false" /> to not show help.</value>
     public bool ShowHelp { get; set; } = true;
 
     /// <summary>
-    /// Indicates whether to show typo suggestions along with error details when an error is found during parsing.
+    /// Gets or sets a value that indicates whether to show typo suggestions along with error details when an error is found during parsing.
     /// </summary>
-    /// <remarks>When set to <see langword="true" />, indicates that suggestions will be shown along with parse error details. When set to false, suggestions will not be shown.</remarks>
+    /// <value><see langword="true" /> to show suggestions along with parse error details. <see langword="false" /> to now show suggestions.</value>
     public bool ShowTypoCorrections { get; set; } = true;
 
     /// <inheritdoc />
@@ -232,4 +232,4 @@ static int GetDistance(string first, string second)
     }
 
     private const int MaxLevenshteinDistance = 3;
-}
\ No newline at end of file
+}
diff --git a/src/System.CommandLine/InvocationConfiguration.cs b/src/System.CommandLine/InvocationConfiguration.cs
index 9338503bee..3537835008 100644
--- a/src/System.CommandLine/InvocationConfiguration.cs
+++ b/src/System.CommandLine/InvocationConfiguration.cs
@@ -9,23 +9,30 @@ public class InvocationConfiguration
     private TextWriter? _output, _error;
 
     /// <summary>
-    /// Enables a default exception handler to catch any unhandled exceptions thrown during invocation. Enabled by default.
+    /// Gets or sets a value that indicates whether a default exception handler catches any unhandled exceptions thrown during invocation.
     /// </summary>
+    /// <value><see langword="true"/> if a default exception handler catches any unhandled exceptions thrown during invocation. The default is <see langword="true"/>.</value>
     public bool EnableDefaultExceptionHandler { get; set; } = true;
 
     /// <summary>
-    /// Enables signaling and handling of process termination (Ctrl+C, SIGINT, SIGTERM) via a <see cref="CancellationToken"/> 
+    /// Gets or sets a time span that enables signaling and handling of process termination (Ctrl+C, SIGINT, SIGTERM) via a <see cref="CancellationToken"/>
     /// that can be passed to a <see cref="CommandLineAction"/> during invocation.
-    /// If not provided, a default timeout of 2 seconds is enforced.
     /// </summary>
-    public TimeSpan? ProcessTerminationTimeout { get; set; } = TimeSpan.FromSeconds(2); 
+    /// <value>The default is two seconds.</value>
+    /// <remarks>
+    /// If this property is set to <see langword="null" />, the termination request isn't handled by System.CommandLine. In that case, the process is terminated immediately unless some other part of the program adds a handler.
+    /// </remarks>
+    public TimeSpan? ProcessTerminationTimeout { get; set; } = TimeSpan.FromSeconds(2);
 
     /// <summary>
-    /// The standard output. Used by Help and other facilities that write non-error information.
-    /// By default it's set to <see cref="Console.Out"/>.
-    /// For testing purposes, it can be set to a new instance of <see cref="StringWriter"/>.
-    /// If you want to disable the output, please set it to <see cref="TextWriter.Null"/>.
+    /// Gets or sets the standard output.
     /// </summary>
+    /// <value>The default is set to <see cref="Console.Out"/>.</value>
+    /// <remarks>
+    /// The standard output is used by Help and other facilities that write non-error information.
+    /// For testing purposes, it can be set to a new instance of <see cref="StringWriter"/>.
+    /// If you want to disable the output, set it to <see cref="TextWriter.Null"/>.
+    /// </remarks>
     public TextWriter Output
     {
         get => _output ??= Console.Out;
@@ -33,13 +40,15 @@ public TextWriter Output
     }
 
     /// <summary>
-    /// The standard error. Used for printing error information like parse errors.
-    /// By default it's set to <see cref="Console.Error"/>.
-    /// For testing purposes, it can be set to a new instance of <see cref="StringWriter"/>.
+    /// Gets or sets the standard error used for printing error information like parse errors.
     /// </summary>
+    /// <value>The default is set to <see cref="Console.Error"/>.</value>
+    /// <remarks>
+    /// For testing purposes, it can be set to a new instance of <see cref="StringWriter"/>.
+    /// </remarks>
     public TextWriter Error
     {
         get => _error ??= Console.Error;
         set => _error = value ?? throw new ArgumentNullException(nameof(value), "Use TextWriter.Null to disable the output");
     }
-}
\ No newline at end of file
+}
diff --git a/src/System.CommandLine/ParseResult.cs b/src/System.CommandLine/ParseResult.cs
index 666f8256ef..eb7649a65b 100644
--- a/src/System.CommandLine/ParseResult.cs
+++ b/src/System.CommandLine/ParseResult.cs
@@ -62,17 +62,17 @@ internal ParseResult(
         internal static ParseResult Empty() => new RootCommand().Parse(Array.Empty<string>());
 
         /// <summary>
-        /// A result indicating the command specified in the command line input.
+        /// Gets a result indicating the command specified in the command line input.
         /// </summary>
         public CommandResult CommandResult { get; }
 
         /// <summary>
-        /// The configuration used to produce the parse result.
+        /// Gets the configuration used to produce the parse result.
         /// </summary>
         public ParserConfiguration Configuration { get; }
 
         /// <summary>
-        /// The configuration used to specify command line runtime behavior.
+        /// Gets the configuration used to specify command line run-time behavior.
         /// </summary>
         public InvocationConfiguration InvocationConfiguration
         {
@@ -86,19 +86,19 @@ public InvocationConfiguration InvocationConfiguration
         public CommandResult RootCommandResult => _rootCommandResult;
 
         /// <summary>
-        /// Gets the parse errors found while parsing command line input.
+        /// Gets the parse errors found while parsing command-line input.
         /// </summary>
         public IReadOnlyList<ParseError> Errors { get; }
 
         /// <summary>
-        /// Gets the tokens identified while parsing command line input.
+        /// Gets the tokens identified while parsing command-line input.
         /// </summary>
         public IReadOnlyList<Token> Tokens { get; }
 
         /// <summary>
-        /// Holds the value of a complete command line input prior to splitting and tokenization, when provided.
+        /// Gets the value of a complete command line input prior to splitting and tokenization, when provided.
         /// </summary>
-        /// <remarks>This will not be set when the parser is called from <c>Program.Main</c>. It is primarily used when calculating suggestions via the <c>dotnet-suggest</c> tool.</remarks>
+        /// <remarks>This value will not be set when the parser is called from <c>Program.Main</c>. It is primarily used when calculating suggestions via the <c>dotnet-suggest</c> tool.</remarks>
         internal string? CommandLineText { get; }
 
         /// <summary>
@@ -137,9 +137,9 @@ CommandLineText is null
         /// </summary>
         /// <param name="name">The name of the Symbol for which to get a value.</param>
         /// <returns>The parsed value or a configured default.</returns>
-        /// <exception cref="InvalidOperationException">Thrown when parsing resulted in parse error(s).</exception>
-        /// <exception cref="ArgumentException">Thrown when there was no symbol defined for given name for the parsed command.</exception>
-        /// <exception cref="InvalidCastException">Thrown when parsed result can not be cast to <typeparamref name="T"/>.</exception>
+        /// <exception cref="InvalidOperationException">Parsing resulted in one or more errors.</exception>
+        /// <exception cref="ArgumentException">No symbol was defined for the given name for the parsed command.</exception>
+        /// <exception cref="InvalidCastException">The parsed result cannot be cast to <typeparamref name="T"/>.</exception>
         public T? GetValue<T>(string name)
             => RootCommandResult.GetValue<T>(name);
 
@@ -148,7 +148,7 @@ CommandLineText is null
         /// </summary>
         /// <param name="argument">The argument for which to get a value.</param>
         /// <returns>The parsed value or a configured default.</returns>
-        /// <exception cref="InvalidOperationException">Thrown when required argument was not parsed or has no default value configured.</exception>
+        /// <exception cref="InvalidOperationException">The required argument was not parsed or has no default value configured.</exception>
         public T GetRequiredValue<T>(Argument<T> argument)
             => RootCommandResult.GetRequiredValue(argument);
 
@@ -157,18 +157,18 @@ public T GetRequiredValue<T>(Argument<T> argument)
         /// </summary>
         /// <param name="option">The option for which to get a value.</param>
         /// <returns>The parsed value or a configured default.</returns>
-        /// <exception cref="InvalidOperationException">Thrown when required option was not parsed or has no default value configured.</exception>
+        /// <exception cref="InvalidOperationException">The required option was not parsed or has no default value configured.</exception>
         public T GetRequiredValue<T>(Option<T> option)
             => RootCommandResult.GetRequiredValue(option);
 
         /// <summary>
-        /// Gets the parsed or default value for the specified required symbol name, in the context of parsed command (not entire symbol tree).
+        /// Gets the parsed or default value for the specified required symbol name in the context of the parsed command (not entire symbol tree).
         /// </summary>
-        /// <param name="name">The name of the required Symbol for which to get a value.</param>
+        /// <param name="name">The name of the required symbol for which to get a value.</param>
         /// <returns>The parsed value or a configured default.</returns>
-        /// <exception cref="InvalidOperationException">Thrown when parsing resulted in parse error(s) or required symbol was not parsed or has no default value configured.</exception>
-        /// <exception cref="ArgumentException">Thrown when there was no symbol defined for given name for the parsed command.</exception>
-        /// <exception cref="InvalidCastException">Thrown when parsed result can not be cast to <typeparamref name="T"/>.</exception>
+        /// <exception cref="InvalidOperationException">Parsing resulted in one or more errors, or the required symbol was not parsed or has no default value configured.</exception>
+        /// <exception cref="ArgumentException">No symbol was defined for the given name for the parsed command.</exception>
+        /// <exception cref="InvalidCastException">The parsed result cannot be cast to <typeparamref name="T"/>.</exception>
         public T GetRequiredValue<T>(string name)
             => RootCommandResult.GetRequiredValue<T>(name);
 
@@ -218,7 +218,7 @@ public T GetRequiredValue<T>(string name)
         /// Finds a result for a symbol having the specified name anywhere in the parse tree.
         /// </summary>
         /// <param name="name">The name of the symbol for which to find a result.</param>
-        /// <returns>An symbol result if the argument was matched by the parser or has a default value; otherwise, <c>null</c>.</returns>
+        /// <returns>A symbol result if the argument was matched by the parser or has a default value; otherwise, <c>null</c>.</returns>
         public SymbolResult? GetResult(string name) =>
             _rootCommandResult.SymbolResultTree.GetResult(name);
 
@@ -270,13 +270,13 @@ static string[] OptionsWithArgumentLimitReached(CommandResult commandResult) =>
         }
 
         /// <summary>
-        /// Invokes the appropriate command handler for a parsed command line input.
+        /// Invokes the appropriate command handler for a parsed command-line input.
         /// </summary>
         /// <param name="configuration">The configuration used to define invocation behaviors.</param>
         /// <param name="cancellationToken">A token that can be used to cancel an invocation.</param>
         /// <returns>A task whose result can be used as a process exit code.</returns>
         public Task<int> InvokeAsync(
-            InvocationConfiguration? configuration = null, 
+            InvocationConfiguration? configuration = null,
             CancellationToken cancellationToken = default)
         {
             if (configuration is not null)
@@ -288,7 +288,7 @@ public Task<int> InvokeAsync(
         }
 
         /// <summary>
-        /// Invokes the appropriate command handler for a parsed command line input.
+        /// Invokes the appropriate command handler for a parsed command-line input.
         /// </summary>
         /// <param name="configuration">The configuration used to define invocation behaviors.</param>
         /// <returns>A value that can be used as a process exit code.</returns>
@@ -400,4 +400,4 @@ static bool WillAcceptAnArgument(
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/System.CommandLine/ParserConfiguration.cs b/src/System.CommandLine/ParserConfiguration.cs
index c3a8b06145..f1f221236a 100644
--- a/src/System.CommandLine/ParserConfiguration.cs
+++ b/src/System.CommandLine/ParserConfiguration.cs
@@ -11,17 +11,17 @@ namespace System.CommandLine
     public class ParserConfiguration
     {
         /// <summary>
-        /// Enables the parser to recognize and expand POSIX-style bundled options.
+        /// Gets or sets a value that indicates whether the parser recognizes and expands POSIX-style bundled options.
         /// </summary>
         /// <param name="value"><see langword="true"/> to parse POSIX bundles; otherwise, <see langword="false"/>.</param>
         /// <remarks>
         /// POSIX conventions recommend that single-character options be allowed to be specified together after a single <c>-</c> prefix. When <see cref="EnablePosixBundling"/> is set to <see langword="true"/>, the following command lines are equivalent:
-        /// 
+        ///
         /// <code>
         ///     &gt; myapp -a -b -c
         ///     &gt; myapp -abc
         /// </code>
-        /// 
+        ///
         /// If an argument is provided after an option bundle, it applies to the last option in the bundle. When <see cref="EnablePosixBundling"/> is set to <see langword="true"/>, all of the following command lines are equivalent:
         /// <code>
         ///     &gt; myapp -a -b -c arg
@@ -33,12 +33,12 @@ public class ParserConfiguration
         public bool EnablePosixBundling { get; set; } = true;
 
         /// <summary>
-        /// Response file token replacer, enabled by default.
-        /// To disable response files support, this property needs to be set to null.
+        /// Gets or sets the response file token replacer.
         /// </summary>
+        /// <value><see langword="null"/> to disable response files support. By default, the response file token replacer is enabled.</value>
         /// <remarks>
-        /// When enabled, any token prefixed with <code>@</code> can be replaced with zero or more other tokens. This is mostly commonly used to expand tokens from response files and interpolate them into a command line prior to parsing.
+        /// When enabled, any token prefixed with <c>@</c> can be replaced with zero or more other tokens. This is mostly commonly used to expand tokens from response files and interpolate them into a command line prior to parsing.
         /// </remarks>
         public TryReplaceToken? ResponseFileTokenReplacer { get; set; } = StringExtensions.TryReadResponseFile;
     }
-}
\ No newline at end of file
+}
diff --git a/src/System.CommandLine/Parsing/ArgumentResult.cs b/src/System.CommandLine/Parsing/ArgumentResult.cs
index f076baa32f..f7d091fa93 100644
--- a/src/System.CommandLine/Parsing/ArgumentResult.cs
+++ b/src/System.CommandLine/Parsing/ArgumentResult.cs
@@ -7,7 +7,7 @@
 namespace System.CommandLine.Parsing
 {
     /// <summary>
-    /// A result produced when parsing an <see cref="Argument"/>.
+    /// Represents a result produced when parsing an <see cref="Argument"/>.
     /// </summary>
     public sealed class ArgumentResult : SymbolResult
     {
@@ -23,7 +23,7 @@ internal ArgumentResult(
         }
 
         /// <summary>
-        /// The argument to which the result applies.
+        /// Gets the argument to which the result applies.
         /// </summary>
         public Argument Argument { get; }
 
@@ -37,19 +37,19 @@ internal ArgumentConversionResult GetArgumentConversionResult() =>
         /// <summary>
         /// Gets the parsed value or the default value for <see cref="Argument"/>.
         /// </summary>
-        /// <returns>The parsed value or the default value for <see cref="Argument"/></returns>
+        /// <returns>The parsed value or the default value for <see cref="Argument"/>.</returns>
         public T GetValueOrDefault<T>() =>
             (_conversionResult ??= ValidateAndConvert(useValidators: false))
                 .ConvertIfNeeded(typeof(T))
                 .GetValueOrDefault<T>();
 
         /// <summary>
-        /// Specifies the maximum number of tokens to consume for the argument. Remaining tokens are passed on and can be consumed by later arguments, or will otherwise be added to <see cref="ParseResult.UnmatchedTokens"/>
+        /// Specifies the maximum number of tokens to consume for the argument. Remaining tokens are passed on and can be consumed by later arguments, or will otherwise be added to <see cref="ParseResult.UnmatchedTokens"/>.
         /// </summary>
         /// <param name="numberOfTokens">The number of tokens to take. The rest are passed on.</param>
-        /// <exception cref="ArgumentOutOfRangeException">numberOfTokens - Value must be at least 1.</exception>
-        /// <exception cref="InvalidOperationException">Thrown if this method is called more than once.</exception>
-        /// <exception cref="NotSupportedException">Thrown if this method is called by Option-owned ArgumentResult.</exception>
+        /// <exception cref="ArgumentOutOfRangeException"><c>numberOfTokens - Value</c> must be at least 1.</exception>
+        /// <exception cref="InvalidOperationException">This method is called more than once.</exception>
+        /// <exception cref="NotSupportedException">This method is called by an Option-owned <see cref="ArgumentResult"/>.</exception>
         public void OnlyTake(int numberOfTokens)
         {
             if (numberOfTokens < 0)
@@ -200,7 +200,7 @@ private ArgumentConversionResult ValidateAndConvert(bool useValidators)
                 ArgumentConversionResult.ArgumentConversionCannotParse(
                     this,
                     Argument.ValueType,
-                    Tokens.Count > 0 
+                    Tokens.Count > 0
                         ? Tokens[0].Value
                         : ""));
 
@@ -218,7 +218,7 @@ ArgumentConversionResult ReportErrorIfNeeded(ArgumentConversionResult result)
         /// <summary>
         /// Since Option.Argument is an internal implementation detail, this ArgumentResult applies to the OptionResult in public API if the parent is an OptionResult.
         /// </summary>
-        private SymbolResult AppliesToPublicSymbolResult => 
+        private SymbolResult AppliesToPublicSymbolResult =>
             Parent is OptionResult optionResult ? optionResult : this;
     }
 }
diff --git a/src/System.CommandLine/Parsing/CommandResult.cs b/src/System.CommandLine/Parsing/CommandResult.cs
index ae4bd2922f..6fbb4ee779 100644
--- a/src/System.CommandLine/Parsing/CommandResult.cs
+++ b/src/System.CommandLine/Parsing/CommandResult.cs
@@ -7,7 +7,7 @@
 namespace System.CommandLine.Parsing
 {
     /// <summary>
-    /// A result produced when parsing a <see cref="Command" />.
+    /// Represents a result produced when parsing a <see cref="Command" />.
     /// </summary>
     public sealed class CommandResult : SymbolResult
     {
@@ -23,17 +23,17 @@ internal CommandResult(
         }
 
         /// <summary>
-        /// The command to which the result applies.
+        /// Gets the command to which the result applies.
         /// </summary>
         public Command Command { get; }
 
         /// <summary>
-        /// The token that was parsed to specify the command.
+        /// Gets the token that was parsed to specify the command.
         /// </summary>
         public Token IdentifierToken { get; }
 
         /// <summary>
-        /// Child symbol results in the parse tree.
+        /// Gets the child symbol results in the parse tree.
         /// </summary>
         public IEnumerable<SymbolResult> Children => SymbolResultTree.GetChildren(this);
 
diff --git a/src/System.CommandLine/Parsing/DirectiveResult.cs b/src/System.CommandLine/Parsing/DirectiveResult.cs
index 78ceeaf0d7..925ec3e3e6 100644
--- a/src/System.CommandLine/Parsing/DirectiveResult.cs
+++ b/src/System.CommandLine/Parsing/DirectiveResult.cs
@@ -3,7 +3,7 @@
 namespace System.CommandLine.Parsing
 {
     /// <summary>
-    /// A result produced when parsing an <see cref="Directive"/>.
+    /// Represents a result produced when parsing a <see cref="Directive"/>.
     /// </summary>
     public sealed class DirectiveResult : SymbolResult
     {
@@ -17,18 +17,18 @@ internal DirectiveResult(Directive directive, Token token, SymbolResultTree symb
         }
 
         /// <summary>
-        /// Parsed values of [name:value] directive(s).
+        /// Parsed values of <c>[name:value]</c> directives.
         /// </summary>
-        /// <remarks>Can be empty for [name] directives.</remarks>
+        /// <remarks>Can be empty for <c>[name]</c> directives.</remarks>
         public IReadOnlyList<string> Values => _values is null ? Array.Empty<string>() : _values;
 
         /// <summary>
-        /// The directive to which the result applies.
+        /// Gets the directive to which the result applies.
         /// </summary>
         public Directive Directive { get; }
 
         /// <summary>
-        /// The token that was parsed to specify the directive.
+        /// Gets the token that was parsed to specify the directive.
         /// </summary>
         public Token Token { get; }
 
diff --git a/src/System.CommandLine/Parsing/OptionResult.cs b/src/System.CommandLine/Parsing/OptionResult.cs
index c673a90458..7aa91c0fc3 100644
--- a/src/System.CommandLine/Parsing/OptionResult.cs
+++ b/src/System.CommandLine/Parsing/OptionResult.cs
@@ -7,7 +7,7 @@
 namespace System.CommandLine.Parsing
 {
     /// <summary>
-    /// A result produced when parsing an <see cref="Option" />.
+    /// Represents a result produced when parsing an <see cref="Option" />.
     /// </summary>
     public sealed class OptionResult : SymbolResult
     {
@@ -25,24 +25,24 @@ internal OptionResult(
         }
 
         /// <summary>
-        /// The option to which the result applies.
+        /// Gets the option to which the result applies.
         /// </summary>
         public Option Option { get; }
 
         /// <summary>
-        /// Indicates whether the result was created implicitly and not due to the option being specified on the command line.
+        /// Gets a value that indicates whether the result was created implicitly and not due to the option being specified on the command line.
         /// </summary>
         /// <remarks>Implicit results commonly result from options having a default value.</remarks>
         public bool Implicit => IdentifierToken is null || IdentifierToken.Implicit;
 
         /// <summary>
-        /// The token that was parsed to specify the option.
+        /// Gets the token that was parsed to specify the option.
         /// </summary>
         /// <remarks>An identifier token is a token that matches either the option's name or one of its aliases.</remarks>
         public Token? IdentifierToken { get; }
 
         /// <summary>
-        /// The number of occurrences of an identifier token matching the option.
+        /// Gets the number of occurrences of an identifier token matching the option.
         /// </summary>
         public int IdentifierTokenCount { get; internal set; }
 
diff --git a/src/System.CommandLine/Parsing/SymbolResult.cs b/src/System.CommandLine/Parsing/SymbolResult.cs
index 18df4af83e..6d275887c6 100644
--- a/src/System.CommandLine/Parsing/SymbolResult.cs
+++ b/src/System.CommandLine/Parsing/SymbolResult.cs
@@ -6,7 +6,7 @@
 namespace System.CommandLine.Parsing
 {
     /// <summary>
-    /// A result produced during parsing for a specific symbol.
+    /// Represents a result produced during parsing for a specific symbol.
     /// </summary>
     public abstract class SymbolResult
     {
@@ -20,7 +20,7 @@ private protected SymbolResult(SymbolResultTree symbolResultTree, SymbolResult?
         }
 
         /// <summary>
-        /// The parse errors associated with this symbol result.
+        /// Gets the parse errors associated with this symbol result.
         /// </summary>
         public IEnumerable<ParseError> Errors
         {
@@ -45,21 +45,21 @@ public IEnumerable<ParseError> Errors
         }
 
         /// <summary>
-        /// The parent symbol result in the parse tree.
+        /// Gets the parent symbol result in the parse tree.
         /// </summary>
         public SymbolResult? Parent { get; }
 
         /// <summary>
-        /// The list of tokens associated with this symbol result during parsing.
+        /// Gets the list of tokens associated with this symbol result during parsing.
         /// </summary>
         public IReadOnlyList<Token> Tokens => _tokens is not null ? _tokens : Array.Empty<Token>();
 
         internal void AddToken(Token token) => (_tokens ??= new()).Add(token);
 
         /// <summary>
-        /// Adds an error message for this symbol result to it's parse tree.
+        /// Adds an error message for this symbol result to its parse tree.
         /// </summary>
-        /// <remarks>Setting an error will cause the parser to indicate an error for the user and prevent invocation of the command line.</remarks>
+        /// <remarks>Setting an error causes the parser to indicate an error for the user and prevents invocation of the command line.</remarks>
         public virtual void AddError(string errorMessage) => SymbolResultTree.AddError(new ParseError(errorMessage, this));
 
         /// <summary>
@@ -73,7 +73,7 @@ public IEnumerable<ParseError> Errors
         /// Finds a result for the specific command anywhere in the parse tree, including parent and child symbol results.
         /// </summary>
         /// <param name="command">The command for which to find a result.</param>
-        /// <returns>An command result if the command was matched by the parser; otherwise, <c>null</c>.</returns>
+        /// <returns>A command result if the command was matched by the parser; otherwise, <c>null</c>.</returns>
         public CommandResult? GetResult(Command command) => SymbolResultTree.GetResult(command);
 
         /// <summary>
@@ -87,7 +87,7 @@ public IEnumerable<ParseError> Errors
         /// Finds a result for the specific directive anywhere in the parse tree.
         /// </summary>
         /// <param name="directive">The directive for which to find a result.</param>
-        /// <returns>A directive result if the directive was matched by the parser, <c>null</c> otherwise.</returns>
+        /// <returns>A directive result if the directive was matched by the parser; otherwise, <c>null</c>.</returns>
         public DirectiveResult? GetResult(Directive directive) => SymbolResultTree.GetResult(directive);
 
         /// <summary>
@@ -98,7 +98,7 @@ public IEnumerable<ParseError> Errors
         /// A <see cref="SymbolResult" /> if the <see cref="Symbol" /> was matched by the parser or has a default value;
         /// otherwise, <see langword="null" />.
         /// </returns>
-        public SymbolResult? GetResult(string name) => 
+        public SymbolResult? GetResult(string name) =>
             SymbolResultTree.GetResult(name);
 
         /// <inheritdoc cref="ParseResult.GetValue{T}(Argument{T})"/>
diff --git a/src/System.CommandLine/System.Runtime.CompilerServices/Range.cs b/src/System.CommandLine/System.Runtime.CompilerServices/Range.cs
index 01342202b7..617fd90d8e 100644
--- a/src/System.CommandLine/System.Runtime.CompilerServices/Range.cs
+++ b/src/System.CommandLine/System.Runtime.CompilerServices/Range.cs
@@ -8,11 +8,11 @@
 
 namespace System
 {
-    /// <summary>Represent a type can be used to index a collection either from the start or the end.</summary>
+    /// <summary>Represents a type that can be used to index a collection either from the beginning or the end.</summary>
     /// <remarks>
-    /// Index is used by the C# compiler to support the new index syntax
-    /// <code>
-    /// int[] someArray = new int[5] { 1, 2, 3, 4, 5 } ;
+    /// <see cref="Index" /> is used by the C# compiler to support the <c>>^</c> or ["index from end" operator](https://learn.microsoft.com/dotnet/csharp/language-reference/operators/member-access-operators#index-from-end-operator-):
+    /// <code language="csharp">
+    /// int[] someArray = new int[5] { 1, 2, 3, 4, 5 };
     /// int lastElement = someArray[^1]; // lastElement = 5
     /// </code>
     /// </remarks>
@@ -20,11 +20,11 @@ namespace System
     {
         private readonly int _value;
 
-        /// <summary>Construct an Index using a value and indicating if the index is from the start or from the end.</summary>
-        /// <param name="value">The index value. it has to be zero or positive number.</param>
-        /// <param name="fromEnd">Indicating if the index is from the start or from the end.</param>
+        /// <summary>Initializes a new <see cref="Index" /> with a specified index position and a value that indicates if the index is from the beginning or the end of a collection.</summary>
+        /// <param name="value">The index value. It has to be greater then or equal to zero.</param>
+        /// <param name="fromEnd"><see langword = "true" /> to index from the end of the collection, or <see langword = "false" /> to index from the beginning of the collection.</param>
         /// <remarks>
-        /// If the Index constructed from the end, index value 1 means pointing at the last element and index value 0 means pointing at beyond last element.
+        /// If the <see cref="Index" /> is constructed from the end, an index value of 1 points to the last element, and an index value of 0 points beyond the last element.
         /// </remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Index(int value, bool fromEnd = false)
@@ -46,14 +46,17 @@ private Index(int value)
             _value = value;
         }
 
-        /// <summary>Create an Index pointing at first element.</summary>
+        /// <summary>Gets an <see cref="Index" /> that points to the first element of a collection.</summary>
+        /// <value>An instance that points to the first element of a collection.</value>
         public static Index Start => new Index(0);
 
-        /// <summary>Create an Index pointing at beyond last element.</summary>
+        /// <summary>Gets an <see cref="Index" /> that points beyond the last element.</summary>
+        /// <value>An index that points beyond the last element.</value>
         public static Index End => new Index(~0);
 
-        /// <summary>Create an Index from the start at the position indicated by the value.</summary>
-        /// <param name="value">The index value from the start.</param>
+        /// <summary>Creates an <see cref="Index" /> from the specified index at the start of a collection.</summary>
+        /// <param name="value">The index position from the start of a collection.</param>
+        /// <returns>The index value.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Index FromStart(int value)
         {
@@ -65,8 +68,8 @@ public static Index FromStart(int value)
             return new Index(value);
         }
 
-        /// <summary>Create an Index from the end at the position indicated by the value.</summary>
-        /// <param name="value">The index value from the end.</param>
+        /// <summary>Creates an <see cref="Index" /> from the end of a collection at a specified index position.</summary>
+        /// <param name="value">The index value from the end of a collection.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Index FromEnd(int value)
         {
@@ -78,7 +81,8 @@ public static Index FromEnd(int value)
             return new Index(~value);
         }
 
-        /// <summary>Returns the index value.</summary>
+        /// <summary>Gets the index value.</summary>
+        /// <value>The index value.</value>
         public int Value
         {
             get
@@ -94,18 +98,18 @@ public int Value
             }
         }
 
-        /// <summary>Indicates whether the index is from the start or the end.</summary>
+        /// <summary>Gets a value that indicates whether the index is from the start or the end.</summary>
+        /// <value><see langword = "true" /> if the Index is from the end; otherwise, <see langword = "false" />.</value>
         public bool IsFromEnd => _value < 0;
 
-        /// <summary>Calculate the offset from the start using the giving collection length.</summary>
-        /// <param name="length">The length of the collection that the Index will be used with. length has to be a positive value</param>
+        /// <summary>Calculates the offset from the start of the collection using the specified collection length.</summary>
+        /// <param name="length">The length of the collection that the Index will be used with. Must be a positive value.</param>
+        /// <returns>The offset.</returns>
         /// <remarks>
-        /// For performance reason, we don't validate the input length parameter and the returned offset value against negative values.
-        /// we don't validate either the returned offset is greater than the input length.
-        /// It is expected Index will be used with collections which always have non negative length/count. If the returned offset is negative and
-        /// then used to index a collection will get out of range exception which will be same affect as the validation.
+        /// For performance reasons, this method does not validate if <c>length</c> or the returned value are negative. It also doesn't validate if the returned value is greater than <c>length</c>.
+        /// Collections aren't expected to have a negative length/count. If this method's returned offset is negative and is then used to index a collection, the runtime will throw <see cref="ArgumentOutOfRangeException" />, which will have the same effect as validation.
         /// </remarks>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public int GetOffset(int length)
         {
             var offset = _value;
@@ -120,21 +124,27 @@ public int GetOffset(int length)
             return offset;
         }
 
-        /// <summary>Indicates whether the current Index object is equal to another object of the same type.</summary>
-        /// <param name="value">An object to compare with this object</param>
+        /// <summary>Indicates whether the current Index object is equal to a specified object.</summary>
+        /// <param name="value">An object to compare with this instance.</param>
+        /// <returns><see langword="true" /> if <paramref name="value" /> is of type <see cref="Index" /> and is equal to the current instance; otherwise, <see langword="false" />.</returns>
         public override bool Equals(object? value) => value is Index && _value == ((Index)value)._value;
 
-        /// <summary>Indicates whether the current Index object is equal to another Index object.</summary>
-        /// <param name="other">An object to compare with this object</param>
+        /// <summary>Returns a value that indicates whether the current object is equal to another <see cref="Index" /> object.</summary>
+        /// <param name="other">The object to compare with this instance.</param>
+        /// <returns><see langword="true" /> if the current Index object is equal to <paramref name="other" />; otherwise, <see langword="false" />.</returns>
         public bool Equals(Index other) => _value == other._value;
 
         /// <summary>Returns the hash code for this instance.</summary>
+        /// <returns>The hash code.</returns>
         public override int GetHashCode() => _value;
 
-        /// <summary>Converts integer number to an Index.</summary>
+        /// <summary>Converts an integer number to an <see cref="Index" />.</summary>
+        /// <param name="value">The integer to convert.</param>
+        /// <returns>An index representing the integer.</returns>
         public static implicit operator Index(int value) => FromStart(value);
 
-        /// <summary>Converts the value of the current Index object to its equivalent string representation.</summary>
+        /// <summary>Returns the string representation of the current <see cref="Index" /> instance.</summary>
+        /// <returns>The string representation of the <see cref="Index" />.</returns>
         public override string ToString()
         {
             if (IsFromEnd)
@@ -144,10 +154,10 @@ public override string ToString()
         }
     }
 
-    /// <summary>Represent a range has start and end indexes.</summary>
+    /// <summary>Represents a range that has start and end indexes.</summary>
     /// <remarks>
-    /// Range is used by the C# compiler to support the range syntax.
-    /// <code>
+    /// <see cref="Range" /> is used by the C# compiler to support the range syntax:
+    /// <code language="csharp">
     /// int[] someArray = new int[5] { 1, 2, 3, 4, 5 };
     /// int[] subArray1 = someArray[0..2]; // { 1, 2 }
     /// int[] subArray2 = someArray[1..^0]; // { 2, 3, 4, 5 }
@@ -155,59 +165,69 @@ public override string ToString()
     /// </remarks>
     internal readonly struct Range : IEquatable<Range>
     {
-        /// <summary>Represent the inclusive start index of the Range.</summary>
+        /// <summary>Gets the inclusive start index of the <see cref="Range" />.</summary>
+        /// <value>The inclusive start index of the range.</value>
         public Index Start { get; }
 
-        /// <summary>Represent the exclusive end index of the Range.</summary>
+        /// <summary>Gets an <see cref="Index" /> that represents the exclusive end index of the range.</summary>
+        /// <value>The end index of the range.</value>
         public Index End { get; }
 
-        /// <summary>Construct a Range object using the start and end indexes.</summary>
-        /// <param name="start">Represent the inclusive start index of the range.</param>
-        /// <param name="end">Represent the exclusive end index of the range.</param>
+        /// <summary>Instantiates a new <see cref="Range" /> instance with the specified starting and ending indexes.</summary>
+        /// <param name="start">The inclusive start index of the range.</param>
+        /// <param name="end">The exclusive end index of the range.</param>
         public Range(Index start, Index end)
         {
             Start = start;
             End = end;
         }
 
-        /// <summary>Indicates whether the current Range object is equal to another object of the same type.</summary>
-        /// <param name="value">An object to compare with this object</param>
+        /// <summary>Returns a value that indicates whether the current instance is equal to a specified object.</summary>
+        /// <param name="value">An object to compare with this <see cref="Range" /> object.</param>
+        /// <returns><see langword="true" /> if <paramref name="value" /> is of type <see cref="Range" /> and is equal to the current instance; otherwise, <see langword="false" />.</returns>
         public override bool Equals(object? value) =>
             value is Range r &&
             r.Start.Equals(Start) &&
             r.End.Equals(End);
 
-        /// <summary>Indicates whether the current Range object is equal to another Range object.</summary>
-        /// <param name="other">An object to compare with this object</param>
+        /// <summary>Returns a value that indicates whether the current instance is equal to another <see cref="Range" /> object.</summary>
+        /// <param name="other">A <see cref="Range" /> object to compare with this <see cref="Range" /> object.</param>
+        /// <see langword="true" /> if the current instance is equal to <paramref name="other" />; otherwise, <see langword="false" />.
         public bool Equals(Range other) => other.Start.Equals(Start) && other.End.Equals(End);
 
         /// <summary>Returns the hash code for this instance.</summary>
+        /// <returns>The hash code.</returns>
         public override int GetHashCode()
         {
             return Start.GetHashCode() * 31 + End.GetHashCode();
         }
 
-        /// <summary>Converts the value of the current Range object to its equivalent string representation.</summary>
+        /// <summary>Returns the string representation of the current <see cref="Range" /> object.</summary>
+        /// <returns>The string representation of the range.</returns>
         public override string ToString()
         {
             return Start + ".." + End;
         }
 
-        /// <summary>Create a Range object starting from start index to the end of the collection.</summary>
+        /// <summary>Returns a new <see cref="Range" /> instance starting from a specified start index to the end of the collection.</summary>
+        /// <param name="start">The position of the first element from which the Range will be created.</param>
+        /// <returns>A range from <paramref name="start" /> to the end of the collection.</returns>
         public static Range StartAt(Index start) => new Range(start, Index.End);
 
-        /// <summary>Create a Range object starting from first element in the collection to the end Index.</summary>
+        /// <summary>Creates a <see cref="Range" /> object starting from the first element in the collection to a specified end index.</summary>
+        /// <param name="end">The position of the last element up to which the <see cref="Range" /> object will be created.</param>
+        /// <returns>A range that starts from the first element to <paramref name="end" />.</returns>
         public static Range EndAt(Index end) => new Range(Index.Start, end);
 
-        /// <summary>Create a Range object starting from first element to the end.</summary>
+        /// <summary>Gets a <see cref="Range" /> object that starts from the first element to the end.</summary>
+        /// <value>A range from the start to the end.</value>
         public static Range All => new Range(Index.Start, Index.End);
 
-        /// <summary>Calculate the start offset and length of range object using a collection length.</summary>
-        /// <param name="length">The length of the collection that the range will be used with. length has to be a positive value.</param>
+        /// <summary>Calculates the start offset and length of the range object using a collection length.</summary>
+        /// <param name="length">A positive integer that represents the length of the collection that the range will be used with.</param>
+        /// <returns>The start offset and length of the range.</returns>
         /// <remarks>
-        /// For performance reason, we don't validate the input length parameter against negative values.
-        /// It is expected Range will be used with collections which always have non negative length/count.
-        /// We validate the range is inside the length scope though.
+        /// For performance reasons, this method doesn't validate <paramref name="length" /> to ensure that it is not negative. It does ensure that <paramref name="length" /> is within the current <see cref="Range" /> instance.
         /// </remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public (int Offset, int Length) GetOffsetAndLength(int length)
diff --git a/src/System.CommandLine/VersionOption.cs b/src/System.CommandLine/VersionOption.cs
index dfcf51f86a..cc4795e8c9 100644
--- a/src/System.CommandLine/VersionOption.cs
+++ b/src/System.CommandLine/VersionOption.cs
@@ -9,22 +9,28 @@
 namespace System.CommandLine
 {
     /// <summary>
-    /// A standard option that indicates that version information should be displayed for the app.
+    /// Represents a standard option that indicates that version information should be displayed for the app.
     /// </summary>
     public sealed class VersionOption : Option
     {
         private CommandLineAction? _action;
 
         /// <summary>
-        /// When added to a <see cref="Command"/>, it enables the use of a <c>--version</c> option, which when specified in command line input will short circuit normal command handling and instead write out version information before exiting.
+        /// Initializes a new instance of <see cref="VersionOption" />.
         /// </summary>
+        /// <remarks>
+        /// When added to a <see cref="Command"/>, it enables the use of a <c>--version</c> option, which, when specified in command line input, short circuits normal command handling and instead writes out version information before exiting.
+        /// </remarks>
         public VersionOption() : this("--version")
         {
         }
 
         /// <summary>
-        /// When added to a <see cref="Command"/>, it enables the use of a provided option name and aliases, which when specified in command line input will short circuit normal command handling and instead write out version information before exiting.
+        /// Initializes a new instance of <see cref="VersionOption" />.
         /// </summary>
+        /// <remarks>
+        /// When added to a <see cref="Command"/>, it enables the use of a provided option name and aliases, which, when specified in command line input, short circuits normal command handling and instead writes out version information before exiting.
+        /// </remarks>
         public VersionOption(string name, params string[] aliases)
             : base(name, aliases)
         {
@@ -88,4 +94,4 @@ private static string GetExecutableVersion()
             }
         }
     }
-}
\ No newline at end of file
+}