diff --git a/src/Cli/Microsoft.DotNet.Cli.CommandLine/ForwardedOptionExtensions.cs b/src/Cli/Microsoft.DotNet.Cli.CommandLine/ForwardedOptionExtensions.cs
index 040f4595f7b8..b4a3e9aeb819 100644
--- a/src/Cli/Microsoft.DotNet.Cli.CommandLine/ForwardedOptionExtensions.cs
+++ b/src/Cli/Microsoft.DotNet.Cli.CommandLine/ForwardedOptionExtensions.cs
@@ -177,12 +177,16 @@ public Option<IEnumerable<string>> ForwardAsManyArgumentsEachPrefixedByOption(st
         /// <summary>
         /// Calls the forwarding functions for all options that have declared a forwarding function (via <see cref="ForwardedOptionExtensions"/>'s extension members) in the provided <see cref="ParseResult"/>.
         /// </summary>
-        /// <param name="parseResult"></param>
         /// <param name="command">If not provided, uses the <see cref="ParseResult.CommandResult" />'s <see cref="CommandResult.Command"/>.</param>
-        /// <returns></returns>
-        public IEnumerable<string> OptionValuesToBeForwarded(Command? command = null) =>
-            (command ?? parseResult.CommandResult.Command)
-                .Options
+        public IEnumerable<string> OptionValuesToBeForwarded(Command? command = null)
+            => parseResult.OptionValuesToBeForwarded((command ?? parseResult.CommandResult.Command).Options);
+
+        /// <summary>
+        /// Calls the forwarding functions for all options that have declared a forwarding function (via <see cref="ForwardedOptionExtensions"/>'s extension members) in the provided <see cref="ParseResult"/>.
+        /// </summary>
+        /// <param name="command">If not provided, uses the <see cref="ParseResult.CommandResult" />'s <see cref="CommandResult.Command"/>.</param>
+        public IEnumerable<string> OptionValuesToBeForwarded(IEnumerable<Option> options)
+            => options
                 .Select(o => o.ForwardingFunction)
                 .SelectMany(f => f is not null ? f(parseResult) : []);
 
@@ -191,9 +195,6 @@ public IEnumerable<string> OptionValuesToBeForwarded(Command? command = null) =>
         /// invokes its forwarding function (if any) and returns the result. If no option with that name is found, or if the option
         /// has no forwarding function, returns an empty enumeration.
         /// </summary>
-        /// <param name="command"></param>
-        /// <param name="alias"></param>
-        /// <returns></returns>
         public IEnumerable<string> ForwardedOptionValues(Command command, string alias)
         {
             var func = command.Options?
diff --git a/src/Cli/dotnet/CommandFactory/CommandResolution/ProjectToolsCommandResolver.cs b/src/Cli/dotnet/CommandFactory/CommandResolution/ProjectToolsCommandResolver.cs
index aa844850e316..99886ae33f91 100644
--- a/src/Cli/dotnet/CommandFactory/CommandResolution/ProjectToolsCommandResolver.cs
+++ b/src/Cli/dotnet/CommandFactory/CommandResolution/ProjectToolsCommandResolver.cs
@@ -385,7 +385,7 @@ internal void GenerateDepsJsonFile(
         string? stdOut;
         string? stdErr;
 
-        var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments([..args], CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, BuildCommandParser.TargetOption, BuildCommandParser.VerbosityOption, BuildCommandParser.NoLogoOption);
+        var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments([..args], CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, BuildCommandDefinition.TargetOption, BuildCommandDefinition.VerbosityOption, BuildCommandDefinition.NoLogoOption);
         var forwardingAppWithoutLogging = new MSBuildForwardingAppWithoutLogging(msbuildArgs, msBuildExePath);
         if (forwardingAppWithoutLogging.ExecuteMSBuildOutOfProc)
         {
diff --git a/src/Cli/dotnet/CommandLineInfo.cs b/src/Cli/dotnet/CommandLineInfo.cs
index 84f0b4ba1eff..497d677f57ae 100644
--- a/src/Cli/dotnet/CommandLineInfo.cs
+++ b/src/Cli/dotnet/CommandLineInfo.cs
@@ -24,7 +24,7 @@ public static void PrintInfo()
         Reporter.Output.WriteLine($"{LocalizableStrings.DotNetSdkInfoLabel}");
         Reporter.Output.WriteLine($" Version:           {Product.Version}");
         Reporter.Output.WriteLine($" Commit:            {commitSha}");
-        Reporter.Output.WriteLine($" Workload version:  {WorkloadCommandParser.GetWorkloadsVersion()}");
+        Reporter.Output.WriteLine($" Workload version:  {WorkloadCommandDefinition.GetWorkloadsVersion()}");
         Reporter.Output.WriteLine($" MSBuild version:   {MSBuildForwardingAppWithoutLogging.MSBuildVersion.ToString()}");
         Reporter.Output.WriteLine();
         Reporter.Output.WriteLine($"{LocalizableStrings.DotNetRuntimeInfoLabel}");
@@ -40,7 +40,7 @@ private static void PrintWorkloadsInfo()
     {
         Reporter.Output.WriteLine();
         Reporter.Output.WriteLine($"{LocalizableStrings.DotnetWorkloadInfoLabel}");
-        WorkloadCommandParser.ShowWorkloadsInfo(showVersion: false);
+        WorkloadCommandDefinition.ShowWorkloadsInfo(showVersion: false);
     }
 
     private static string GetDisplayRid(DotnetVersionFile versionFile)
diff --git a/src/Cli/dotnet/Commands/Build/BuildCommand.cs b/src/Cli/dotnet/Commands/Build/BuildCommand.cs
index 264abdad7d80..9b6dabdb020a 100644
--- a/src/Cli/dotnet/Commands/Build/BuildCommand.cs
+++ b/src/Cli/dotnet/Commands/Build/BuildCommand.cs
@@ -22,14 +22,14 @@ public static CommandBase FromParseResult(ParseResult parseResult, string? msbui
         parseResult.ShowHelpOrErrorIfAppropriate();
 
         CommonOptions.ValidateSelfContainedOptions(
-            parseResult.HasOption(BuildCommandParser.SelfContainedOption),
-            parseResult.HasOption(BuildCommandParser.NoSelfContainedOption));
+            parseResult.HasOption(BuildCommandDefinition.SelfContainedOption),
+            parseResult.HasOption(BuildCommandDefinition.NoSelfContainedOption));
 
-        bool noRestore = parseResult.HasOption(BuildCommandParser.NoRestoreOption);
+        bool noRestore = parseResult.HasOption(BuildCommandDefinition.NoRestoreOption);
 
         return CommandFactory.CreateVirtualOrPhysicalCommand(
             BuildCommandParser.GetCommand(),
-            BuildCommandParser.SlnOrProjectOrFileArgument,
+            BuildCommandDefinition.SlnOrProjectOrFileArgument,
             (msbuildArgs, appFilePath) => new VirtualProjectBuildingCommand(
                 entryPointFileFullPath: Path.GetFullPath(appFilePath),
                 msbuildArgs: msbuildArgs
@@ -43,7 +43,7 @@ public static CommandBase FromParseResult(ParseResult parseResult, string? msbui
                 noRestore: noRestore,
                 msbuildPath: msbuildPath
             ),
-            [CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, BuildCommandParser.TargetOption, BuildCommandParser.VerbosityOption, BuildCommandParser.NoLogoOption],
+            [CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, BuildCommandDefinition.TargetOption, BuildCommandDefinition.VerbosityOption, BuildCommandDefinition.NoLogoOption],
             parseResult,
             msbuildPath
         );
diff --git a/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs b/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
new file mode 100644
index 000000000000..e4c3b40b3628
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Build/BuildCommandDefinition.cs
@@ -0,0 +1,95 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Restore;
+using Microsoft.DotNet.Cli.Extensions;
+
+namespace Microsoft.DotNet.Cli.Commands.Build;
+
+internal static class BuildCommandDefinition
+{
+    public static readonly string DocsLink = "https://aka.ms/dotnet-build";
+
+    public static readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
+    {
+        Description = CliStrings.SolutionOrProjectOrFileArgumentDescription,
+        Arity = ArgumentArity.ZeroOrMore
+    };
+
+    public static readonly Option<string> OutputOption = new Option<string>("--output", "-o")
+    {
+        Description = CliCommandStrings.BuildOutputOptionDescription,
+        HelpName = CliCommandStrings.OutputOptionName
+    }.ForwardAsOutputPath("OutputPath");
+
+    public static readonly Option<bool> NoIncrementalOption = new Option<bool>("--no-incremental")
+    {
+        Description = CliCommandStrings.NoIncrementalOptionDescription,
+        Arity = ArgumentArity.Zero
+    }.ForwardAs("--target:Rebuild");
+
+    public static readonly Option<bool> NoDependenciesOption = new Option<bool>("--no-dependencies")
+    {
+        Description = CliCommandStrings.NoDependenciesOptionDescription,
+        Arity = ArgumentArity.Zero
+    }.ForwardAs("--property:BuildProjectReferences=false");
+
+    public static readonly Option<bool> NoLogoOption = CommonOptions.NoLogoOption();
+
+    public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+
+    public static readonly Option<bool> SelfContainedOption = CommonOptions.SelfContainedOption;
+
+    public static readonly Option<bool> NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
+
+    public static readonly Option<string> RuntimeOption = CommonOptions.RuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription);
+
+    public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(CliCommandStrings.BuildFrameworkOptionDescription);
+
+    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(CliCommandStrings.BuildConfigurationOptionDescription);
+
+    /// <summary>
+    /// Build actually means 'run the default Target' generally in MSBuild
+    /// </summary>
+    public static readonly Option<string[]?> TargetOption = CommonOptions.MSBuildTargetOption();
+
+    public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.VerbosityOption();
+
+    public static Command Create()
+    {
+        Command command = new("build", CliCommandStrings.BuildAppFullName)
+        {
+            DocsLink = DocsLink
+        };
+
+        command.Arguments.Add(SlnOrProjectOrFileArgument);
+        RestoreCommandDefinition.AddImplicitRestoreOptions(command, includeRuntimeOption: false, includeNoDependenciesOption: false);
+        command.Options.Add(FrameworkOption);
+        command.Options.Add(ConfigurationOption);
+        command.Options.Add(RuntimeOption);
+        command.Options.Add(CommonOptions.VersionSuffixOption);
+        command.Options.Add(NoRestoreOption);
+        command.Options.Add(CommonOptions.InteractiveMsBuildForwardOption);
+        command.Options.Add(VerbosityOption);
+        command.Options.Add(CommonOptions.DebugOption);
+        command.Options.Add(OutputOption);
+        command.Options.Add(CommonOptions.ArtifactsPathOption);
+        command.Options.Add(NoIncrementalOption);
+        command.Options.Add(NoDependenciesOption);
+        command.Options.Add(NoLogoOption);
+        command.Options.Add(SelfContainedOption);
+        command.Options.Add(NoSelfContainedOption);
+        command.Options.Add(CommonOptions.ArchitectureOption);
+        command.Options.Add(CommonOptions.OperatingSystemOption);
+        command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(TargetOption);
+        command.Options.Add(CommonOptions.GetPropertyOption);
+        command.Options.Add(CommonOptions.GetItemOption);
+        command.Options.Add(CommonOptions.GetTargetResultOption);
+        command.Options.Add(CommonOptions.GetResultOutputFileOption);
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs b/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs
index be2e52c45263..7759cdf1684c 100644
--- a/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Build/BuildCommandParser.cs
@@ -2,103 +2,21 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
-using Microsoft.DotNet.Cli.CommandLine;
-using Microsoft.DotNet.Cli.Commands.Restore;
-using Microsoft.DotNet.Cli.Extensions;
 
 namespace Microsoft.DotNet.Cli.Commands.Build;
 
 internal static class BuildCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-build";
-
-    public static readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
-    {
-        Description = CliStrings.SolutionOrProjectOrFileArgumentDescription,
-        Arity = ArgumentArity.ZeroOrMore
-    };
-
-    public static readonly Option<string> OutputOption = new Option<string>("--output", "-o")
-    {
-        Description = CliCommandStrings.BuildOutputOptionDescription,
-        HelpName = CliCommandStrings.OutputOptionName
-    }.ForwardAsOutputPath("OutputPath");
-
-    public static readonly Option<bool> NoIncrementalOption = new Option<bool>("--no-incremental")
-    {
-        Description = CliCommandStrings.NoIncrementalOptionDescription,
-        Arity = ArgumentArity.Zero
-    }.ForwardAs("--target:Rebuild");
-
-    public static readonly Option<bool> NoDependenciesOption = new Option<bool>("--no-dependencies")
-    {
-        Description = CliCommandStrings.NoDependenciesOptionDescription,
-        Arity = ArgumentArity.Zero
-    }.ForwardAs("--property:BuildProjectReferences=false");
-
-    public static readonly Option<bool> NoLogoOption = CommonOptions.NoLogoOption();
-
-    public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
-
-    public static readonly Option<bool> SelfContainedOption = CommonOptions.SelfContainedOption;
-
-    public static readonly Option<bool> NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
-
-    public static readonly Option<string> RuntimeOption = CommonOptions.RuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription);
-
-    public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(CliCommandStrings.BuildFrameworkOptionDescription);
-
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(CliCommandStrings.BuildConfigurationOptionDescription);
-
-    /// <summary>
-    /// Build actually means 'run the default Target' generally in MSBuild
-    /// </summary>
-    public static readonly Option<string[]?> TargetOption = CommonOptions.MSBuildTargetOption();
-
-    public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.VerbosityOption();
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = SetAction(BuildCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command SetAction(Command command)
     {
-        Command command = new("build", CliCommandStrings.BuildAppFullName)
-        {
-            DocsLink = DocsLink
-        };
-
-        command.Arguments.Add(SlnOrProjectOrFileArgument);
-        RestoreCommandParser.AddImplicitRestoreOptions(command, includeRuntimeOption: false, includeNoDependenciesOption: false);
-        command.Options.Add(FrameworkOption);
-        command.Options.Add(ConfigurationOption);
-        command.Options.Add(RuntimeOption);
-        command.Options.Add(CommonOptions.VersionSuffixOption);
-        command.Options.Add(NoRestoreOption);
-        command.Options.Add(CommonOptions.InteractiveMsBuildForwardOption);
-        command.Options.Add(VerbosityOption);
-        command.Options.Add(CommonOptions.DebugOption);
-        command.Options.Add(OutputOption);
-        command.Options.Add(CommonOptions.ArtifactsPathOption);
-        command.Options.Add(NoIncrementalOption);
-        command.Options.Add(NoDependenciesOption);
-        command.Options.Add(NoLogoOption);
-        command.Options.Add(SelfContainedOption);
-        command.Options.Add(NoSelfContainedOption);
-        command.Options.Add(CommonOptions.ArchitectureOption);
-        command.Options.Add(CommonOptions.OperatingSystemOption);
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
-        command.Options.Add(TargetOption);
-        command.Options.Add(CommonOptions.GetPropertyOption);
-        command.Options.Add(CommonOptions.GetItemOption);
-        command.Options.Add(CommonOptions.GetTargetResultOption);
-        command.Options.Add(CommonOptions.GetResultOutputFileOption);
-
         command.SetAction(BuildCommand.Run);
-
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/BuildServer/BuildServerCommandDefinition.cs b/src/Cli/dotnet/Commands/BuildServer/BuildServerCommandDefinition.cs
new file mode 100644
index 000000000000..9c7726f139bf
--- /dev/null
+++ b/src/Cli/dotnet/Commands/BuildServer/BuildServerCommandDefinition.cs
@@ -0,0 +1,27 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.Commands.BuildServer.Shutdown;
+using Microsoft.DotNet.Cli.CommandLine;
+using Microsoft.DotNet.Cli.Extensions;
+
+namespace Microsoft.DotNet.Cli.Commands.BuildServer;
+
+internal static class BuildServerCommandDefinition
+{
+    public const string Name = "build-server";
+    public static readonly string DocsLink = "https://aka.ms/dotnet-build-server";
+
+    public static Command Create()
+    {
+        var command = new Command(Name, CliCommandStrings.BuildServerCommandDescription)
+        {
+            DocsLink = DocsLink
+        };
+
+        command.Subcommands.Add(BuildServerShutdownCommandDefinition.Create());
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/BuildServer/BuildServerCommandParser.cs b/src/Cli/dotnet/Commands/BuildServer/BuildServerCommandParser.cs
index 468e60ad4fe1..064d7bb4afea 100644
--- a/src/Cli/dotnet/Commands/BuildServer/BuildServerCommandParser.cs
+++ b/src/Cli/dotnet/Commands/BuildServer/BuildServerCommandParser.cs
@@ -1,37 +1,25 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
 using Microsoft.DotNet.Cli.Commands.BuildServer.Shutdown;
-using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Extensions;
 
 namespace Microsoft.DotNet.Cli.Commands.BuildServer;
 
 internal static class BuildServerCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-build-server";
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = SetAction(BuildServerCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command SetAction(Command command)
     {
-        var command = new Command("build-server", CliCommandStrings.BuildServerCommandDescription)
-        {
-            DocsLink = DocsLink
-        };
-
-        command.Subcommands.Add(BuildServerShutdownCommandParser.GetCommand());
-
         command.SetAction((parseResult) => parseResult.HandleMissingCommand());
-
+        command.Subcommands.Single(c => c.Name == BuildServerShutdownCommandDefinition.Name).SetAction((parseResult) => new BuildServerShutdownCommand(parseResult).Execute());
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/BuildServer/Shutdown/BuildServerShutdownCommand.cs b/src/Cli/dotnet/Commands/BuildServer/Shutdown/BuildServerShutdownCommand.cs
index 244660651751..62f83d368b74 100644
--- a/src/Cli/dotnet/Commands/BuildServer/Shutdown/BuildServerShutdownCommand.cs
+++ b/src/Cli/dotnet/Commands/BuildServer/Shutdown/BuildServerShutdownCommand.cs
@@ -25,9 +25,9 @@ public BuildServerShutdownCommand(
         IReporter reporter = null)
         : base(result)
     {
-        bool msbuild = result.GetValue(BuildServerShutdownCommandParser.MSBuildOption);
-        bool vbcscompiler = result.GetValue(BuildServerShutdownCommandParser.VbcsOption);
-        bool razor = result.GetValue(BuildServerShutdownCommandParser.RazorOption);
+        bool msbuild = result.GetValue(BuildServerShutdownCommandDefinition.MSBuildOption);
+        bool vbcscompiler = result.GetValue(BuildServerShutdownCommandDefinition.VbcsOption);
+        bool razor = result.GetValue(BuildServerShutdownCommandDefinition.RazorOption);
         bool all = !msbuild && !vbcscompiler && !razor;
 
         _enumerationFlags = ServerEnumerationFlags.None;
diff --git a/src/Cli/dotnet/Commands/BuildServer/Shutdown/BuildServerShutdownCommandParser.cs b/src/Cli/dotnet/Commands/BuildServer/Shutdown/BuildServerShutdownCommandDefinition.cs
similarity index 68%
rename from src/Cli/dotnet/Commands/BuildServer/Shutdown/BuildServerShutdownCommandParser.cs
rename to src/Cli/dotnet/Commands/BuildServer/Shutdown/BuildServerShutdownCommandDefinition.cs
index a34ea767f28f..0966bea08219 100644
--- a/src/Cli/dotnet/Commands/BuildServer/Shutdown/BuildServerShutdownCommandParser.cs
+++ b/src/Cli/dotnet/Commands/BuildServer/Shutdown/BuildServerShutdownCommandDefinition.cs
@@ -7,8 +7,10 @@
 
 namespace Microsoft.DotNet.Cli.Commands.BuildServer.Shutdown;
 
-internal static class BuildServerShutdownCommandParser
+internal static class BuildServerShutdownCommandDefinition
 {
+    public const string Name = "shutdown";
+
     public static readonly Option<bool> MSBuildOption = new("--msbuild")
     {
         Description = CliCommandStrings.MSBuildOptionDescription,
@@ -27,23 +29,14 @@ internal static class BuildServerShutdownCommandParser
         Arity = ArgumentArity.Zero
     };
 
-    private static readonly Command Command = ConstructCommand();
-
-    public static Command GetCommand()
-    {
-        return Command;
-    }
-
-    private static Command ConstructCommand()
+    public static Command Create()
     {
-        Command command = new("shutdown", CliCommandStrings.BuildServerShutdownCommandDescription);
+        Command command = new(Name, CliCommandStrings.BuildServerShutdownCommandDescription);
 
         command.Options.Add(MSBuildOption);
         command.Options.Add(VbcsOption);
         command.Options.Add(RazorOption);
 
-        command.SetAction((parseResult) => new BuildServerShutdownCommand(parseResult).Execute());
-
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Clean/CleanCommand.cs b/src/Cli/dotnet/Commands/Clean/CleanCommand.cs
index c7e48c376ee9..15a183a4da6d 100644
--- a/src/Cli/dotnet/Commands/Clean/CleanCommand.cs
+++ b/src/Cli/dotnet/Commands/Clean/CleanCommand.cs
@@ -22,7 +22,7 @@ public static CommandBase FromParseResult(ParseResult result, string? msbuildPat
         result.ShowHelpOrErrorIfAppropriate();
         return CommandFactory.CreateVirtualOrPhysicalCommand(
             CleanCommandParser.GetCommand(),
-            CleanCommandParser.SlnOrProjectOrFileArgument,
+            CleanCommandDefinition.SlnOrProjectOrFileArgument,
             static (msbuildArgs, appFilePath) => new VirtualProjectBuildingCommand(
                     entryPointFileFullPath: appFilePath,
                     msbuildArgs: msbuildArgs)
@@ -33,7 +33,7 @@ public static CommandBase FromParseResult(ParseResult result, string? msbuildPat
                 NoWriteBuildMarkers = true,
             },
             static (msbuildArgs, msbuildPath) => new CleanCommand(msbuildArgs, msbuildPath),
-            [ CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CleanCommandParser.TargetOption, CleanCommandParser.VerbosityOption, CleanCommandParser.NoLogoOption],
+            [ CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CleanCommandDefinition.TargetOption, CleanCommandDefinition.VerbosityOption, CleanCommandDefinition.NoLogoOption],
             result,
             msbuildPath
         );
diff --git a/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs b/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs
new file mode 100644
index 000000000000..1dc8e9028aed
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Clean/CleanCommandDefinition.cs
@@ -0,0 +1,63 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Clean.FileBasedAppArtifacts;
+using Microsoft.DotNet.Cli.Extensions;
+
+namespace Microsoft.DotNet.Cli.Commands.Clean;
+
+internal static class CleanCommandDefinition
+{
+    public static readonly string DocsLink = "https://aka.ms/dotnet-clean";
+
+    public static readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
+    {
+        Description = CliStrings.SolutionOrProjectOrFileArgumentDescription,
+        Arity = ArgumentArity.ZeroOrMore
+    };
+
+    public static readonly Option<string> OutputOption = new Option<string>("--output", "-o")
+    {
+        Description = CliCommandStrings.CleanCmdOutputDirDescription,
+        HelpName = CliCommandStrings.CleanCmdOutputDir
+    }.ForwardAsOutputPath("OutputPath");
+
+    public static readonly Option<bool> NoLogoOption = CommonOptions.NoLogoOption();
+
+    public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(CliCommandStrings.CleanFrameworkOptionDescription);
+
+    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(CliCommandStrings.CleanConfigurationOptionDescription);
+
+    public static readonly Option<string[]> TargetOption = CommonOptions.RequiredMSBuildTargetOption("Clean");
+
+    public static readonly Option<Utils.VerbosityOptions> VerbosityOption = CommonOptions.VerbosityOption(Utils.VerbosityOptions.normal);
+
+    public static Command Create()
+    {
+        Command command = new("clean", CliCommandStrings.CleanAppFullName)
+        {
+            DocsLink = DocsLink
+        };
+
+        command.Arguments.Add(SlnOrProjectOrFileArgument);
+        command.Options.Add(FrameworkOption);
+        command.Options.Add(CommonOptions.RuntimeOption(CliCommandStrings.CleanRuntimeOptionDescription));
+        command.Options.Add(ConfigurationOption);
+        command.Options.Add(CommonOptions.InteractiveMsBuildForwardOption);
+        command.Options.Add(VerbosityOption);
+        command.Options.Add(OutputOption);
+        command.Options.Add(CommonOptions.ArtifactsPathOption);
+        command.Options.Add(NoLogoOption);
+        command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(TargetOption);
+        command.Options.Add(CommonOptions.GetPropertyOption);
+        command.Options.Add(CommonOptions.GetItemOption);
+        command.Options.Add(CommonOptions.GetTargetResultOption);
+        command.Options.Add(CommonOptions.GetResultOutputFileOption);
+        command.Subcommands.Add(CleanFileBasedAppArtifactsCommandDefinition.Create());
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Clean/CleanCommandParser.cs b/src/Cli/dotnet/Commands/Clean/CleanCommandParser.cs
index 117537d7fd1f..8a9237d558b0 100644
--- a/src/Cli/dotnet/Commands/Clean/CleanCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Clean/CleanCommandParser.cs
@@ -2,72 +2,26 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
-using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Commands.Clean.FileBasedAppArtifacts;
-using Microsoft.DotNet.Cli.Extensions;
 
 namespace Microsoft.DotNet.Cli.Commands.Clean;
 
 internal static class CleanCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-clean";
-
-    public static readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
-    {
-        Description = CliStrings.SolutionOrProjectOrFileArgumentDescription,
-        Arity = ArgumentArity.ZeroOrMore
-    };
-
-    public static readonly Option<string> OutputOption = new Option<string>("--output", "-o")
-    {
-        Description = CliCommandStrings.CleanCmdOutputDirDescription,
-        HelpName = CliCommandStrings.CleanCmdOutputDir
-    }.ForwardAsOutputPath("OutputPath");
-
-    public static readonly Option<bool> NoLogoOption = CommonOptions.NoLogoOption();
-
-    public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(CliCommandStrings.CleanFrameworkOptionDescription);
-
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(CliCommandStrings.CleanConfigurationOptionDescription);
-
-    public static readonly Option<string[]> TargetOption = CommonOptions.RequiredMSBuildTargetOption("Clean");
-
-    public static readonly Option<Utils.VerbosityOptions> VerbosityOption = CommonOptions.VerbosityOption(Utils.VerbosityOptions.normal);
-
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = SetAction(CleanCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command SetAction(Command command)
     {
-        Command command = new("clean", CliCommandStrings.CleanAppFullName)
-        {
-            DocsLink = DocsLink
-        };
-
-        command.Arguments.Add(SlnOrProjectOrFileArgument);
-        command.Options.Add(FrameworkOption);
-        command.Options.Add(CommonOptions.RuntimeOption(CliCommandStrings.CleanRuntimeOptionDescription));
-        command.Options.Add(ConfigurationOption);
-        command.Options.Add(CommonOptions.InteractiveMsBuildForwardOption);
-        command.Options.Add(VerbosityOption);
-        command.Options.Add(OutputOption);
-        command.Options.Add(CommonOptions.ArtifactsPathOption);
-        command.Options.Add(NoLogoOption);
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
-        command.Options.Add(TargetOption);
-        command.Options.Add(CommonOptions.GetPropertyOption);
-        command.Options.Add(CommonOptions.GetItemOption);
-        command.Options.Add(CommonOptions.GetTargetResultOption);
-        command.Options.Add(CommonOptions.GetResultOutputFileOption);
-        command.Subcommands.Add(CleanFileBasedAppArtifactsCommandParser.Command);
-
         command.SetAction(CleanCommand.Run);
 
+        command.Subcommands.Single(c => c.Name == CleanFileBasedAppArtifactsCommandDefinition.Name)
+            .SetAction(parseResult => new CleanFileBasedAppArtifactsCommand(parseResult).Execute());
+
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Clean/FileBasedAppArtifacts/CleanFileBasedAppArtifactsCommand.cs b/src/Cli/dotnet/Commands/Clean/FileBasedAppArtifacts/CleanFileBasedAppArtifactsCommand.cs
index 006e8830ad5c..6654ab3697b9 100644
--- a/src/Cli/dotnet/Commands/Clean/FileBasedAppArtifacts/CleanFileBasedAppArtifactsCommand.cs
+++ b/src/Cli/dotnet/Commands/Clean/FileBasedAppArtifacts/CleanFileBasedAppArtifactsCommand.cs
@@ -14,7 +14,7 @@ internal sealed class CleanFileBasedAppArtifactsCommand(ParseResult parseResult)
 {
     public override int Execute()
     {
-        bool dryRun = _parseResult.GetValue(CleanFileBasedAppArtifactsCommandParser.DryRunOption);
+        bool dryRun = _parseResult.GetValue(CleanFileBasedAppArtifactsCommandDefinition.DryRunOption);
 
         using var metadataFileStream = OpenMetadataFile();
 
@@ -70,7 +70,7 @@ private IEnumerable<DirectoryInfo> GetFoldersToRemove()
 
         Reporter.Output.WriteLine(CliCommandStrings.CleanFileBasedAppArtifactsScanning, directory.FullName);
 
-        var days = _parseResult.GetValue(CleanFileBasedAppArtifactsCommandParser.DaysOption);
+        var days = _parseResult.GetValue(CleanFileBasedAppArtifactsCommandDefinition.DaysOption);
         var cutoff = DateTime.UtcNow.AddDays(-days);
 
         foreach (var subdir in directory.GetDirectories())
@@ -89,7 +89,7 @@ private static FileInfo GetMetadataFile()
 
     private FileStream? OpenMetadataFile()
     {
-        if (!_parseResult.GetValue(CleanFileBasedAppArtifactsCommandParser.AutomaticOption))
+        if (!_parseResult.GetValue(CleanFileBasedAppArtifactsCommandDefinition.AutomaticOption))
         {
             return null;
         }
@@ -127,8 +127,8 @@ public static void StartAutomaticCleanupIfNeeded()
                 Arguments = ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(
                 [
                     CleanCommandParser.GetCommand().Name,
-                    CleanFileBasedAppArtifactsCommandParser.Command.Name,
-                    CleanFileBasedAppArtifactsCommandParser.AutomaticOption.Name,
+                    CleanFileBasedAppArtifactsCommandDefinition.Name,
+                    CleanFileBasedAppArtifactsCommandDefinition.AutomaticOption.Name,
                 ]),
                 UseShellExecute = false,
                 RedirectStandardInput = true,
diff --git a/src/Cli/dotnet/Commands/Clean/FileBasedAppArtifacts/CleanFileBasedAppArtifactsCommandParser.cs b/src/Cli/dotnet/Commands/Clean/FileBasedAppArtifacts/CleanFileBasedAppArtifactsCommandDefinition.cs
similarity index 73%
rename from src/Cli/dotnet/Commands/Clean/FileBasedAppArtifacts/CleanFileBasedAppArtifactsCommandParser.cs
rename to src/Cli/dotnet/Commands/Clean/FileBasedAppArtifacts/CleanFileBasedAppArtifactsCommandDefinition.cs
index 818c4f23a5ec..db9bf92bd846 100644
--- a/src/Cli/dotnet/Commands/Clean/FileBasedAppArtifacts/CleanFileBasedAppArtifactsCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Clean/FileBasedAppArtifacts/CleanFileBasedAppArtifactsCommandDefinition.cs
@@ -5,8 +5,10 @@
 
 namespace Microsoft.DotNet.Cli.Commands.Clean.FileBasedAppArtifacts;
 
-internal sealed class CleanFileBasedAppArtifactsCommandParser
+internal sealed class CleanFileBasedAppArtifactsCommandDefinition
 {
+    public const string Name = "file-based-apps";
+
     public static readonly Option<bool> DryRunOption = new("--dry-run")
     {
         Description = CliCommandStrings.CleanFileBasedAppArtifactsDryRun,
@@ -28,11 +30,8 @@ internal sealed class CleanFileBasedAppArtifactsCommandParser
         Hidden = true,
     };
 
-    public static Command Command => field ??= ConstructCommand();
-
-    private static Command ConstructCommand()
-    {
-        Command command = new("file-based-apps", CliCommandStrings.CleanFileBasedAppArtifactsCommandDescription)
+    public static Command Create()
+        => new(Name, CliCommandStrings.CleanFileBasedAppArtifactsCommandDescription)
         {
             Hidden = true,
             Options =
@@ -42,8 +41,4 @@ private static Command ConstructCommand()
                 AutomaticOption,
             },
         };
-
-        command.SetAction((parseResult) => new CleanFileBasedAppArtifactsCommand(parseResult).Execute());
-        return command;
-    }
 }
diff --git a/src/Cli/dotnet/Commands/Dnx/DnxCommandDefinition.cs b/src/Cli/dotnet/Commands/Dnx/DnxCommandDefinition.cs
new file mode 100644
index 000000000000..03546f4ac5a8
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Dnx/DnxCommandDefinition.cs
@@ -0,0 +1,28 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Tool.Execute;
+
+namespace Microsoft.DotNet.Cli.Commands.Dnx;
+
+internal static class DnxCommandDefinition
+{
+    public static Command Create()
+    {
+        Command command = new("dnx", CliCommandStrings.ToolExecuteCommandDescription);
+        command.Hidden = true;
+
+        foreach (var argument in ToolExecuteCommandParser.Command.Arguments)
+        {
+            command.Arguments.Add(argument);
+        }
+
+        foreach (var option in ToolExecuteCommandParser.Command.Options)
+        {
+            command.Options.Add(option);
+        }
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Dnx/DnxCommandParser.cs b/src/Cli/dotnet/Commands/Dnx/DnxCommandParser.cs
index 89938373a637..2e3488ff5e13 100644
--- a/src/Cli/dotnet/Commands/Dnx/DnxCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Dnx/DnxCommandParser.cs
@@ -1,37 +1,23 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
-using Microsoft.DotNet.Cli.Commands.Tool;
 using Microsoft.DotNet.Cli.Commands.Tool.Execute;
 
 namespace Microsoft.DotNet.Cli.Commands.Dnx;
 
 internal static class DnxCommandParser
 {
-    public static readonly Command Command = ConstructCommand();
+    public static readonly Command Command = ConfigureCommand(DnxCommandDefinition.Create());
+
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command ConfigureCommand(Command command)
     {
-        Command command = new("dnx", CliCommandStrings.ToolExecuteCommandDescription);
-        command.Hidden = true;
-
-        foreach (var argument in ToolExecuteCommandParser.Command.Arguments)
-        {
-            command.Arguments.Add(argument);
-        }
-
-        foreach (var option in ToolExecuteCommandParser.Command.Options)
-        {
-            command.Options.Add(option);
-        }
-
         command.SetAction((parseResult) => new ToolExecuteCommand(parseResult).Execute());
-
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Format/FormatCommand.cs b/src/Cli/dotnet/Commands/Format/FormatCommand.cs
index 9ee9296172fa..ae4bedf56185 100644
--- a/src/Cli/dotnet/Commands/Format/FormatCommand.cs
+++ b/src/Cli/dotnet/Commands/Format/FormatCommand.cs
@@ -19,7 +19,7 @@ public static FormatCommand FromArgs(string[] args)
 
     public static FormatCommand FromParseResult(ParseResult result)
     {
-        return new FormatCommand(result.GetValue(FormatCommandParser.Arguments));
+        return new FormatCommand(result.GetValue(FormatCommandDefinition.Arguments));
     }
 
     public static int Run(ParseResult parseResult)
diff --git a/src/Cli/dotnet/Commands/Format/FormatCommandDefinition.cs b/src/Cli/dotnet/Commands/Format/FormatCommandDefinition.cs
new file mode 100644
index 000000000000..e1042db345cf
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Format/FormatCommandDefinition.cs
@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
+
+namespace Microsoft.DotNet.Cli.Commands.Format;
+
+internal static class FormatCommandDefinition
+{
+    public const string Name = "format";
+
+    public static readonly Argument<string[]> Arguments = new("arguments");
+
+    public static readonly string DocsLink = "https://aka.ms/dotnet-format";
+
+    public static Command Create()
+        => new(Name)
+        {
+            Arguments = { Arguments },
+            DocsLink = DocsLink,
+        };
+}
diff --git a/src/Cli/dotnet/Commands/Format/FormatCommandParser.cs b/src/Cli/dotnet/Commands/Format/FormatCommandParser.cs
index dcbeb642e4a8..7ba0478c04ec 100644
--- a/src/Cli/dotnet/Commands/Format/FormatCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Format/FormatCommandParser.cs
@@ -1,34 +1,22 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
-using Microsoft.DotNet.Cli.CommandLine;
 
 namespace Microsoft.DotNet.Cli.Commands.Format;
 
-internal static partial class FormatCommandParser
+internal static class FormatCommandParser
 {
-    public static readonly Argument<string[]> Arguments = new("arguments");
-
-    public static readonly string DocsLink = "https://aka.ms/dotnet-format";
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = SetAction(FormatCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command SetAction(Command command)
     {
-        var formatCommand = new Command("format")
-        {
-            Arguments = { Arguments },
-            DocsLink = DocsLink,
-        };
-        formatCommand.SetAction((parseResult) => FormatCommand.Run(parseResult.GetValue(Arguments)));
-        return formatCommand;
+        command.SetAction(parseResult => FormatCommand.Run(parseResult.GetValue(FormatCommandDefinition.Arguments)));
+        return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Fsi/FsiCommandDefinition.cs b/src/Cli/dotnet/Commands/Fsi/FsiCommandDefinition.cs
new file mode 100644
index 000000000000..7dd63f6d4057
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Fsi/FsiCommandDefinition.cs
@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
+
+namespace Microsoft.DotNet.Cli.Commands.Fsi;
+
+internal static class FsiCommandDefinition
+{
+    public const string Name = "fsi";
+
+    public static readonly string DocsLink = "https://aka.ms/dotnet-fsi";
+
+    public static readonly Argument<string[]> Arguments = new("arguments");
+
+    public static Command Create()
+    {
+        Command command = new(Name) {
+            Arguments = { Arguments },
+            DocsLink = DocsLink,
+        };
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Fsi/FsiCommandParser.cs b/src/Cli/dotnet/Commands/Fsi/FsiCommandParser.cs
index c81c34e79566..06d3a2a18a33 100644
--- a/src/Cli/dotnet/Commands/Fsi/FsiCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Fsi/FsiCommandParser.cs
@@ -1,34 +1,22 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
-using Microsoft.DotNet.Cli.CommandLine;
 
 namespace Microsoft.DotNet.Cli.Commands.Fsi;
 
 internal static class FsiCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-fsi";
-
-    public static readonly Argument<string[]> Arguments = new("arguments");
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = SetAction(FsiCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command SetAction(Command command)
     {
-        Command command = new("fsi") {
-            Arguments = { Arguments },
-            DocsLink = DocsLink,
-        };
-        command.SetAction((parseResult) => FsiCommand.Run(parseResult.GetValue(Arguments)));
-
+        command.SetAction((parseResult) => FsiCommand.Run(parseResult.GetValue(FsiCommandDefinition.Arguments)));
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Help/HelpCommand.cs b/src/Cli/dotnet/Commands/Help/HelpCommand.cs
index a2646a3764d4..1eb9a76e32fa 100644
--- a/src/Cli/dotnet/Commands/Help/HelpCommand.cs
+++ b/src/Cli/dotnet/Commands/Help/HelpCommand.cs
@@ -20,7 +20,7 @@ public static int Run(ParseResult result)
 
         result.ShowHelpOrErrorIfAppropriate();
 
-        if (result.GetValue(HelpCommandParser.Argument) is string[] args && args is not [])
+        if (result.GetValue(HelpCommandDefinition.Argument) is string[] args && args is not [])
         {
             return new HelpCommand(args).Execute();
         }
diff --git a/src/Cli/dotnet/Commands/Help/HelpCommandDefinition.cs b/src/Cli/dotnet/Commands/Help/HelpCommandDefinition.cs
new file mode 100644
index 000000000000..50802d4463f8
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Help/HelpCommandDefinition.cs
@@ -0,0 +1,31 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
+
+namespace Microsoft.DotNet.Cli.Commands.Help;
+
+internal static class HelpCommandDefinition
+{
+    public static readonly string DocsLink = "https://aka.ms/dotnet-help";
+
+    public static readonly Argument<string[]> Argument = new(CliCommandStrings.CommandArgumentName)
+    {
+        Description = CliCommandStrings.CommandArgumentDescription,
+        Arity = ArgumentArity.ZeroOrMore
+    };
+
+    public static Command Create()
+    {
+        Command command = new("help", CliCommandStrings.HelpAppFullName)
+        {
+            DocsLink = DocsLink
+        };
+
+        command.Arguments.Add(Argument);
+
+        return command;
+    }
+}
+
diff --git a/src/Cli/dotnet/Commands/Help/HelpCommandParser.cs b/src/Cli/dotnet/Commands/Help/HelpCommandParser.cs
index 8334e262381f..f6226803fb17 100644
--- a/src/Cli/dotnet/Commands/Help/HelpCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Help/HelpCommandParser.cs
@@ -1,42 +1,22 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
-using Microsoft.DotNet.Cli.CommandLine;
 
 namespace Microsoft.DotNet.Cli.Commands.Help;
 
 internal static class HelpCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-help";
-
-    public static readonly Argument<string[]> Argument = new(CliCommandStrings.CommandArgumentName)
-    {
-        Description = CliCommandStrings.CommandArgumentDescription,
-        Arity = ArgumentArity.ZeroOrMore
-    };
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = SetAction(HelpCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command SetAction(Command command)
     {
-        Command command = new("help", CliCommandStrings.HelpAppFullName)
-        {
-            DocsLink = DocsLink
-        };
-
-        command.Arguments.Add(Argument);
-
         command.SetAction(HelpCommand.Run);
-
         return command;
     }
 }
-
diff --git a/src/Cli/dotnet/Commands/Hidden/Add/AddCommandDefinition.cs b/src/Cli/dotnet/Commands/Hidden/Add/AddCommandDefinition.cs
new file mode 100644
index 000000000000..e7f3b84b5227
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Hidden/Add/AddCommandDefinition.cs
@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Hidden.Add.Package;
+using Microsoft.DotNet.Cli.Commands.Hidden.Add.Reference;
+using Microsoft.DotNet.Cli.Commands.Package;
+
+namespace Microsoft.DotNet.Cli.Commands.Hidden.Add;
+
+internal static class AddCommandDefinition
+{
+    public const string Name = "add";
+
+    public static readonly string DocsLink = "https://aka.ms/dotnet-add";
+
+    public static Command Create()
+    {
+        var command = new Command(Name, CliCommandStrings.NetAddCommand)
+        {
+            Hidden = true,
+            DocsLink = DocsLink
+        };
+
+        command.Arguments.Add(PackageCommandDefinition.ProjectOrFileArgument);
+        command.Subcommands.Add(AddPackageCommandDefinition.Create());
+        command.Subcommands.Add(AddReferenceCommandDefinition.Create());
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Hidden/Add/AddCommandParser.cs b/src/Cli/dotnet/Commands/Hidden/Add/AddCommandParser.cs
index c2d21405b1f2..bbd7230b0829 100644
--- a/src/Cli/dotnet/Commands/Hidden/Add/AddCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Hidden/Add/AddCommandParser.cs
@@ -4,37 +4,27 @@
 using System.CommandLine;
 using Microsoft.DotNet.Cli.Commands.Hidden.Add.Package;
 using Microsoft.DotNet.Cli.Commands.Hidden.Add.Reference;
-using Microsoft.DotNet.Cli.Commands.Package;
-using Microsoft.DotNet.Cli.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Package.Add;
+using Microsoft.DotNet.Cli.Commands.Reference.Add;
 using Microsoft.DotNet.Cli.Extensions;
 
 namespace Microsoft.DotNet.Cli.Commands.Hidden.Add;
 
 internal static class AddCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-add";
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = SetAction(AddCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command SetAction(Command command)
     {
-        var command = new Command("add", CliCommandStrings.NetAddCommand)
-        {
-            Hidden = true,
-            DocsLink = DocsLink
-        };
-
-        command.Arguments.Add(PackageCommandParser.ProjectOrFileArgument);
-        command.Subcommands.Add(AddPackageCommandParser.GetCommand());
-        command.Subcommands.Add(AddReferenceCommandParser.GetCommand());
-
         command.SetAction((parseResult) => parseResult.HandleMissingCommand());
 
+        command.Subcommands.Single(c => c.Name == AddPackageCommandDefinition.Name).SetAction((parseResult) => new PackageAddCommand(parseResult).Execute());
+        command.Subcommands.Single(c => c.Name == AddReferenceCommandDefinition.Name).SetAction((parseResult) => new ReferenceAddCommand(parseResult).Execute());
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Hidden/Add/Package/AddPackageCommandDefinition.cs b/src/Cli/dotnet/Commands/Hidden/Add/Package/AddPackageCommandDefinition.cs
new file mode 100644
index 000000000000..213cf1c18fa8
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Hidden/Add/Package/AddPackageCommandDefinition.cs
@@ -0,0 +1,31 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Package;
+using Microsoft.DotNet.Cli.Commands.Package.Add;
+
+namespace Microsoft.DotNet.Cli.Commands.Hidden.Add.Package;
+
+internal static class AddPackageCommandDefinition
+{
+    public const string Name = "package";
+
+    public static Command Create()
+    {
+        Command command = new(Name, CliCommandStrings.PackageAddAppFullName);
+
+        command.Arguments.Add(PackageAddCommandDefinition.CmdPackageArgument);
+        command.Options.Add(PackageAddCommandDefinition.VersionOption);
+        command.Options.Add(PackageAddCommandDefinition.FrameworkOption);
+        command.Options.Add(PackageAddCommandDefinition.NoRestoreOption);
+        command.Options.Add(PackageAddCommandDefinition.SourceOption);
+        command.Options.Add(PackageAddCommandDefinition.PackageDirOption);
+        command.Options.Add(PackageAddCommandDefinition.InteractiveOption);
+        command.Options.Add(PackageAddCommandDefinition.PrereleaseOption);
+        command.Options.Add(PackageCommandDefinition.ProjectOption);
+        command.Options.Add(PackageCommandDefinition.FileOption);
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Hidden/Add/Package/AddPackageCommandParser.cs b/src/Cli/dotnet/Commands/Hidden/Add/Package/AddPackageCommandParser.cs
deleted file mode 100644
index f6cb1909b23d..000000000000
--- a/src/Cli/dotnet/Commands/Hidden/Add/Package/AddPackageCommandParser.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.CommandLine;
-using Microsoft.DotNet.Cli.Commands.Package;
-using Microsoft.DotNet.Cli.Commands.Package.Add;
-
-namespace Microsoft.DotNet.Cli.Commands.Hidden.Add.Package;
-
-internal static class AddPackageCommandParser
-{
-    private static readonly Command Command = ConstructCommand();
-
-    public static Command GetCommand()
-    {
-        return Command;
-    }
-
-    private static Command ConstructCommand()
-    {
-        Command command = new("package", CliCommandStrings.PackageAddAppFullName);
-
-        command.Arguments.Add(PackageAddCommandParser.CmdPackageArgument);
-        command.Options.Add(PackageAddCommandParser.VersionOption);
-        command.Options.Add(PackageAddCommandParser.FrameworkOption);
-        command.Options.Add(PackageAddCommandParser.NoRestoreOption);
-        command.Options.Add(PackageAddCommandParser.SourceOption);
-        command.Options.Add(PackageAddCommandParser.PackageDirOption);
-        command.Options.Add(PackageAddCommandParser.InteractiveOption);
-        command.Options.Add(PackageAddCommandParser.PrereleaseOption);
-        command.Options.Add(PackageCommandParser.ProjectOption);
-        command.Options.Add(PackageCommandParser.FileOption);
-
-        command.SetAction((parseResult) => new PackageAddCommand(parseResult).Execute());
-
-        return command;
-    }
-}
diff --git a/src/Cli/dotnet/Commands/Hidden/Add/Reference/AddReferenceCommandDefinition.cs b/src/Cli/dotnet/Commands/Hidden/Add/Reference/AddReferenceCommandDefinition.cs
new file mode 100644
index 000000000000..2bfe74a9b573
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Hidden/Add/Reference/AddReferenceCommandDefinition.cs
@@ -0,0 +1,25 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Reference;
+using Microsoft.DotNet.Cli.Commands.Reference.Add;
+
+namespace Microsoft.DotNet.Cli.Commands.Hidden.Add.Reference;
+
+internal static class AddReferenceCommandDefinition
+{
+    public const string Name = "reference";
+
+    public static Command Create()
+    {
+        Command command = new(Name, CliCommandStrings.ReferenceAddAppFullName);
+
+        command.Arguments.Add(ReferenceAddCommandDefinition.ProjectPathArgument);
+        command.Options.Add(ReferenceAddCommandDefinition.FrameworkOption);
+        command.Options.Add(ReferenceAddCommandDefinition.InteractiveOption);
+        command.Options.Add(ReferenceCommandDefinition.ProjectOption);
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Hidden/Add/Reference/AddReferenceCommandParser.cs b/src/Cli/dotnet/Commands/Hidden/Add/Reference/AddReferenceCommandParser.cs
deleted file mode 100644
index 2cb98fd75b35..000000000000
--- a/src/Cli/dotnet/Commands/Hidden/Add/Reference/AddReferenceCommandParser.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-using System.CommandLine;
-using Microsoft.DotNet.Cli.Commands.Reference;
-using Microsoft.DotNet.Cli.Commands.Reference.Add;
-
-namespace Microsoft.DotNet.Cli.Commands.Hidden.Add.Reference;
-
-internal static class AddReferenceCommandParser
-{
-    private static readonly Command Command = ConstructCommand();
-
-    public static Command GetCommand()
-    {
-        return Command;
-    }
-
-    private static Command ConstructCommand()
-    {
-        Command command = new("reference", CliCommandStrings.ReferenceAddAppFullName);
-
-        command.Arguments.Add(ReferenceAddCommandParser.ProjectPathArgument);
-        command.Options.Add(ReferenceAddCommandParser.FrameworkOption);
-        command.Options.Add(ReferenceAddCommandParser.InteractiveOption);
-        command.Options.Add(ReferenceCommandParser.ProjectOption);
-
-        command.SetAction((parseResult) => new ReferenceAddCommand(parseResult).Execute());
-
-        return command;
-    }
-}
diff --git a/src/Cli/dotnet/Commands/Hidden/Complete/CompleteCommand.cs b/src/Cli/dotnet/Commands/Hidden/Complete/CompleteCommand.cs
index 5cdf66cfca6e..cd193ed52669 100644
--- a/src/Cli/dotnet/Commands/Hidden/Complete/CompleteCommand.cs
+++ b/src/Cli/dotnet/Commands/Hidden/Complete/CompleteCommand.cs
@@ -51,9 +51,9 @@ public static int RunWithReporter(ParseResult result, IReporter reporter)
 
     private static CompletionItem[] Completions(ParseResult complete)
     {
-        var input = complete.GetValue(CompleteCommandParser.PathArgument) ?? string.Empty;
+        var input = complete.GetValue(CompleteCommandDefinition.PathArgument) ?? string.Empty;
 
-        var position = complete.GetValue(CompleteCommandParser.PositionOption);
+        var position = complete.GetValue(CompleteCommandDefinition.PositionOption);
 
         if (position > input.Length)
         {
diff --git a/src/Cli/dotnet/Commands/Hidden/Complete/CompleteCommandDefinition.cs b/src/Cli/dotnet/Commands/Hidden/Complete/CompleteCommandDefinition.cs
new file mode 100644
index 000000000000..cdfbe82b5f13
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Hidden/Complete/CompleteCommandDefinition.cs
@@ -0,0 +1,29 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+
+namespace Microsoft.DotNet.Cli.Commands.Hidden.Complete;
+
+internal static class CompleteCommandDefinition
+{
+    public static readonly Argument<string> PathArgument = new("path");
+
+    public static readonly Option<int?> PositionOption = new("--position")
+    {
+        HelpName = "command"
+    };
+
+    public static Command Create()
+    {
+        Command command = new("complete")
+        {
+            Hidden = true
+        };
+
+        command.Arguments.Add(PathArgument);
+        command.Options.Add(PositionOption);
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Hidden/Complete/CompleteCommandParser.cs b/src/Cli/dotnet/Commands/Hidden/Complete/CompleteCommandParser.cs
index e613f4ad739a..459f128ebc79 100644
--- a/src/Cli/dotnet/Commands/Hidden/Complete/CompleteCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Hidden/Complete/CompleteCommandParser.cs
@@ -1,40 +1,22 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
 
 namespace Microsoft.DotNet.Cli.Commands.Hidden.Complete;
 
 internal static class CompleteCommandParser
 {
-    public static readonly Argument<string> PathArgument = new("path");
-
-    public static readonly Option<int?> PositionOption = new("--position")
-    {
-        HelpName = "command"
-    };
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = SetAction(CompleteCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command SetAction(Command command)
     {
-        Command command = new("complete")
-        {
-            Hidden = true
-        };
-
-        command.Arguments.Add(PathArgument);
-        command.Options.Add(PositionOption);
-
         command.SetAction(CompleteCommand.Run);
-
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Hidden/InternalReportInstallSuccess/InternalReportInstallSuccessCommand.cs b/src/Cli/dotnet/Commands/Hidden/InternalReportInstallSuccess/InternalReportInstallSuccessCommand.cs
index 744289023948..af7e3df0c98e 100644
--- a/src/Cli/dotnet/Commands/Hidden/InternalReportInstallSuccess/InternalReportInstallSuccessCommand.cs
+++ b/src/Cli/dotnet/Commands/Hidden/InternalReportInstallSuccess/InternalReportInstallSuccessCommand.cs
@@ -31,7 +31,7 @@ public static void ProcessInputAndSendTelemetry(string[] args, ITelemetry teleme
 
     public static void ProcessInputAndSendTelemetry(ParseResult result, ITelemetry telemetry)
     {
-        var exeName = Path.GetFileName(result.GetValue(InternalReportInstallSuccessCommandParser.Argument));
+        var exeName = Path.GetFileName(result.GetValue(InternalReportInstallSuccessCommandDefinition.Argument));
 
         var filter = new TelemetryFilter(Sha256Hasher.HashWithNormalizedCasing);
         foreach (var e in filter.Filter(new InstallerSuccessReport(exeName)))
diff --git a/src/Cli/dotnet/Commands/Hidden/InternalReportInstallSuccess/InternalReportInstallSuccessCommandDefinition.cs b/src/Cli/dotnet/Commands/Hidden/InternalReportInstallSuccess/InternalReportInstallSuccessCommandDefinition.cs
new file mode 100644
index 000000000000..23736c5f4ac8
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Hidden/InternalReportInstallSuccess/InternalReportInstallSuccessCommandDefinition.cs
@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+
+namespace Microsoft.DotNet.Cli.Commands.Hidden.InternalReportInstallSuccess;
+
+internal static class InternalReportInstallSuccessCommandDefinition
+{
+    public static readonly Argument<string> Argument = new("internal-reportinstallsuccess-arg");
+
+    public static Command Create()
+    {
+        Command command = new("internal-reportinstallsuccess")
+        {
+            Hidden = true
+        };
+
+        command.Arguments.Add(Argument);
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Hidden/InternalReportInstallSuccess/InternalReportInstallSuccessCommandParser.cs b/src/Cli/dotnet/Commands/Hidden/InternalReportInstallSuccess/InternalReportInstallSuccessCommandParser.cs
index 5a5ea89397e8..e174c010d04b 100644
--- a/src/Cli/dotnet/Commands/Hidden/InternalReportInstallSuccess/InternalReportInstallSuccessCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Hidden/InternalReportInstallSuccess/InternalReportInstallSuccessCommandParser.cs
@@ -1,34 +1,22 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
 
 namespace Microsoft.DotNet.Cli.Commands.Hidden.InternalReportInstallSuccess;
 
 internal static class InternalReportInstallSuccessCommandParser
 {
-    public static readonly Argument<string> Argument = new("internal-reportinstallsuccess-arg");
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = SetAction(InternalReportInstallSuccessCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command SetAction(Command command)
     {
-        Command command = new("internal-reportinstallsuccess")
-        {
-            Hidden = true
-        };
-
-        command.Arguments.Add(Argument);
-
         command.SetAction(InternalReportInstallSuccessCommand.Run);
-
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Hidden/List/ListCommandDefinition.cs b/src/Cli/dotnet/Commands/Hidden/List/ListCommandDefinition.cs
new file mode 100644
index 000000000000..055be9199019
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Hidden/List/ListCommandDefinition.cs
@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Hidden.List.Package;
+using Microsoft.DotNet.Cli.Commands.Hidden.List.Reference;
+
+namespace Microsoft.DotNet.Cli.Commands.Hidden.List;
+
+internal static class ListCommandDefinition
+{
+    public static readonly string DocsLink = "https://aka.ms/dotnet-list";
+
+    public static readonly Argument<string> SlnOrProjectArgument = CreateSlnOrProjectArgument(CliStrings.SolutionOrProjectArgumentName, CliStrings.SolutionOrProjectArgumentDescription);
+
+    internal static Argument<string> CreateSlnOrProjectArgument(string name, string description)
+        => new Argument<string>(name)
+        {
+            Description = description,
+            Arity = ArgumentArity.ZeroOrOne
+        }.DefaultToCurrentDirectory();
+
+    public static Command Create()
+    {
+        var command = new Command("list", CliCommandStrings.NetListCommand)
+        {
+            Hidden = true,
+            DocsLink = DocsLink
+        };
+
+        command.Arguments.Add(SlnOrProjectArgument);
+        command.Subcommands.Add(ListPackageCommandDefinition.Create());
+        command.Subcommands.Add(ListReferenceCommandDefinition.Create());
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Hidden/List/ListCommandParser.cs b/src/Cli/dotnet/Commands/Hidden/List/ListCommandParser.cs
index f471c20b62d1..8d10c7e12f1c 100644
--- a/src/Cli/dotnet/Commands/Hidden/List/ListCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Hidden/List/ListCommandParser.cs
@@ -1,49 +1,30 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
 using Microsoft.DotNet.Cli.Commands.Hidden.List.Package;
 using Microsoft.DotNet.Cli.Commands.Hidden.List.Reference;
+using Microsoft.DotNet.Cli.Commands.Package.List;
+using Microsoft.DotNet.Cli.Commands.Reference.List;
 using Microsoft.DotNet.Cli.Extensions;
-using Microsoft.DotNet.Cli.CommandLine;
 
 namespace Microsoft.DotNet.Cli.Commands.Hidden.List;
 
 internal static class ListCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-list";
-
-    public static readonly Argument<string> SlnOrProjectArgument = CreateSlnOrProjectArgument(CliStrings.SolutionOrProjectArgumentName, CliStrings.SolutionOrProjectArgumentDescription);
-
-    internal static Argument<string> CreateSlnOrProjectArgument(string name, string description)
-        => new Argument<string>(name)
-        {
-            Description = description,
-            Arity = ArgumentArity.ZeroOrOne
-        }.DefaultToCurrentDirectory();
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = SetAction(ListCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command SetAction(Command command)
     {
-        var command = new Command("list", CliCommandStrings.NetListCommand)
-        {
-            Hidden = true,
-            DocsLink = DocsLink
-        };
-
-        command.Arguments.Add(SlnOrProjectArgument);
-        command.Subcommands.Add(ListPackageCommandParser.GetCommand());
-        command.Subcommands.Add(ListReferenceCommandParser.GetCommand());
+        command.SetAction(parseResult => parseResult.HandleMissingCommand());
 
-        command.SetAction((parseResult) => parseResult.HandleMissingCommand());
+        command.Subcommands.Single(c => c.Name == ListPackageCommandDefinition.Name).SetAction((parseResult) => new PackageListCommand(parseResult).Execute());
+        command.Subcommands.Single(c => c.Name == ListReferenceCommandDefinition.Name).SetAction((parseResult) => new ReferenceListCommand(parseResult).Execute());
 
         return command;
     }
diff --git a/src/Cli/dotnet/Commands/Hidden/List/Package/ListPackageCommandDefinition.cs b/src/Cli/dotnet/Commands/Hidden/List/Package/ListPackageCommandDefinition.cs
new file mode 100644
index 000000000000..df28ebcda833
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Hidden/List/Package/ListPackageCommandDefinition.cs
@@ -0,0 +1,35 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Package.List;
+
+namespace Microsoft.DotNet.Cli.Commands.Hidden.List.Package;
+
+internal static class ListPackageCommandDefinition
+{
+    public const string Name = "package";
+
+    public static Command Create()
+    {
+        Command command = new(Name, CliCommandStrings.PackageListAppFullName);
+
+        command.Options.Add(PackageListCommandDefinition.VerbosityOption);
+        command.Options.Add(PackageListCommandDefinition.OutdatedOption);
+        command.Options.Add(PackageListCommandDefinition.DeprecatedOption);
+        command.Options.Add(PackageListCommandDefinition.VulnerableOption);
+        command.Options.Add(PackageListCommandDefinition.FrameworkOption);
+        command.Options.Add(PackageListCommandDefinition.TransitiveOption);
+        command.Options.Add(PackageListCommandDefinition.PrereleaseOption);
+        command.Options.Add(PackageListCommandDefinition.HighestPatchOption);
+        command.Options.Add(PackageListCommandDefinition.HighestMinorOption);
+        command.Options.Add(PackageListCommandDefinition.ConfigOption);
+        command.Options.Add(PackageListCommandDefinition.SourceOption);
+        command.Options.Add(PackageListCommandDefinition.InteractiveOption);
+        command.Options.Add(PackageListCommandDefinition.FormatOption);
+        command.Options.Add(PackageListCommandDefinition.OutputVersionOption);
+        command.Options.Add(PackageListCommandDefinition.NoRestore);
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Hidden/List/Package/ListPackageCommandParser.cs b/src/Cli/dotnet/Commands/Hidden/List/Package/ListPackageCommandParser.cs
deleted file mode 100644
index a1d8c613f289..000000000000
--- a/src/Cli/dotnet/Commands/Hidden/List/Package/ListPackageCommandParser.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-using System.CommandLine;
-using Microsoft.DotNet.Cli.Commands.Package.List;
-
-namespace Microsoft.DotNet.Cli.Commands.Hidden.List.Package;
-
-internal static class ListPackageCommandParser
-{
-    private static readonly Command Command = ConstructCommand();
-
-    public static Command GetCommand()
-    {
-        return Command;
-    }
-
-    private static Command ConstructCommand()
-    {
-        Command command = new("package", CliCommandStrings.PackageListAppFullName);
-
-        command.Options.Add(PackageListCommandParser.VerbosityOption);
-        command.Options.Add(PackageListCommandParser.OutdatedOption);
-        command.Options.Add(PackageListCommandParser.DeprecatedOption);
-        command.Options.Add(PackageListCommandParser.VulnerableOption);
-        command.Options.Add(PackageListCommandParser.FrameworkOption);
-        command.Options.Add(PackageListCommandParser.TransitiveOption);
-        command.Options.Add(PackageListCommandParser.PrereleaseOption);
-        command.Options.Add(PackageListCommandParser.HighestPatchOption);
-        command.Options.Add(PackageListCommandParser.HighestMinorOption);
-        command.Options.Add(PackageListCommandParser.ConfigOption);
-        command.Options.Add(PackageListCommandParser.SourceOption);
-        command.Options.Add(PackageListCommandParser.InteractiveOption);
-        command.Options.Add(PackageListCommandParser.FormatOption);
-        command.Options.Add(PackageListCommandParser.OutputVersionOption);
-        command.Options.Add(PackageListCommandParser.NoRestore);
-
-        command.SetAction((parseResult) => new PackageListCommand(parseResult).Execute());
-
-        return command;
-    }
-}
diff --git a/src/Cli/dotnet/Commands/Hidden/List/Reference/ListReferenceCommandParser.cs b/src/Cli/dotnet/Commands/Hidden/List/Reference/ListReferenceCommandDefinition.cs
similarity index 52%
rename from src/Cli/dotnet/Commands/Hidden/List/Reference/ListReferenceCommandParser.cs
rename to src/Cli/dotnet/Commands/Hidden/List/Reference/ListReferenceCommandDefinition.cs
index 6401f55aa0b9..75dd65165055 100644
--- a/src/Cli/dotnet/Commands/Hidden/List/Reference/ListReferenceCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Hidden/List/Reference/ListReferenceCommandDefinition.cs
@@ -1,32 +1,23 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
 using Microsoft.DotNet.Cli.Commands.Reference.List;
 
 namespace Microsoft.DotNet.Cli.Commands.Hidden.List.Reference;
 
-internal static class ListReferenceCommandParser
+internal static class ListReferenceCommandDefinition
 {
-    public static readonly Argument<string> Argument = new("argument") { Arity = ArgumentArity.ZeroOrOne, Hidden = true };
+    public const string Name = "reference";
 
-    private static readonly Command Command = ConstructCommand();
-
-    public static Command GetCommand()
-    {
-        return Command;
-    }
+    public static readonly Argument<string> Argument = new("argument") { Arity = ArgumentArity.ZeroOrOne, Hidden = true };
 
-    private static Command ConstructCommand()
+    public static Command Create()
     {
-        var command = new Command("reference", CliCommandStrings.ReferenceListAppFullName);
+        var command = new Command(Name, CliCommandStrings.ReferenceListAppFullName);
 
         command.Arguments.Add(Argument);
 
-        command.SetAction((parseResult) => new ReferenceListCommand(parseResult).Execute());
-
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Hidden/Parse/ParseCommandDefinition.cs b/src/Cli/dotnet/Commands/Hidden/Parse/ParseCommandDefinition.cs
new file mode 100644
index 000000000000..419e1ddd4bc7
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Hidden/Parse/ParseCommandDefinition.cs
@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+
+namespace Microsoft.DotNet.Cli.Commands.Hidden.Parse;
+
+internal static class ParseCommandDefinition
+{
+    public static Command Create()
+        => new("parse")
+        {
+            Hidden = true
+        };
+}
diff --git a/src/Cli/dotnet/Commands/Hidden/Parse/ParseCommandParser.cs b/src/Cli/dotnet/Commands/Hidden/Parse/ParseCommandParser.cs
index 14ef8cc1a26b..4049bde2df92 100644
--- a/src/Cli/dotnet/Commands/Hidden/Parse/ParseCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Hidden/Parse/ParseCommandParser.cs
@@ -1,30 +1,22 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
 
 namespace Microsoft.DotNet.Cli.Commands.Hidden.Parse;
 
 internal static class ParseCommandParser
 {
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = SetAction(ParseCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command SetAction(Command command)
     {
-        var command = new Command("parse")
-        {
-            Hidden = true
-        };
-
         command.SetAction(ParseCommand.Run);
-
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Hidden/Remove/Package/RemovePackageCommandDefinition.cs b/src/Cli/dotnet/Commands/Hidden/Remove/Package/RemovePackageCommandDefinition.cs
new file mode 100644
index 000000000000..2739d53e1b3c
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Hidden/Remove/Package/RemovePackageCommandDefinition.cs
@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Package.Remove;
+
+namespace Microsoft.DotNet.Cli.Commands.Hidden.Remove.Package;
+
+internal static class RemovePackageCommandDefinition
+{
+    public const string Name = "package";
+
+    public static Command Create()
+    {
+        var command = new Command(Name, CliCommandStrings.PackageRemoveAppFullName);
+
+        command.Arguments.Add(PackageRemoveCommandDefinition.CmdPackageArgument);
+        command.Options.Add(PackageRemoveCommandDefinition.InteractiveOption);
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Hidden/Remove/Package/RemovePackageCommandParser.cs b/src/Cli/dotnet/Commands/Hidden/Remove/Package/RemovePackageCommandParser.cs
deleted file mode 100644
index 51eb32535cc2..000000000000
--- a/src/Cli/dotnet/Commands/Hidden/Remove/Package/RemovePackageCommandParser.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.CommandLine;
-using Microsoft.DotNet.Cli.Commands.Package.Remove;
-
-namespace Microsoft.DotNet.Cli.Commands.Hidden.Remove.Package;
-
-internal static class RemovePackageCommandParser
-{
-    private static readonly Command Command = ConstructCommand();
-
-    public static Command GetCommand()
-    {
-        return Command;
-    }
-
-    private static Command ConstructCommand()
-    {
-        var command = new Command("package", CliCommandStrings.PackageRemoveAppFullName);
-
-        command.Arguments.Add(PackageRemoveCommandParser.CmdPackageArgument);
-        command.Options.Add(PackageRemoveCommandParser.InteractiveOption);
-
-        command.SetAction((parseResult) => new PackageRemoveCommand(parseResult).Execute());
-
-        return command;
-    }
-}
diff --git a/src/Cli/dotnet/Commands/Hidden/Remove/Reference/RemoveReferenceCommandDefinition.cs b/src/Cli/dotnet/Commands/Hidden/Remove/Reference/RemoveReferenceCommandDefinition.cs
new file mode 100644
index 000000000000..c792f9f6eac3
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Hidden/Remove/Reference/RemoveReferenceCommandDefinition.cs
@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Reference.Remove;
+
+namespace Microsoft.DotNet.Cli.Commands.Hidden.Remove.Reference;
+
+internal static class RemoveReferenceCommandDefinition
+{
+    public const string Name = "reference";
+
+    public static Command Create()
+    {
+        var command = new Command(Name, CliCommandStrings.ReferenceRemoveAppFullName);
+
+        command.Arguments.Add(ReferenceRemoveCommandDefinition.ProjectPathArgument);
+        command.Options.Add(ReferenceRemoveCommandDefinition.FrameworkOption);
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Hidden/Remove/Reference/RemoveReferenceCommandParser.cs b/src/Cli/dotnet/Commands/Hidden/Remove/Reference/RemoveReferenceCommandParser.cs
deleted file mode 100644
index d0ab77efebbf..000000000000
--- a/src/Cli/dotnet/Commands/Hidden/Remove/Reference/RemoveReferenceCommandParser.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-using System.CommandLine;
-using Microsoft.DotNet.Cli.Commands.Reference.Remove;
-
-namespace Microsoft.DotNet.Cli.Commands.Hidden.Remove.Reference;
-
-internal static class RemoveReferenceCommandParser
-{
-    private static readonly Command Command = ConstructCommand();
-
-    public static Command GetCommand()
-    {
-        return Command;
-    }
-
-    private static Command ConstructCommand()
-    {
-        var command = new Command("reference", CliCommandStrings.ReferenceRemoveAppFullName);
-
-        command.Arguments.Add(ReferenceRemoveCommandParser.ProjectPathArgument);
-        command.Options.Add(ReferenceRemoveCommandParser.FrameworkOption);
-
-        command.SetAction((parseResult) => new ReferenceRemoveCommand(parseResult).Execute());
-
-        return command;
-    }
-}
diff --git a/src/Cli/dotnet/Commands/Hidden/Remove/RemoveCommandDefinition.cs b/src/Cli/dotnet/Commands/Hidden/Remove/RemoveCommandDefinition.cs
new file mode 100644
index 000000000000..fdcddea6ed61
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Hidden/Remove/RemoveCommandDefinition.cs
@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Hidden.Remove.Package;
+using Microsoft.DotNet.Cli.Commands.Hidden.Remove.Reference;
+using Microsoft.DotNet.Cli.Commands.Package;
+
+namespace Microsoft.DotNet.Cli.Commands.Hidden.Remove;
+
+internal static class RemoveCommandDefinition
+{
+    public const string Name = "remove";
+
+    public static readonly string DocsLink = "https://aka.ms/dotnet-remove";
+
+    public static Command Create()
+    {
+        var command = new Command(Name, CliCommandStrings.NetRemoveCommand)
+        {
+            Hidden = true,
+            DocsLink = DocsLink
+        };
+
+        command.Arguments.Add(PackageCommandDefinition.ProjectOrFileArgument);
+        command.Subcommands.Add(RemovePackageCommandDefinition.Create());
+        command.Subcommands.Add(RemoveReferenceCommandDefinition.Create());
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Hidden/Remove/RemoveCommandParser.cs b/src/Cli/dotnet/Commands/Hidden/Remove/RemoveCommandParser.cs
index a91ed69540f8..880ac90bc426 100644
--- a/src/Cli/dotnet/Commands/Hidden/Remove/RemoveCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Hidden/Remove/RemoveCommandParser.cs
@@ -4,37 +4,28 @@
 using System.CommandLine;
 using Microsoft.DotNet.Cli.Commands.Hidden.Remove.Package;
 using Microsoft.DotNet.Cli.Commands.Hidden.Remove.Reference;
-using Microsoft.DotNet.Cli.Commands.Package;
-using Microsoft.DotNet.Cli.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Package.Remove;
+using Microsoft.DotNet.Cli.Commands.Reference.Remove;
 using Microsoft.DotNet.Cli.Extensions;
 
 namespace Microsoft.DotNet.Cli.Commands.Hidden.Remove;
 
 internal static class RemoveCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-remove";
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = ConfigureCommand(RemoveCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command ConfigureCommand(Command command)
     {
-        var command = new Command("remove", CliCommandStrings.NetRemoveCommand)
-        {
-            Hidden = true,
-            DocsLink = DocsLink
-        };
-
-        command.Arguments.Add(PackageCommandParser.ProjectOrFileArgument);
-        command.Subcommands.Add(RemovePackageCommandParser.GetCommand());
-        command.Subcommands.Add(RemoveReferenceCommandParser.GetCommand());
-
         command.SetAction((parseResult) => parseResult.HandleMissingCommand());
 
+        command.Subcommands.Single(c => c.Name == RemovePackageCommandDefinition.Name).SetAction((parseResult) => new PackageRemoveCommand(parseResult).Execute());
+        command.Subcommands.Single(c => c.Name == RemoveReferenceCommandDefinition.Name).SetAction((parseResult) => new ReferenceRemoveCommand(parseResult).Execute());
+
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/MSBuild/MSBuildCommand.cs b/src/Cli/dotnet/Commands/MSBuild/MSBuildCommand.cs
index 7e28945067a3..ce0be333fbdc 100644
--- a/src/Cli/dotnet/Commands/MSBuild/MSBuildCommand.cs
+++ b/src/Cli/dotnet/Commands/MSBuild/MSBuildCommand.cs
@@ -15,7 +15,7 @@ public class MSBuildCommand(
         [.. msbuildArgs],
         CommonOptions.PropertiesOption,
         CommonOptions.RestorePropertiesOption,
-        MSBuildCommandParser.TargetOption,
+        MSBuildCommandDefinition.TargetOption,
         CommonOptions.VerbosityOption(),
         // We set the no-logo option to false here to ensure that by default the logo is shown for this command.
         // This is different from other commands that default to hiding the logo - but this command is meant to mimic
@@ -32,7 +32,7 @@ public static MSBuildCommand FromArgs(string[] args, string? msbuildPath = null)
     public static MSBuildCommand FromParseResult(ParseResult parseResult, string? msbuildPath = null)
     {
         var msbuildArgs = new List<string>();
-        msbuildArgs.AddRange(parseResult.GetValue(MSBuildCommandParser.Arguments) ?? []);
+        msbuildArgs.AddRange(parseResult.GetValue(MSBuildCommandDefinition.Arguments) ?? []);
         msbuildArgs.AddRange(parseResult.OptionValuesToBeForwarded(MSBuildCommandParser.GetCommand()));
 
         MSBuildCommand command = new(
diff --git a/src/Cli/dotnet/Commands/MSBuild/MSBuildCommandDefinition.cs b/src/Cli/dotnet/Commands/MSBuild/MSBuildCommandDefinition.cs
new file mode 100644
index 000000000000..43a48acd4459
--- /dev/null
+++ b/src/Cli/dotnet/Commands/MSBuild/MSBuildCommandDefinition.cs
@@ -0,0 +1,29 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
+
+namespace Microsoft.DotNet.Cli.Commands.MSBuild;
+
+internal static class MSBuildCommandDefinition
+{
+    public static readonly string DocsLink = "https://aka.ms/dotnet-msbuild";
+
+    public static readonly Argument<string[]> Arguments = new("arguments");
+    public static readonly Option<string[]?> TargetOption = CommonOptions.MSBuildTargetOption();
+
+    public static Command Create()
+    {
+        var command = new Command("msbuild", CliCommandStrings.BuildAppFullName)
+        {
+            Arguments = { Arguments },
+            DocsLink = DocsLink,
+        };
+
+        command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(TargetOption);
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/MSBuild/MSBuildCommandParser.cs b/src/Cli/dotnet/Commands/MSBuild/MSBuildCommandParser.cs
index 5893570d7be2..f5484ef3fe5f 100644
--- a/src/Cli/dotnet/Commands/MSBuild/MSBuildCommandParser.cs
+++ b/src/Cli/dotnet/Commands/MSBuild/MSBuildCommandParser.cs
@@ -2,36 +2,21 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
-using Microsoft.DotNet.Cli.CommandLine;
 
 namespace Microsoft.DotNet.Cli.Commands.MSBuild;
 
 internal static class MSBuildCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-msbuild";
-
-    public static readonly Argument<string[]> Arguments = new("arguments");
-    public static readonly Option<string[]?> TargetOption = CommonOptions.MSBuildTargetOption();
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = ConfigureCommand(MSBuildCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command ConfigureCommand(Command command)
     {
-        var command = new Command("msbuild", CliCommandStrings.BuildAppFullName)
-        {
-            Arguments = { Arguments },
-            DocsLink = DocsLink,
-        };
-
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
-        command.Options.Add(TargetOption);
         command.SetAction(MSBuildCommand.Run);
-
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/New/DotnetCommandCallbacks.cs b/src/Cli/dotnet/Commands/New/DotnetCommandCallbacks.cs
index 4aae2f0f037e..9de29fe2287e 100644
--- a/src/Cli/dotnet/Commands/New/DotnetCommandCallbacks.cs
+++ b/src/Cli/dotnet/Commands/New/DotnetCommandCallbacks.cs
@@ -19,7 +19,7 @@ internal static bool AddPackageReference(string projectPath, string packageName,
         IEnumerable<string> commandArgs = ["add", projectPath, "package", packageName];
         if (!string.IsNullOrWhiteSpace(version))
         {
-            commandArgs = commandArgs.Append(PackageAddCommandParser.VersionOption.Name).Append(version);
+            commandArgs = commandArgs.Append(PackageAddCommandDefinition.VersionOption.Name).Append(version);
         }
         var addPackageReferenceCommand = new PackageAddCommand(AddCommandParser.GetCommand().Parse([.. commandArgs]));
         return addPackageReferenceCommand.Execute() == 0;
@@ -48,12 +48,12 @@ internal static bool AddProjectsToSolution(string solutionPath, IReadOnlyList<st
         IEnumerable<string> commandArgs = new[] { "solution", solutionPath, "add" }.Concat(projectsToAdd);
         if (!string.IsNullOrWhiteSpace(solutionFolder))
         {
-            commandArgs = commandArgs.Append(SolutionAddCommandParser.SolutionFolderOption.Name).Append(solutionFolder);
+            commandArgs = commandArgs.Append(SolutionAddCommandDefinition.SolutionFolderOption.Name).Append(solutionFolder);
         }
 
         if (inRoot is true)
         {
-            commandArgs = commandArgs.Append(SolutionAddCommandParser.InRootOption.Name);
+            commandArgs = commandArgs.Append(SolutionAddCommandDefinition.InRootOption.Name);
         }
         var addProjectToSolutionCommand = new SolutionAddCommand(SolutionCommandParser.GetCommand().Parse([.. commandArgs]));
         return addProjectToSolutionCommand.Execute() == 0;
diff --git a/src/Cli/dotnet/Commands/NuGet/NuGetCommandDefinition.cs b/src/Cli/dotnet/Commands/NuGet/NuGetCommandDefinition.cs
new file mode 100644
index 000000000000..aedfc8c40898
--- /dev/null
+++ b/src/Cli/dotnet/Commands/NuGet/NuGetCommandDefinition.cs
@@ -0,0 +1,249 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
+using NuGetWhyCommand = NuGet.CommandLine.XPlat.Commands.Why.WhyCommand;
+
+namespace Microsoft.DotNet.Cli.Commands.NuGet;
+
+// This parser is used for completion and telemetry.
+// See https://github.com/NuGet/NuGet.Client for the actual implementation.
+internal static class NuGetCommandDefinition
+{
+    public static readonly string DocsLink = "https://aka.ms/dotnet-nuget";
+
+    public static Command Create()
+    {
+        var command = new Command("nuget")
+        {
+            // some subcommands are not defined here and just forwarded to NuGet app
+            TreatUnmatchedTokensAsErrors = false,
+            DocsLink = DocsLink
+        };
+
+        command.Options.Add(new Option<bool>("--version")
+        {
+            Arity = ArgumentArity.Zero
+        });
+        command.Options.Add(new Option<string>("--verbosity", "-v"));
+
+        command.Subcommands.Add(CreateDeleteCommand());
+        command.Subcommands.Add(CreateLocalsCommand());
+        command.Subcommands.Add(CreatePushCommand());
+        command.Subcommands.Add(CreateVerifyCommand());
+        command.Subcommands.Add(CreateTrustCommand());
+        command.Subcommands.Add(CreateSignCommand());
+        NuGetWhyCommand.GetWhyCommand(command);
+
+        return command;
+    }
+
+    private static Command CreateDeleteCommand()
+    {
+        Command deleteCommand = new("delete");
+        deleteCommand.Arguments.Add(new Argument<IEnumerable<string>>("package-paths") { Arity = ArgumentArity.OneOrMore });
+        deleteCommand.Options.Add(new Option<bool>("--force-english-output")
+        {
+            Arity = ArgumentArity.Zero
+        });
+        deleteCommand.Options.Add(new Option<string>("--source", "-s"));
+        deleteCommand.Options.Add(new Option<bool>("--non-interactive")
+        {
+            Arity = ArgumentArity.Zero
+        });
+        deleteCommand.Options.Add(new Option<string>("--api-key", "-k"));
+        deleteCommand.Options.Add(new Option<bool>("--no-service-endpoint")
+        {
+            Arity = ArgumentArity.Zero
+        });
+        deleteCommand.Options.Add(CommonOptions.InteractiveOption());
+
+        return deleteCommand;
+    }
+
+    private static Command CreateLocalsCommand()
+    {
+        Command localsCommand = new("locals");
+
+        Argument<string> foldersArgument = new("folders");
+        foldersArgument.AcceptOnlyFromAmong(["all", "http-cache", "global-packages", "plugins-cache", "temp"]);
+
+        localsCommand.Arguments.Add(foldersArgument);
+
+        localsCommand.Options.Add(new Option<bool>("--force-english-output")
+        {
+            Arity = ArgumentArity.Zero
+        });
+        localsCommand.Options.Add(new Option<bool>("--clear", "-c")
+        {
+            Arity = ArgumentArity.Zero
+        });
+        localsCommand.Options.Add(new Option<bool>("--list", "-l")
+        {
+            Arity = ArgumentArity.Zero
+        });
+
+        return localsCommand;
+    }
+
+    private static Command CreatePushCommand()
+    {
+        Command pushCommand = new("push");
+
+        pushCommand.Arguments.Add(new Argument<IEnumerable<string>>("package-paths") { Arity = ArgumentArity.OneOrMore });
+
+        pushCommand.Options.Add(new Option<bool>("--force-english-output")
+        {
+            Arity = ArgumentArity.Zero
+        });
+        pushCommand.Options.Add(new Option<string>("--source", "-s"));
+        pushCommand.Options.Add(new Option<string>("--symbol-source", "-ss"));
+        pushCommand.Options.Add(new Option<string>("--timeout", "-t"));
+        pushCommand.Options.Add(new Option<string>("--api-key", "-k"));
+        pushCommand.Options.Add(new Option<string>("--symbol-api-key", "-sk"));
+        pushCommand.Options.Add(new Option<bool>("--disable-buffering", "-d")
+        {
+            Arity = ArgumentArity.Zero
+        });
+        pushCommand.Options.Add(new Option<bool>("--no-symbols", "-n")
+        {
+            Arity = ArgumentArity.Zero
+        });
+        pushCommand.Options.Add(new Option<bool>("--no-service-endpoint")
+        {
+            Arity = ArgumentArity.Zero
+        });
+        pushCommand.Options.Add(CommonOptions.InteractiveOption());
+        pushCommand.Options.Add(new Option<bool>("--skip-duplicate")
+        {
+            Arity = ArgumentArity.Zero
+        });
+        pushCommand.Options.Add(new Option<string>("--configfile"));
+
+        return pushCommand;
+    }
+
+    private static Command CreateVerifyCommand()
+    {
+        const string fingerprint = "--certificate-fingerprint";
+        Command verifyCommand = new("verify");
+
+        verifyCommand.Arguments.Add(new Argument<IEnumerable<string>>("package-paths") { Arity = ArgumentArity.OneOrMore });
+
+        verifyCommand.Options.Add(new Option<bool>("--all")
+        {
+            Arity = ArgumentArity.Zero
+        });
+        verifyCommand.Options.Add(new Option<IEnumerable<string>>(fingerprint)
+            .ForwardAsManyArgumentsEachPrefixedByOption(fingerprint)
+            .AllowSingleArgPerToken());
+        verifyCommand.Options.Add(CommonOptions.VerbosityOption(Utils.VerbosityOptions.normal));
+
+        return verifyCommand;
+    }
+
+    private static Command CreateTrustCommand()
+    {
+        Command trustCommand = new("trust");
+
+        Option<bool> allowUntrustedRoot = new("--allow-untrusted-root")
+        {
+            Arity = ArgumentArity.Zero
+        };
+        Option<string> owners = new("--owners");
+
+        trustCommand.Subcommands.Add(new Command("list"));
+        trustCommand.Subcommands.Add(CreateAuthorCommand());
+        trustCommand.Subcommands.Add(CreateRepositoryCommand());
+        trustCommand.Subcommands.Add(CreateSourceCommand());
+        trustCommand.Subcommands.Add(CreateCertificateCommand());
+        trustCommand.Subcommands.Add(CreateRemoveCommand());
+        trustCommand.Subcommands.Add(CreateSyncCommand());
+
+        Option<string> configFile = new("--configfile");
+
+        // now set global options for all nuget commands: configfile, verbosity
+        // as well as the standard NugetCommand.Run handler
+
+        trustCommand.Options.Add(configFile);
+        trustCommand.Options.Add(CommonOptions.VerbosityOption(Utils.VerbosityOptions.normal));
+
+        foreach (var command in trustCommand.Subcommands)
+        {
+            command.Options.Add(configFile);
+            command.Options.Add(CommonOptions.VerbosityOption(Utils.VerbosityOptions.normal));
+        }
+
+        Command CreateAuthorCommand() => new("author") {
+            new Argument<string>("NAME"),
+            new Argument<string>("PACKAGE"),
+            allowUntrustedRoot,
+        };
+
+        Command CreateRepositoryCommand() => new("repository") {
+            new Argument<string>("NAME"),
+            new Argument<string>("PACKAGE"),
+            allowUntrustedRoot,
+            owners
+        };
+
+        Command CreateSourceCommand() => new("source") {
+            new Argument<string>("NAME"),
+            owners,
+            new Option<string>("--source-url"),
+        };
+
+        Command CreateCertificateCommand()
+        {
+            Option<string> algorithm = new("--algorithm")
+            {
+                DefaultValueFactory = (_argResult) => "SHA256"
+            };
+            algorithm.AcceptOnlyFromAmong("SHA256", "SHA384", "SHA512");
+
+            return new Command("certificate") {
+                new Argument<string>("NAME"),
+                new Argument<string>("FINGERPRINT"),
+                allowUntrustedRoot,
+                algorithm
+            };
+        }
+        ;
+
+        Command CreateRemoveCommand() => new("remove") {
+            new Argument<string>("NAME"),
+        };
+
+        Command CreateSyncCommand() => new("sync") {
+            new Argument<string>("NAME"),
+        };
+
+        return trustCommand;
+    }
+
+    private static Command CreateSignCommand()
+    {
+        Command signCommand = new("sign");
+
+        signCommand.Arguments.Add(new Argument<IEnumerable<string>>("package-paths") { Arity = ArgumentArity.OneOrMore });
+
+        signCommand.Options.Add(new Option<string>("--output", "-o"));
+        signCommand.Options.Add(new Option<string>("--certificate-path"));
+        signCommand.Options.Add(new Option<string>("--certificate-store-name"));
+        signCommand.Options.Add(new Option<string>("--certificate-store-location"));
+        signCommand.Options.Add(new Option<string>("--certificate-subject-name"));
+        signCommand.Options.Add(new Option<string>("--certificate-fingerprint"));
+        signCommand.Options.Add(new Option<string>("--certificate-password"));
+        signCommand.Options.Add(new Option<string>("--hash-algorithm"));
+        signCommand.Options.Add(new Option<string>("--timestamper"));
+        signCommand.Options.Add(new Option<string>("--timestamp-hash-algorithm"));
+        signCommand.Options.Add(new Option<bool>("--overwrite")
+        {
+            Arity = ArgumentArity.Zero
+        });
+        signCommand.Options.Add(CommonOptions.VerbosityOption(Utils.VerbosityOptions.normal));
+
+        return signCommand;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/NuGet/NuGetCommandParser.cs b/src/Cli/dotnet/Commands/NuGet/NuGetCommandParser.cs
index 814ad45f8544..89c0af1d020d 100644
--- a/src/Cli/dotnet/Commands/NuGet/NuGetCommandParser.cs
+++ b/src/Cli/dotnet/Commands/NuGet/NuGetCommandParser.cs
@@ -2,269 +2,28 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
-using Microsoft.DotNet.Cli.CommandLine;
-using NuGetWhyCommand = NuGet.CommandLine.XPlat.Commands.Why.WhyCommand;
 
 namespace Microsoft.DotNet.Cli.Commands.NuGet;
 
-// This parser is used for completion and telemetry.
-// See https://github.com/NuGet/NuGet.Client for the actual implementation.
 internal static class NuGetCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-nuget";
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = SetAction(NuGetCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command SetAction(Command command)
     {
-        var command = new Command("nuget")
-        {
-            // some subcommands are not defined here and just forwarded to NuGet app
-            TreatUnmatchedTokensAsErrors = false,
-            DocsLink = DocsLink
-        };
-
-        command.Options.Add(new Option<bool>("--version")
-        {
-            Arity = ArgumentArity.Zero
-        });
-        command.Options.Add(new Option<string>("--verbosity", "-v"));
-
-        command.Subcommands.Add(GetDeleteCommand());
-        command.Subcommands.Add(GetLocalsCommand());
-        command.Subcommands.Add(GetPushCommand());
-        command.Subcommands.Add(GetVerifyCommand());
-        command.Subcommands.Add(GetTrustCommand());
-        command.Subcommands.Add(GetSignCommand());
-        NuGetWhyCommand.GetWhyCommand(command);
-
         command.SetAction(NuGetCommand.Run);
 
-        return command;
-    }
-
-    private static Command GetDeleteCommand()
-    {
-        Command deleteCommand = new("delete");
-        deleteCommand.Arguments.Add(new Argument<IEnumerable<string>>("package-paths") { Arity = ArgumentArity.OneOrMore });
-        deleteCommand.Options.Add(new Option<bool>("--force-english-output")
-        {
-            Arity = ArgumentArity.Zero
-        });
-        deleteCommand.Options.Add(new Option<string>("--source", "-s"));
-        deleteCommand.Options.Add(new Option<bool>("--non-interactive")
-        {
-            Arity = ArgumentArity.Zero
-        });
-        deleteCommand.Options.Add(new Option<string>("--api-key", "-k"));
-        deleteCommand.Options.Add(new Option<bool>("--no-service-endpoint")
-        {
-            Arity = ArgumentArity.Zero
-        });
-        deleteCommand.Options.Add(CommonOptions.InteractiveOption());
-
-        deleteCommand.SetAction(NuGetCommand.Run);
-
-        return deleteCommand;
-    }
-
-    private static Command GetLocalsCommand()
-    {
-        Command localsCommand = new("locals");
-
-        Argument<string> foldersArgument = new("folders");
-        foldersArgument.AcceptOnlyFromAmong(["all", "http-cache", "global-packages", "plugins-cache", "temp"]);
-
-        localsCommand.Arguments.Add(foldersArgument);
-
-        localsCommand.Options.Add(new Option<bool>("--force-english-output")
-        {
-            Arity = ArgumentArity.Zero
-        });
-        localsCommand.Options.Add(new Option<bool>("--clear", "-c")
+        foreach (var subcommand in command.Subcommands)
         {
-            Arity = ArgumentArity.Zero
-        });
-        localsCommand.Options.Add(new Option<bool>("--list", "-l")
-        {
-            Arity = ArgumentArity.Zero
-        });
-
-        localsCommand.SetAction(NuGetCommand.Run);
-
-        return localsCommand;
-    }
-
-    private static Command GetPushCommand()
-    {
-        Command pushCommand = new("push");
-
-        pushCommand.Arguments.Add(new Argument<IEnumerable<string>>("package-paths") { Arity = ArgumentArity.OneOrMore });
-
-        pushCommand.Options.Add(new Option<bool>("--force-english-output")
-        {
-            Arity = ArgumentArity.Zero
-        });
-        pushCommand.Options.Add(new Option<string>("--source", "-s"));
-        pushCommand.Options.Add(new Option<string>("--symbol-source", "-ss"));
-        pushCommand.Options.Add(new Option<string>("--timeout", "-t"));
-        pushCommand.Options.Add(new Option<string>("--api-key", "-k"));
-        pushCommand.Options.Add(new Option<string>("--symbol-api-key", "-sk"));
-        pushCommand.Options.Add(new Option<bool>("--disable-buffering", "-d")
-        {
-            Arity = ArgumentArity.Zero
-        });
-        pushCommand.Options.Add(new Option<bool>("--no-symbols", "-n")
-        {
-            Arity = ArgumentArity.Zero
-        });
-        pushCommand.Options.Add(new Option<bool>("--no-service-endpoint")
-        {
-            Arity = ArgumentArity.Zero
-        });
-        pushCommand.Options.Add(CommonOptions.InteractiveOption());
-        pushCommand.Options.Add(new Option<bool>("--skip-duplicate")
-        {
-            Arity = ArgumentArity.Zero
-        });
-        pushCommand.Options.Add(new Option<string>("--configfile"));
-
-        pushCommand.SetAction(NuGetCommand.Run);
-
-        return pushCommand;
-    }
-
-    private static Command GetVerifyCommand()
-    {
-        const string fingerprint = "--certificate-fingerprint";
-        Command verifyCommand = new("verify");
-
-        verifyCommand.Arguments.Add(new Argument<IEnumerable<string>>("package-paths") { Arity = ArgumentArity.OneOrMore });
-
-        verifyCommand.Options.Add(new Option<bool>("--all")
-        {
-            Arity = ArgumentArity.Zero
-        });
-        verifyCommand.Options.Add(new Option<IEnumerable<string>>(fingerprint)
-            .ForwardAsManyArgumentsEachPrefixedByOption(fingerprint)
-            .AllowSingleArgPerToken());
-        verifyCommand.Options.Add(CommonOptions.VerbosityOption(Utils.VerbosityOptions.normal));
-
-        verifyCommand.SetAction(NuGetCommand.Run);
-
-        return verifyCommand;
-    }
-
-    private static Command GetTrustCommand()
-    {
-        Command trustCommand = new("trust");
-
-        Option<bool> allowUntrustedRoot = new("--allow-untrusted-root")
-        {
-            Arity = ArgumentArity.Zero
-        };
-        Option<string> owners = new("--owners");
-
-        trustCommand.Subcommands.Add(new Command("list"));
-        trustCommand.Subcommands.Add(AuthorCommand());
-        trustCommand.Subcommands.Add(RepositoryCommand());
-        trustCommand.Subcommands.Add(SourceCommand());
-        trustCommand.Subcommands.Add(CertificateCommand());
-        trustCommand.Subcommands.Add(RemoveCommand());
-        trustCommand.Subcommands.Add(SyncCommand());
-
-        Option<string> configFile = new("--configfile");
-
-        // now set global options for all nuget commands: configfile, verbosity
-        // as well as the standard NugetCommand.Run handler
-
-        trustCommand.Options.Add(configFile);
-        trustCommand.Options.Add(CommonOptions.VerbosityOption(Utils.VerbosityOptions.normal));
-        trustCommand.SetAction(NuGetCommand.Run);
-
-        foreach (var command in trustCommand.Subcommands)
-        {
-            command.Options.Add(configFile);
-            command.Options.Add(CommonOptions.VerbosityOption(Utils.VerbosityOptions.normal));
-            command.SetAction(NuGetCommand.Run);
+            subcommand.SetAction(NuGetCommand.Run);
         }
 
-        Command AuthorCommand() => new("author") {
-            new Argument<string>("NAME"),
-            new Argument<string>("PACKAGE"),
-            allowUntrustedRoot,
-        };
-
-        Command RepositoryCommand() => new("repository") {
-            new Argument<string>("NAME"),
-            new Argument<string>("PACKAGE"),
-            allowUntrustedRoot,
-            owners
-        };
-
-        Command SourceCommand() => new("source") {
-            new Argument<string>("NAME"),
-            owners,
-            new Option<string>("--source-url"),
-        };
-
-        Command CertificateCommand()
-        {
-            Option<string> algorithm = new("--algorithm")
-            {
-                DefaultValueFactory = (_argResult) => "SHA256"
-            };
-            algorithm.AcceptOnlyFromAmong("SHA256", "SHA384", "SHA512");
-
-            return new Command("certificate") {
-                new Argument<string>("NAME"),
-                new Argument<string>("FINGERPRINT"),
-                allowUntrustedRoot,
-                algorithm
-            };
-        }
-        ;
-
-        Command RemoveCommand() => new("remove") {
-            new Argument<string>("NAME"),
-        };
-
-        Command SyncCommand() => new("sync") {
-            new Argument<string>("NAME"),
-        };
-
-        return trustCommand;
-    }
-
-    private static Command GetSignCommand()
-    {
-        Command signCommand = new("sign");
-
-        signCommand.Arguments.Add(new Argument<IEnumerable<string>>("package-paths") { Arity = ArgumentArity.OneOrMore });
-
-        signCommand.Options.Add(new Option<string>("--output", "-o"));
-        signCommand.Options.Add(new Option<string>("--certificate-path"));
-        signCommand.Options.Add(new Option<string>("--certificate-store-name"));
-        signCommand.Options.Add(new Option<string>("--certificate-store-location"));
-        signCommand.Options.Add(new Option<string>("--certificate-subject-name"));
-        signCommand.Options.Add(new Option<string>("--certificate-fingerprint"));
-        signCommand.Options.Add(new Option<string>("--certificate-password"));
-        signCommand.Options.Add(new Option<string>("--hash-algorithm"));
-        signCommand.Options.Add(new Option<string>("--timestamper"));
-        signCommand.Options.Add(new Option<string>("--timestamp-hash-algorithm"));
-        signCommand.Options.Add(new Option<bool>("--overwrite")
-        {
-            Arity = ArgumentArity.Zero
-        });
-        signCommand.Options.Add(CommonOptions.VerbosityOption(Utils.VerbosityOptions.normal));
-
-        signCommand.SetAction(NuGetCommand.Run);
-
-        return signCommand;
+        return command;
     }
 }
+
diff --git a/src/Cli/dotnet/Commands/Pack/PackCommand.cs b/src/Cli/dotnet/Commands/Pack/PackCommand.cs
index 9f31bfa145fe..fe36ed860367 100644
--- a/src/Cli/dotnet/Commands/Pack/PackCommand.cs
+++ b/src/Cli/dotnet/Commands/Pack/PackCommand.cs
@@ -31,17 +31,17 @@ public static CommandBase FromArgs(string[] args, string? msbuildPath = null)
 
     public static CommandBase FromParseResult(ParseResult parseResult, string? msbuildPath = null)
     {
-        var args = parseResult.GetValue(PackCommandParser.SlnOrProjectOrFileArgument) ?? [];
+        var args = parseResult.GetValue(PackCommandDefinition.SlnOrProjectOrFileArgument) ?? [];
 
         LoggerUtility.SeparateBinLogArguments(args, out var binLogArgs, out var nonBinLogArgs);
 
-        bool noBuild = parseResult.HasOption(PackCommandParser.NoBuildOption);
+        bool noBuild = parseResult.HasOption(PackCommandDefinition.NoBuildOption);
 
-        bool noRestore = noBuild || parseResult.HasOption(PackCommandParser.NoRestoreOption);
+        bool noRestore = noBuild || parseResult.HasOption(PackCommandDefinition.NoRestoreOption);
 
         return CommandFactory.CreateVirtualOrPhysicalCommand(
             PackCommandParser.GetCommand(),
-            PackCommandParser.SlnOrProjectOrFileArgument,
+            PackCommandDefinition.SlnOrProjectOrFileArgument,
             (msbuildArgs, appFilePath) => new VirtualProjectBuildingCommand(
                 entryPointFileFullPath: Path.GetFullPath(appFilePath),
                 msbuildArgs: msbuildArgs)
@@ -58,9 +58,9 @@ public static CommandBase FromParseResult(ParseResult parseResult, string? msbui
             [
                 CommonOptions.PropertiesOption,
                 CommonOptions.RestorePropertiesOption,
-                PackCommandParser.TargetOption,
-                PackCommandParser.VerbosityOption,
-                PackCommandParser.NoLogoOption
+                PackCommandDefinition.TargetOption,
+                PackCommandDefinition.VerbosityOption,
+                PackCommandDefinition.NoLogoOption
             ],
             parseResult,
             msbuildPath,
@@ -69,7 +69,7 @@ public static CommandBase FromParseResult(ParseResult parseResult, string? msbui
                 ReleasePropertyProjectLocator projectLocator = new(parseResult, MSBuildPropertyNames.PACK_RELEASE,
                     new ReleasePropertyProjectLocator.DependentCommandOptions(
                             nonBinLogArgs,
-                            parseResult.HasOption(PackCommandParser.ConfigurationOption) ? parseResult.GetValue(PackCommandParser.ConfigurationOption) : null
+                            parseResult.HasOption(PackCommandDefinition.ConfigurationOption) ? parseResult.GetValue(PackCommandDefinition.ConfigurationOption) : null
                         )
                 );
                 return msbuildArgs.CloneWithAdditionalProperties(projectLocator.GetCustomDefaultConfigurationValueIfSpecified());
@@ -90,22 +90,22 @@ private static LogLevel MappingVerbosityToNugetLogLevel(VerbosityOptions? verbos
 
     public static int RunPackCommand(ParseResult parseResult)
     {
-        var args = parseResult.GetValue(PackCommandParser.SlnOrProjectOrFileArgument)?.ToList() ?? new List<string>();
+        var args = parseResult.GetValue(PackCommandDefinition.SlnOrProjectOrFileArgument)?.ToList() ?? new List<string>();
 
         if (args.Count != 1)
         {
-            Console.Error.WriteLine(CliStrings.PackCmd_OneNuspecAllowed);
+            Console.Error.WriteLine(CliStrings.PackCmd_OneNuspecAllowed); 
             return 1;
         }
 
         var nuspecPath = args[0];
 
         var packArgs = new PackArgs()
-        {
+        { 
             Logger = new NuGetConsoleLogger(),
             Exclude = new List<string>(),
-            OutputDirectory = parseResult.GetValue(PackCommandParser.OutputOption),
-            LogLevel = MappingVerbosityToNugetLogLevel(parseResult.GetValue(BuildCommandParser.VerbosityOption)),
+            OutputDirectory = parseResult.GetValue(PackCommandDefinition.OutputOption),
+            LogLevel = MappingVerbosityToNugetLogLevel(parseResult.GetValue(BuildCommandDefinition.VerbosityOption)),
             Arguments = [nuspecPath]
         };
 
@@ -117,11 +117,11 @@ public static int RunPackCommand(ParseResult parseResult)
         if (globalProperties != null)
             packArgs.Properties.AddRange(globalProperties);
 
-        var version = parseResult.GetValue(PackCommandParser.VersionOption);
+        var version = parseResult.GetValue(PackCommandDefinition.VersionOption);
         if (version != null)
             packArgs.Version = version.ToNormalizedString();
 
-        var configuration = parseResult.GetValue(PackCommandParser.ConfigurationOption) ?? "Debug";
+        var configuration = parseResult.GetValue(PackCommandDefinition.ConfigurationOption) ?? "Debug";
         packArgs.Properties["configuration"] = configuration;
 
         var packCommandRunner = new PackCommandRunner(packArgs, null);
@@ -135,7 +135,7 @@ public static int Run(ParseResult parseResult)
         parseResult.HandleDebugSwitch();
         parseResult.ShowHelpOrErrorIfAppropriate();
 
-        var args = parseResult.GetValue(PackCommandParser.SlnOrProjectOrFileArgument)?.ToList() ?? new List<string>();
+        var args = parseResult.GetValue(PackCommandDefinition.SlnOrProjectOrFileArgument)?.ToList() ?? new List<string>();
 
         if (args.Count > 0 && Path.GetExtension(args[0]).Equals(".nuspec", StringComparison.OrdinalIgnoreCase))
         {
diff --git a/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs b/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
new file mode 100644
index 000000000000..100b5e42cc39
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Pack/PackCommandDefinition.cs
@@ -0,0 +1,114 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Build;
+using Microsoft.DotNet.Cli.Commands.Restore;
+using NuGet.Versioning;
+
+namespace Microsoft.DotNet.Cli.Commands.Pack;
+
+internal static class PackCommandDefinition
+{
+    public static readonly string DocsLink = "https://aka.ms/dotnet-pack";
+
+    public static readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
+    {
+        Description = CliStrings.SolutionOrProjectOrFileArgumentDescription,
+        Arity = ArgumentArity.ZeroOrMore
+    };
+
+    public static readonly Option<string> OutputOption = new Option<string>("--output", "-o")
+    {
+        Description = CliCommandStrings.PackCmdOutputDirDescription,
+        HelpName = CliCommandStrings.PackCmdOutputDir
+    }.ForwardAsSingle(o => $"-property:PackageOutputPath={CommandDirectoryContext.GetFullPath(o)}");
+
+    public static readonly Option<bool> NoBuildOption = new Option<bool>("--no-build")
+    {
+        Description = CliCommandStrings.CmdNoBuildOptionDescription,
+        Arity = ArgumentArity.Zero
+    }.ForwardAs("-property:NoBuild=true");
+
+    public static readonly Option<bool> IncludeSymbolsOption = new Option<bool>("--include-symbols")
+    {
+        Description = CliCommandStrings.CmdIncludeSymbolsDescription,
+        Arity = ArgumentArity.Zero
+    }.ForwardAs("-property:IncludeSymbols=true");
+
+    public static readonly Option<bool> IncludeSourceOption = new Option<bool>("--include-source")
+    {
+        Description = CliCommandStrings.CmdIncludeSourceDescription,
+        Arity = ArgumentArity.Zero
+    }.ForwardAs("-property:IncludeSource=true");
+
+    public static readonly Option<bool> ServiceableOption = new Option<bool>("--serviceable", "-s")
+    {
+        Description = CliCommandStrings.CmdServiceableDescription,
+        Arity = ArgumentArity.Zero
+    }.ForwardAs("-property:Serviceable=true");
+
+    public static readonly Option<bool> NoLogoOption = CommonOptions.NoLogoOption();
+
+    public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+
+    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(CliCommandStrings.PackConfigurationOptionDescription);
+
+    public static readonly Option<string[]> TargetOption = CommonOptions.RequiredMSBuildTargetOption("Pack", [("_IsPacking", "true")]);
+    public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = BuildCommandDefinition.VerbosityOption;
+
+    public static Option<NuGetVersion> VersionOption =
+        new Option<NuGetVersion>("--version")
+        {
+            Description = CliCommandStrings.PackCmdVersionDescription,
+            HelpName = CliCommandStrings.PackCmdVersion,
+            Arity = ArgumentArity.ExactlyOne,
+            CustomParser = r =>
+            {
+                if (r.Tokens.Count == 0)
+                    return null;
+                var value = r.Tokens[0].Value;
+                if (NuGetVersion.TryParse(value, out var version))
+                    return version;
+                r.AddError(string.Format(CliStrings.InvalidVersion, value));
+                return null;
+
+            }
+        }.ForwardAsSingle(o => $"--property:PackageVersion={o}");
+
+    public static Command Create()
+    {
+        var command = new Command("pack", CliCommandStrings.PackAppFullName)
+        {
+            DocsLink = DocsLink
+        };
+
+        command.Arguments.Add(SlnOrProjectOrFileArgument);
+        command.Options.Add(OutputOption);
+        command.Options.Add(CommonOptions.ArtifactsPathOption);
+        command.Options.Add(NoBuildOption);
+        command.Options.Add(IncludeSymbolsOption);
+        command.Options.Add(IncludeSourceOption);
+        command.Options.Add(ServiceableOption);
+        command.Options.Add(NoLogoOption);
+        command.Options.Add(CommonOptions.InteractiveMsBuildForwardOption);
+        command.Options.Add(NoRestoreOption);
+        command.Options.Add(VerbosityOption);
+        command.Options.Add(CommonOptions.VersionSuffixOption);
+        command.Options.Add(VersionOption);
+        command.Options.Add(ConfigurationOption);
+        command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(TargetOption);
+        command.Options.Add(CommonOptions.GetPropertyOption);
+        command.Options.Add(CommonOptions.GetItemOption);
+        command.Options.Add(CommonOptions.GetTargetResultOption);
+        command.Options.Add(CommonOptions.GetResultOutputFileOption);
+
+        // Don't include runtime option because we want to include it specifically and allow the short version ("-r") to be used
+        RestoreCommandDefinition.AddImplicitRestoreOptions(command, includeRuntimeOption: false, includeNoDependenciesOption: true);
+        command.Options.Add(CommonOptions.RuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription));
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Pack/PackCommandParser.cs b/src/Cli/dotnet/Commands/Pack/PackCommandParser.cs
index 23fc1ef58f69..577d3d2c9bb4 100644
--- a/src/Cli/dotnet/Commands/Pack/PackCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Pack/PackCommandParser.cs
@@ -2,122 +2,21 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
-using Microsoft.DotNet.Cli.CommandLine;
-using Microsoft.DotNet.Cli.Commands.Build;
-using Microsoft.DotNet.Cli.Commands.Restore;
-using NuGet.Versioning;
 
 namespace Microsoft.DotNet.Cli.Commands.Pack;
 
 internal static class PackCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-pack";
-
-    public static readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
-    {
-        Description = CliStrings.SolutionOrProjectOrFileArgumentDescription,
-        Arity = ArgumentArity.ZeroOrMore
-    };
-
-    public static readonly Option<string> OutputOption = new Option<string>("--output", "-o")
-    {
-        Description = CliCommandStrings.PackCmdOutputDirDescription,
-        HelpName = CliCommandStrings.PackCmdOutputDir
-    }.ForwardAsSingle(o => $"-property:PackageOutputPath={CommandDirectoryContext.GetFullPath(o)}");
-
-    public static readonly Option<bool> NoBuildOption = new Option<bool>("--no-build")
-    {
-        Description = CliCommandStrings.CmdNoBuildOptionDescription,
-        Arity = ArgumentArity.Zero
-    }.ForwardAs("-property:NoBuild=true");
-
-    public static readonly Option<bool> IncludeSymbolsOption = new Option<bool>("--include-symbols")
-    {
-        Description = CliCommandStrings.CmdIncludeSymbolsDescription,
-        Arity = ArgumentArity.Zero
-    }.ForwardAs("-property:IncludeSymbols=true");
-
-    public static readonly Option<bool> IncludeSourceOption = new Option<bool>("--include-source")
-    {
-        Description = CliCommandStrings.CmdIncludeSourceDescription,
-        Arity = ArgumentArity.Zero
-    }.ForwardAs("-property:IncludeSource=true");
-
-    public static readonly Option<bool> ServiceableOption = new Option<bool>("--serviceable", "-s")
-    {
-        Description = CliCommandStrings.CmdServiceableDescription,
-        Arity = ArgumentArity.Zero
-    }.ForwardAs("-property:Serviceable=true");
-
-    public static readonly Option<bool> NoLogoOption = CommonOptions.NoLogoOption();
-
-    public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
-
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(CliCommandStrings.PackConfigurationOptionDescription);
-
-    public static readonly Option<string[]> TargetOption = CommonOptions.RequiredMSBuildTargetOption("Pack", [("_IsPacking", "true")]);
-    public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = BuildCommandParser.VerbosityOption;
-
-    public static Option<NuGetVersion> VersionOption =
-        new Option<NuGetVersion>("--version")
-        {
-            Description = CliCommandStrings.PackCmdVersionDescription,
-            HelpName = CliCommandStrings.PackCmdVersion,
-            Arity = ArgumentArity.ExactlyOne,
-            CustomParser = r =>
-            {
-                if (r.Tokens.Count == 0)
-                    return null;
-                var value = r.Tokens[0].Value;
-                if (NuGetVersion.TryParse(value, out var version))
-                    return version;
-                r.AddError(string.Format(CliStrings.InvalidVersion, value));
-                return null;
-
-            }
-        }.ForwardAsSingle(o => $"--property:PackageVersion={o}");
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = SetAction(PackCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command SetAction(Command command)
     {
-        var command = new Command("pack", CliCommandStrings.PackAppFullName)
-        {
-            DocsLink = DocsLink
-        };
-
-        command.Arguments.Add(SlnOrProjectOrFileArgument);
-        command.Options.Add(OutputOption);
-        command.Options.Add(CommonOptions.ArtifactsPathOption);
-        command.Options.Add(NoBuildOption);
-        command.Options.Add(IncludeSymbolsOption);
-        command.Options.Add(IncludeSourceOption);
-        command.Options.Add(ServiceableOption);
-        command.Options.Add(NoLogoOption);
-        command.Options.Add(CommonOptions.InteractiveMsBuildForwardOption);
-        command.Options.Add(NoRestoreOption);
-        command.Options.Add(VerbosityOption);
-        command.Options.Add(CommonOptions.VersionSuffixOption);
-        command.Options.Add(VersionOption);
-        command.Options.Add(ConfigurationOption);
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
-        command.Options.Add(TargetOption);
-        command.Options.Add(CommonOptions.GetPropertyOption);
-        command.Options.Add(CommonOptions.GetItemOption);
-        command.Options.Add(CommonOptions.GetTargetResultOption);
-        command.Options.Add(CommonOptions.GetResultOutputFileOption);
-
-        // Don't include runtime option because we want to include it specifically and allow the short version ("-r") to be used
-        RestoreCommandParser.AddImplicitRestoreOptions(command, includeRuntimeOption: false, includeNoDependenciesOption: true);
-        command.Options.Add(CommonOptions.RuntimeOption(CliCommandStrings.BuildRuntimeOptionDescription));
-
         command.SetAction(PackCommand.Run);
-
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Package/Add/PackageAddCommand.cs b/src/Cli/dotnet/Commands/Package/Add/PackageAddCommand.cs
index a463165828cb..4353668c6d6c 100644
--- a/src/Cli/dotnet/Commands/Package/Add/PackageAddCommand.cs
+++ b/src/Cli/dotnet/Commands/Package/Add/PackageAddCommand.cs
@@ -19,11 +19,11 @@ namespace Microsoft.DotNet.Cli.Commands.Package.Add;
 
 internal class PackageAddCommand(ParseResult parseResult) : CommandBase(parseResult)
 {
-    private readonly PackageIdentityWithRange _packageId = parseResult.GetValue(PackageAddCommandParser.CmdPackageArgument)!;
+    private readonly PackageIdentityWithRange _packageId = parseResult.GetValue(PackageAddCommandDefinition.CmdPackageArgument)!;
 
     public override int Execute()
     {
-        var (fileOrDirectory, allowedAppKinds) = PackageCommandParser.ProcessPathOptions(_parseResult);
+        var (fileOrDirectory, allowedAppKinds) = PackageCommandDefinition.ProcessPathOptions(_parseResult);
 
         if (allowedAppKinds.HasFlag(AppKinds.FileBased) && VirtualProjectBuildingCommand.IsValidEntryPointPath(fileOrDirectory))
         {
@@ -44,7 +44,7 @@ public override int Execute()
 
         var tempDgFilePath = string.Empty;
 
-        if (!_parseResult.GetValue(PackageAddCommandParser.NoRestoreOption))
+        if (!_parseResult.GetValue(PackageAddCommandDefinition.NoRestoreOption))
         {
 
             try
@@ -134,7 +134,7 @@ private string[] TransformArgs(PackageIdentityWithRange packageId, string tempDg
             .OptionValuesToBeForwarded()
             .SelectMany(a => a.Split(' ', 2)));
 
-        if (_parseResult.GetValue(PackageAddCommandParser.NoRestoreOption))
+        if (_parseResult.GetValue(PackageAddCommandDefinition.NoRestoreOption))
         {
             args.Add("--no-restore");
         }
@@ -153,9 +153,9 @@ private int ExecuteForFileBasedApp(string path)
         // Check disallowed options.
         ReadOnlySpan<Option> disallowedOptions =
         [
-            PackageAddCommandParser.FrameworkOption,
-            PackageAddCommandParser.SourceOption,
-            PackageAddCommandParser.PackageDirOption,
+            PackageAddCommandDefinition.FrameworkOption,
+            PackageAddCommandDefinition.SourceOption,
+            PackageAddCommandDefinition.PackageDirOption,
         ];
         foreach (var option in disallowedOptions)
         {
@@ -167,8 +167,8 @@ private int ExecuteForFileBasedApp(string path)
 
         string? specifiedVersion = _packageId.HasVersion
             ? _packageId.VersionRange?.OriginalString ?? string.Empty
-            : _parseResult.GetValue(PackageAddCommandParser.VersionOption);
-        bool prerelease = _parseResult.GetValue(PackageAddCommandParser.PrereleaseOption);
+            : _parseResult.GetValue(PackageAddCommandDefinition.VersionOption);
+        bool prerelease = _parseResult.GetValue(PackageAddCommandDefinition.PrereleaseOption);
 
         if (specifiedVersion != null && prerelease)
         {
@@ -178,7 +178,7 @@ private int ExecuteForFileBasedApp(string path)
         var fullPath = Path.GetFullPath(path);
 
         // Create restore command, used also for obtaining MSBuild properties.
-        bool interactive = _parseResult.GetValue(PackageAddCommandParser.InteractiveOption);
+        bool interactive = _parseResult.GetValue(PackageAddCommandDefinition.InteractiveOption);
         var command = new VirtualProjectBuildingCommand(
             entryPointFileFullPath: fullPath,
             msbuildArgs: MSBuildArgs.FromProperties(new Dictionary<string, string>(2)
@@ -202,7 +202,7 @@ private int ExecuteForFileBasedApp(string path)
         var central = SetCentralVersion(version);
         var local = SetLocalVersion(central != null ? null : version);
 
-        if (!_parseResult.GetValue(PackageAddCommandParser.NoRestoreOption))
+        if (!_parseResult.GetValue(PackageAddCommandDefinition.NoRestoreOption))
         {
             // Restore.
             int exitCode = command.Execute();
diff --git a/src/Cli/dotnet/Commands/Package/Add/PackageAddCommandParser.cs b/src/Cli/dotnet/Commands/Package/Add/PackageAddCommandDefinition.cs
similarity index 91%
rename from src/Cli/dotnet/Commands/Package/Add/PackageAddCommandParser.cs
rename to src/Cli/dotnet/Commands/Package/Add/PackageAddCommandDefinition.cs
index ad5c1270896f..a9cc72c22f4e 100644
--- a/src/Cli/dotnet/Commands/Package/Add/PackageAddCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Package/Add/PackageAddCommandDefinition.cs
@@ -11,8 +11,10 @@
 
 namespace Microsoft.DotNet.Cli.Commands.Package.Add;
 
-public static class PackageAddCommandParser
+public static class PackageAddCommandDefinition
 {
+    public const string Name = "add";
+
     public static readonly Option<bool> PrereleaseOption = new Option<bool>("--prerelease")
     {
         Description = CliStrings.CommandPrereleaseOptionDescription,
@@ -76,16 +78,9 @@ public static class PackageAddCommandParser
 
     public static readonly Option<bool> InteractiveOption = CommonOptions.InteractiveOption().ForwardIfEnabled("--interactive");
 
-    private static readonly Command Command = ConstructCommand();
-
-    public static Command GetCommand()
-    {
-        return Command;
-    }
-
-    private static Command ConstructCommand()
+    public static Command Create()
     {
-        Command command = new("add", CliCommandStrings.PackageAddAppFullName);
+        Command command = new(Name, CliCommandStrings.PackageAddAppFullName);
 
         VersionOption.Validators.Add(DisallowVersionIfPackageIdentityHasVersionValidator);
         command.Arguments.Add(CmdPackageArgument);
@@ -96,10 +91,8 @@ private static Command ConstructCommand()
         command.Options.Add(PackageDirOption);
         command.Options.Add(InteractiveOption);
         command.Options.Add(PrereleaseOption);
-        command.Options.Add(PackageCommandParser.ProjectOption);
-        command.Options.Add(PackageCommandParser.FileOption);
-
-        command.SetAction((parseResult) => new PackageAddCommand(parseResult).Execute());
+        command.Options.Add(PackageCommandDefinition.ProjectOption);
+        command.Options.Add(PackageCommandDefinition.FileOption);
 
         return command;
     }
diff --git a/src/Cli/dotnet/Commands/Package/List/PackageListCommand.cs b/src/Cli/dotnet/Commands/Package/List/PackageListCommand.cs
index 4ff46b804d2c..3bb3a17d61de 100644
--- a/src/Cli/dotnet/Commands/Package/List/PackageListCommand.cs
+++ b/src/Cli/dotnet/Commands/Package/List/PackageListCommand.cs
@@ -19,9 +19,9 @@ internal class PackageListCommand(
 {
     //The file or directory passed down by the command
     private readonly string _fileOrDirectory = GetAbsolutePath(Directory.GetCurrentDirectory(),
-            parseResult.HasOption(PackageCommandParser.ProjectOption) ?
-            parseResult.GetValue(PackageCommandParser.ProjectOption) :
-            parseResult.GetValue(ListCommandParser.SlnOrProjectArgument) ?? "");
+            parseResult.HasOption(PackageCommandDefinition.ProjectOption) ?
+            parseResult.GetValue(PackageCommandDefinition.ProjectOption) :
+            parseResult.GetValue(ListCommandDefinition.SlnOrProjectArgument) ?? "");
 
     private static string GetAbsolutePath(string currentDirectory, string relativePath)
     {
@@ -31,13 +31,13 @@ private static string GetAbsolutePath(string currentDirectory, string relativePa
     public override int Execute()
     {
         string projectFile = GetProjectOrSolution();
-        bool noRestore = _parseResult.HasOption(PackageListCommandParser.NoRestore);
+        bool noRestore = _parseResult.HasOption(PackageListCommandDefinition.NoRestore);
         int restoreExitCode = 0;
 
         if (!noRestore)
         {
-            ReportOutputFormat formatOption = _parseResult.GetValue((Option<ReportOutputFormat>)PackageListCommandParser.FormatOption);
-            bool interactive = _parseResult.GetValue((Option<bool>)PackageListCommandParser.InteractiveOption);
+            ReportOutputFormat formatOption = _parseResult.GetValue((Option<ReportOutputFormat>)PackageListCommandDefinition.FormatOption);
+            bool interactive = _parseResult.GetValue((Option<bool>)PackageListCommandDefinition.InteractiveOption);
             restoreExitCode = RunRestore(projectFile, formatOption, interactive);
         }
 
@@ -100,9 +100,9 @@ private int RunRestore(string projectOrSolution, ReportOutputFormat formatOption
     internal static void EnforceOptionRules(ParseResult parseResult)
     {
         var mutexOptionCount = 0;
-        mutexOptionCount += parseResult.HasOption(PackageListCommandParser.DeprecatedOption) ? 1 : 0;
-        mutexOptionCount += parseResult.HasOption(PackageListCommandParser.OutdatedOption) ? 1 : 0;
-        mutexOptionCount += parseResult.HasOption(PackageListCommandParser.VulnerableOption) ? 1 : 0;
+        mutexOptionCount += parseResult.HasOption(PackageListCommandDefinition.DeprecatedOption) ? 1 : 0;
+        mutexOptionCount += parseResult.HasOption(PackageListCommandDefinition.OutdatedOption) ? 1 : 0;
+        mutexOptionCount += parseResult.HasOption(PackageListCommandDefinition.VulnerableOption) ? 1 : 0;
         if (mutexOptionCount > 1)
         {
             throw new GracefulException(CliCommandStrings.OptionsCannotBeCombined);
@@ -118,7 +118,7 @@ private string[] TransformArgs(string projectOrSolution)
             projectOrSolution
         };
 
-        args.AddRange(_parseResult.OptionValuesToBeForwarded(PackageListCommandParser.GetCommand()));
+        args.AddRange(_parseResult.OptionValuesToBeForwarded(PackageListCommandDefinition.Create()));
 
         EnforceOptionRules(_parseResult);
 
diff --git a/src/Cli/dotnet/Commands/Package/List/PackageListCommandParser.cs b/src/Cli/dotnet/Commands/Package/List/PackageListCommandDefinition.cs
similarity index 90%
rename from src/Cli/dotnet/Commands/Package/List/PackageListCommandParser.cs
rename to src/Cli/dotnet/Commands/Package/List/PackageListCommandDefinition.cs
index 2ce93a3c7e80..8aeb0bdb904a 100644
--- a/src/Cli/dotnet/Commands/Package/List/PackageListCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Package/List/PackageListCommandDefinition.cs
@@ -8,8 +8,10 @@
 
 namespace Microsoft.DotNet.Cli.Commands.Package.List;
 
-internal static class PackageListCommandParser
+internal static class PackageListCommandDefinition
 {
+    public const string Name = "list";
+
     public static readonly Option OutdatedOption = new Option<bool>("--outdated")
     {
         Description = CliCommandStrings.CmdOutdatedDescription,
@@ -96,16 +98,9 @@ internal static class PackageListCommandParser
         Description = CliCommandStrings.CmdOutputVersionDescription
     }.ForwardAsSingle(o => $"--output-version:{o}");
 
-    private static readonly Command Command = ConstructCommand();
-
-    public static Command GetCommand()
-    {
-        return Command;
-    }
-
-    private static Command ConstructCommand()
+    public static Command Create()
     {
-        Command command = new("list", CliCommandStrings.PackageListAppFullName);
+        Command command = new(Name, CliCommandStrings.PackageListAppFullName);
 
         command.Options.Add(VerbosityOption);
         command.Options.Add(OutdatedOption);
@@ -122,9 +117,7 @@ private static Command ConstructCommand()
         command.Options.Add(FormatOption);
         command.Options.Add(OutputVersionOption);
         command.Options.Add(NoRestore);
-        command.Options.Add(PackageCommandParser.ProjectOption);
-
-        command.SetAction((parseResult) => new PackageListCommand(parseResult).Execute());
+        command.Options.Add(PackageCommandDefinition.ProjectOption);
 
         return command;
     }
diff --git a/src/Cli/dotnet/Commands/Package/List/ReportOutputFormat.cs b/src/Cli/dotnet/Commands/Package/List/ReportOutputFormat.cs
index 00a1971e05ab..1c685e2dfa1a 100644
--- a/src/Cli/dotnet/Commands/Package/List/ReportOutputFormat.cs
+++ b/src/Cli/dotnet/Commands/Package/List/ReportOutputFormat.cs
@@ -1,8 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 namespace Microsoft.DotNet.Cli.Commands.Package.List;
 
 internal enum ReportOutputFormat
diff --git a/src/Cli/dotnet/Commands/Package/PackageCommandDefinition.cs b/src/Cli/dotnet/Commands/Package/PackageCommandDefinition.cs
new file mode 100644
index 000000000000..9248bbfb3893
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Package/PackageCommandDefinition.cs
@@ -0,0 +1,70 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Package.Add;
+using Microsoft.DotNet.Cli.Commands.Package.List;
+using Microsoft.DotNet.Cli.Commands.Package.Remove;
+using Microsoft.DotNet.Cli.Commands.Package.Search;
+using Microsoft.DotNet.Cli.Commands.Run;
+using Microsoft.DotNet.Cli.CommandLine;
+using Microsoft.DotNet.Cli.Extensions;
+using Microsoft.DotNet.Cli.Utils;
+using Command = System.CommandLine.Command;
+
+namespace Microsoft.DotNet.Cli.Commands.Package;
+
+internal class PackageCommandDefinition
+{
+    public const string Name = "package";
+    private const string DocsLink = "https://aka.ms/dotnet-package";
+
+    public static readonly Option<string?> ProjectOption = new("--project")
+    {
+        Recursive = true,
+        Description = CliStrings.ProjectArgumentDescription
+    };
+
+    public static readonly Option<string?> FileOption = new("--file")
+    {
+        Recursive = true,
+        Description = CliStrings.FileArgumentDescription
+    };
+
+    // Used by the legacy 'add/remove package' commands.
+    public static readonly Argument<string> ProjectOrFileArgument = new Argument<string>(CliStrings.ProjectOrFileArgumentName)
+    {
+        Description = CliStrings.ProjectOrFileArgumentDescription
+    }.DefaultToCurrentDirectory();
+
+    public static Command Create()
+    {
+        Command command = new Command("package")
+        {
+            DocsLink = DocsLink
+        };
+
+        command.Subcommands.Add(PackageSearchCommandDefinition.Create());
+        command.Subcommands.Add(PackageAddCommandDefinition.Create());
+        command.Subcommands.Add(PackageListCommandDefinition.Create());
+        command.Subcommands.Add(PackageRemoveCommandDefinition.Create());
+
+        return command;
+    }
+
+    public static (string Path, AppKinds AllowedAppKinds) ProcessPathOptions(ParseResult parseResult)
+    {
+        bool hasFileOption = parseResult.HasOption(FileOption);
+        bool hasProjectOption = parseResult.HasOption(ProjectOption);
+
+        return (hasFileOption, hasProjectOption) switch
+        {
+            (false, false) => parseResult.GetValue(ProjectOrFileArgument) is { } projectOrFile
+                ? (projectOrFile, AppKinds.Any)
+                : (Environment.CurrentDirectory, AppKinds.ProjectBased),
+            (true, false) => (parseResult.GetValue(FileOption)!, AppKinds.FileBased),
+            (false, true) => (parseResult.GetValue(ProjectOption)!, AppKinds.ProjectBased),
+            (true, true) => throw new GracefulException(CliCommandStrings.CannotCombineOptions, FileOption.Name, ProjectOption.Name),
+        };
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Package/PackageCommandParser.cs b/src/Cli/dotnet/Commands/Package/PackageCommandParser.cs
index 16eb5873794d..2793efdc1dff 100644
--- a/src/Cli/dotnet/Commands/Package/PackageCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Package/PackageCommandParser.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
@@ -6,64 +6,40 @@
 using Microsoft.DotNet.Cli.Commands.Package.List;
 using Microsoft.DotNet.Cli.Commands.Package.Remove;
 using Microsoft.DotNet.Cli.Commands.Package.Search;
-using Microsoft.DotNet.Cli.Commands.Run;
-using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Extensions;
-using Microsoft.DotNet.Cli.Utils;
-using Command = System.CommandLine.Command;
 
 namespace Microsoft.DotNet.Cli.Commands.Package;
 
 internal class PackageCommandParser
 {
-    private const string DocsLink = "https://aka.ms/dotnet-package";
+    private static readonly Command Command = SetAction(PackageCommandDefinition.Create());
 
-    public static readonly Option<string?> ProjectOption = new("--project")
+    public static Command GetCommand()
     {
-        Recursive = true,
-        Description = CliStrings.ProjectArgumentDescription
-    };
+        return Command;
+    }
 
-    public static readonly Option<string?> FileOption = new("--file")
+    private static Command SetAction(Command command)
     {
-        Recursive = true,
-        Description = CliStrings.FileArgumentDescription
-    };
+        command.SetAction((parseResult) => parseResult.HandleMissingCommand());
 
-    // Used by the legacy 'add/remove package' commands.
-    public static readonly Argument<string> ProjectOrFileArgument = new Argument<string>(CliStrings.ProjectOrFileArgumentName)
-    {
-        Description = CliStrings.ProjectOrFileArgumentDescription
-    }.DefaultToCurrentDirectory();
+        command.Subcommands.Single(c => c.Name == PackageRemoveCommandDefinition.Name).SetAction(parseResult => new PackageRemoveCommand(parseResult).Execute());
+        command.Subcommands.Single(c => c.Name == PackageListCommandDefinition.Name).SetAction(parseResult => new PackageListCommand(parseResult).Execute());
+        command.Subcommands.Single(c => c.Name == PackageAddCommandDefinition.Name).SetAction(parseResult => new PackageAddCommand(parseResult).Execute());
 
-    public static Command GetCommand()
-    {
-        Command command = new Command("package")
+        command.Subcommands.Single(c => c.Name == PackageSearchCommandDefinition.Name).SetAction((parseResult) =>
         {
-            DocsLink = DocsLink
-        };
-        command.SetAction((parseResult) => parseResult.HandleMissingCommand());
-        command.Subcommands.Add(PackageSearchCommandParser.GetCommand());
-        command.Subcommands.Add(PackageAddCommandParser.GetCommand());
-        command.Subcommands.Add(PackageListCommandParser.GetCommand());
-        command.Subcommands.Add(PackageRemoveCommandParser.GetCommand());
+            var command = new PackageSearchCommand(parseResult);
+            int exitCode = command.Execute();
 
-        return command;
-    }
-
-    public static (string Path, AppKinds AllowedAppKinds) ProcessPathOptions(ParseResult parseResult)
-    {
-        bool hasFileOption = parseResult.HasOption(FileOption);
-        bool hasProjectOption = parseResult.HasOption(ProjectOption);
+            if (exitCode == 1)
+            {
+                parseResult.ShowHelp();
+            }
+            // Only return 1 or 0
+            return exitCode == 0 ? 0 : 1;
+        });
 
-        return (hasFileOption, hasProjectOption) switch
-        {
-            (false, false) => parseResult.GetValue(ProjectOrFileArgument) is { } projectOrFile
-                ? (projectOrFile, AppKinds.Any)
-                : (Environment.CurrentDirectory, AppKinds.ProjectBased),
-            (true, false) => (parseResult.GetValue(FileOption)!, AppKinds.FileBased),
-            (false, true) => (parseResult.GetValue(ProjectOption)!, AppKinds.ProjectBased),
-            (true, true) => throw new GracefulException(CliCommandStrings.CannotCombineOptions, FileOption.Name, ProjectOption.Name),
-        };
+        return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Package/Remove/PackageRemoveCommand.cs b/src/Cli/dotnet/Commands/Package/Remove/PackageRemoveCommand.cs
index e90099382273..7213118e35cf 100644
--- a/src/Cli/dotnet/Commands/Package/Remove/PackageRemoveCommand.cs
+++ b/src/Cli/dotnet/Commands/Package/Remove/PackageRemoveCommand.cs
@@ -15,14 +15,14 @@ internal class PackageRemoveCommand(ParseResult parseResult) : CommandBase(parse
 {
     public override int Execute()
     {
-        var arguments = _parseResult.GetValue(PackageRemoveCommandParser.CmdPackageArgument) ?? [];
+        var arguments = _parseResult.GetValue(PackageRemoveCommandDefinition.CmdPackageArgument) ?? [];
 
         if (arguments is not [{ } packageToRemove])
         {
             throw new GracefulException(CliCommandStrings.PackageRemoveSpecifyExactlyOnePackageReference);
         }
 
-        var (fileOrDirectory, allowedAppKinds) = PackageCommandParser.ProcessPathOptions(_parseResult);
+        var (fileOrDirectory, allowedAppKinds) = PackageCommandDefinition.ProcessPathOptions(_parseResult);
 
         if (allowedAppKinds.HasFlag(AppKinds.FileBased) && VirtualProjectBuildingCommand.IsValidEntryPointPath(fileOrDirectory))
         {
@@ -59,7 +59,7 @@ private string[] TransformArgs(string packageId, string projectFilePath)
         };
 
         args.AddRange(_parseResult
-            .OptionValuesToBeForwarded(PackageRemoveCommandParser.GetCommand())
+            .OptionValuesToBeForwarded(PackageRemoveCommandDefinition.Options)
             .SelectMany(a => a.Split(' ')));
 
         return [.. args];
diff --git a/src/Cli/dotnet/Commands/Package/Remove/PackageRemoveCommandParser.cs b/src/Cli/dotnet/Commands/Package/Remove/PackageRemoveCommandDefinition.cs
similarity index 54%
rename from src/Cli/dotnet/Commands/Package/Remove/PackageRemoveCommandParser.cs
rename to src/Cli/dotnet/Commands/Package/Remove/PackageRemoveCommandDefinition.cs
index 20354b4f0658..ff8e406cc1d1 100644
--- a/src/Cli/dotnet/Commands/Package/Remove/PackageRemoveCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Package/Remove/PackageRemoveCommandDefinition.cs
@@ -6,8 +6,10 @@
 
 namespace Microsoft.DotNet.Cli.Commands.Package.Remove;
 
-internal static class PackageRemoveCommandParser
+internal static class PackageRemoveCommandDefinition
 {
+    public const string Name = "remove";
+
     public static readonly Argument<string[]> CmdPackageArgument = new(CliCommandStrings.CmdPackage)
     {
         Description = CliCommandStrings.PackageRemoveAppHelpText,
@@ -16,23 +18,19 @@ internal static class PackageRemoveCommandParser
 
     public static readonly Option<bool> InteractiveOption = CommonOptions.InteractiveOption().ForwardIfEnabled("--interactive");
 
-    private static readonly Command Command = ConstructCommand();
+    public static readonly IEnumerable<Option> Options =
+    [
+        InteractiveOption,
+        PackageCommandDefinition.ProjectOption,
+        PackageCommandDefinition.FileOption
+    ];
 
-    public static Command GetCommand()
+    public static Command Create()
     {
-        return Command;
-    }
-
-    private static Command ConstructCommand()
-    {
-        var command = new Command("remove", CliCommandStrings.PackageRemoveAppFullName);
+        var command = new Command(Name, CliCommandStrings.PackageRemoveAppFullName);
 
         command.Arguments.Add(CmdPackageArgument);
-        command.Options.Add(InteractiveOption);
-        command.Options.Add(PackageCommandParser.ProjectOption);
-        command.Options.Add(PackageCommandParser.FileOption);
-
-        command.SetAction((parseResult) => new PackageRemoveCommand(parseResult).Execute());
+        command.Options.AddRange(Options);
 
         return command;
     }
diff --git a/src/Cli/dotnet/Commands/Package/Search/PackageSearchCommand.cs b/src/Cli/dotnet/Commands/Package/Search/PackageSearchCommand.cs
index d26a96fab237..374ff10f7ee8 100644
--- a/src/Cli/dotnet/Commands/Package/Search/PackageSearchCommand.cs
+++ b/src/Cli/dotnet/Commands/Package/Search/PackageSearchCommand.cs
@@ -19,13 +19,13 @@ public override int Execute()
             "search"
         };
 
-        var searchArgument = _parseResult.GetValue(PackageSearchCommandParser.SearchTermArgument);
+        var searchArgument = _parseResult.GetValue(PackageSearchCommandDefinition.SearchTermArgument);
         if (searchArgument != null)
         {
             args.Add(searchArgument);
         }
 
-        args.AddRange(_parseResult.OptionValuesToBeForwarded(PackageSearchCommandParser.GetCommand()));
+        args.AddRange(_parseResult.OptionValuesToBeForwarded(PackageSearchCommandDefinition.Options));
         return NuGetCommand.Run([.. args]);
     }
 }
diff --git a/src/Cli/dotnet/Commands/Package/Search/PackageSearchCommandParser.cs b/src/Cli/dotnet/Commands/Package/Search/PackageSearchCommandDefinition.cs
similarity index 72%
rename from src/Cli/dotnet/Commands/Package/Search/PackageSearchCommandParser.cs
rename to src/Cli/dotnet/Commands/Package/Search/PackageSearchCommandDefinition.cs
index 54b0749cca3d..a1b8c3b51836 100644
--- a/src/Cli/dotnet/Commands/Package/Search/PackageSearchCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Package/Search/PackageSearchCommandDefinition.cs
@@ -1,16 +1,16 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
 using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Extensions;
 
 namespace Microsoft.DotNet.Cli.Commands.Package.Search;
 
-internal static class PackageSearchCommandParser
+internal static class PackageSearchCommandDefinition
 {
+    public const string Name = "search";
+
     public static readonly Argument<string> SearchTermArgument = new Argument<string>("SearchTerm")
     {
         HelpName = CliCommandStrings.PackageSearchSearchTermArgumentName,
@@ -69,40 +69,25 @@ internal static class PackageSearchCommandParser
         HelpName = CliCommandStrings.VerbosityArgumentName
     }.ForwardAsSingle(o => $"--verbosity:{o}");
 
-    private static readonly Command Command = ConstructCommand();
-
-    public static Command GetCommand()
-    {
-        return Command;
-    }
-
-    private static Command ConstructCommand()
+    public static readonly IEnumerable<Option> Options =
+    [
+        Sources,
+        Take,
+        Skip,
+        ExactMatch,
+        Interactive,
+        Prerelease,
+        ConfigFile,
+        Format,
+        Verbosity
+    ];
+
+    public static Command Create()
     {
-        Command searchCommand = new("search", CliCommandStrings.PackageSearchCommandDescription);
+        Command searchCommand = new(Name, CliCommandStrings.PackageSearchCommandDescription);
 
         searchCommand.Arguments.Add(SearchTermArgument);
-        searchCommand.Options.Add(Sources);
-        searchCommand.Options.Add(Take);
-        searchCommand.Options.Add(Skip);
-        searchCommand.Options.Add(ExactMatch);
-        searchCommand.Options.Add(Interactive);
-        searchCommand.Options.Add(Prerelease);
-        searchCommand.Options.Add(ConfigFile);
-        searchCommand.Options.Add(Format);
-        searchCommand.Options.Add(Verbosity);
-
-        searchCommand.SetAction((parseResult) =>
-        {
-            var command = new PackageSearchCommand(parseResult);
-            int exitCode = command.Execute();
-
-            if (exitCode == 1)
-            {
-                parseResult.ShowHelp();
-            }
-            // Only return 1 or 0
-            return exitCode == 0 ? 0 : 1;
-        });
+        searchCommand.Options.AddRange(Options);
 
         return searchCommand;
     }
diff --git a/src/Cli/dotnet/Commands/Project/Convert/ProjectConvertCommand.cs b/src/Cli/dotnet/Commands/Project/Convert/ProjectConvertCommand.cs
index 6acf2b7cc63b..2d59742f8b17 100644
--- a/src/Cli/dotnet/Commands/Project/Convert/ProjectConvertCommand.cs
+++ b/src/Cli/dotnet/Commands/Project/Convert/ProjectConvertCommand.cs
@@ -15,9 +15,9 @@ namespace Microsoft.DotNet.Cli.Commands.Project.Convert;
 
 internal sealed class ProjectConvertCommand(ParseResult parseResult) : CommandBase(parseResult)
 {
-    private readonly string _file = parseResult.GetValue(ProjectConvertCommandParser.FileArgument) ?? string.Empty;
+    private readonly string _file = parseResult.GetValue(ProjectConvertCommandDefinition.FileArgument) ?? string.Empty;
     private readonly string? _outputDirectory = parseResult.GetValue(SharedOptions.OutputOption)?.FullName;
-    private readonly bool _force = parseResult.GetValue(ProjectConvertCommandParser.ForceOption);
+    private readonly bool _force = parseResult.GetValue(ProjectConvertCommandDefinition.ForceOption);
 
     public override int Execute()
     {
@@ -53,7 +53,7 @@ public override int Execute()
         // Find other items to copy over, e.g., default Content items like JSON files in Web apps.
         var includeItems = FindIncludedItems().ToList();
 
-        bool dryRun = _parseResult.GetValue(ProjectConvertCommandParser.DryRunOption);
+        bool dryRun = _parseResult.GetValue(ProjectConvertCommandDefinition.DryRunOption);
 
         CreateDirectory(targetDirectory);
 
diff --git a/src/Cli/dotnet/Commands/Project/Convert/ProjectConvertCommandParser.cs b/src/Cli/dotnet/Commands/Project/Convert/ProjectConvertCommandDefinition.cs
similarity index 76%
rename from src/Cli/dotnet/Commands/Project/Convert/ProjectConvertCommandParser.cs
rename to src/Cli/dotnet/Commands/Project/Convert/ProjectConvertCommandDefinition.cs
index c3104e995cd3..78e47120c3b2 100644
--- a/src/Cli/dotnet/Commands/Project/Convert/ProjectConvertCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Project/Convert/ProjectConvertCommandDefinition.cs
@@ -6,8 +6,10 @@
 
 namespace Microsoft.DotNet.Cli.Commands.Project.Convert;
 
-internal sealed class ProjectConvertCommandParser
+internal sealed class ProjectConvertCommandDefinition
 {
+    public const string Name = "convert";
+
     public static readonly Argument<string> FileArgument = new("file")
     {
         Description = CliCommandStrings.CmdFileDescription,
@@ -26,9 +28,8 @@ internal sealed class ProjectConvertCommandParser
         Arity = ArgumentArity.Zero,
     };
 
-    public static Command GetCommand()
-    {
-        Command command = new("convert", CliCommandStrings.ProjectConvertAppFullName)
+    public static Command Create()
+        => new(Name, CliCommandStrings.ProjectConvertAppFullName)
         {
             FileArgument,
             SharedOptions.OutputOption,
@@ -36,8 +37,4 @@ public static Command GetCommand()
             CommonOptions.InteractiveOption(),
             DryRunOption,
         };
-
-        command.SetAction((parseResult) => new ProjectConvertCommand(parseResult).Execute());
-        return command;
-    }
 }
diff --git a/src/Cli/dotnet/Commands/Project/ProjectCommandDefinition.cs b/src/Cli/dotnet/Commands/Project/ProjectCommandDefinition.cs
new file mode 100644
index 000000000000..ec71ceda9c44
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Project/ProjectCommandDefinition.cs
@@ -0,0 +1,18 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Project.Convert;
+
+namespace Microsoft.DotNet.Cli.Commands.Project;
+
+internal sealed class ProjectCommandDefinition
+{
+    public static Command Create()
+    {
+        Command command = new("project");
+        command.Subcommands.Add(ProjectConvertCommandDefinition.Create());
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Project/ProjectCommandParser.cs b/src/Cli/dotnet/Commands/Project/ProjectCommandParser.cs
index 7fb4a8752a7c..c4ea9d708502 100644
--- a/src/Cli/dotnet/Commands/Project/ProjectCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Project/ProjectCommandParser.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
@@ -9,11 +9,18 @@ namespace Microsoft.DotNet.Cli.Commands.Project;
 
 internal sealed class ProjectCommandParser
 {
+    private static readonly Command Command = ConfigureCommand(ProjectCommandDefinition.Create());
+
     public static Command GetCommand()
     {
-        Command command = new("project");
+        return Command;
+    }
+
+    private static Command ConfigureCommand(Command command)
+    {
         command.SetAction((parseResult) => parseResult.HandleMissingCommand());
-        command.Subcommands.Add(ProjectConvertCommandParser.GetCommand());
+
+        command.Subcommands.Single(c => c.Name == ProjectConvertCommandDefinition.Name).SetAction(parseResult => new ProjectConvertCommand(parseResult).Execute());
 
         return command;
     }
diff --git a/src/Cli/dotnet/Commands/Publish/PublishCommand.cs b/src/Cli/dotnet/Commands/Publish/PublishCommand.cs
index 424a2250c25a..19568315c08c 100644
--- a/src/Cli/dotnet/Commands/Publish/PublishCommand.cs
+++ b/src/Cli/dotnet/Commands/Publish/PublishCommand.cs
@@ -31,20 +31,20 @@ public static CommandBase FromParseResult(ParseResult parseResult, string? msbui
         parseResult.HandleDebugSwitch();
         parseResult.ShowHelpOrErrorIfAppropriate();
 
-        string[] args = parseResult.GetValue(PublishCommandParser.SlnOrProjectOrFileArgument) ?? [];
+        string[] args = parseResult.GetValue(PublishCommandDefinition.SlnOrProjectOrFileArgument) ?? [];
 
         LoggerUtility.SeparateBinLogArguments(args, out var binLogArgs, out var nonBinLogArgs);
 
-        CommonOptions.ValidateSelfContainedOptions(parseResult.HasOption(PublishCommandParser.SelfContainedOption),
-            parseResult.HasOption(PublishCommandParser.NoSelfContainedOption));
+        CommonOptions.ValidateSelfContainedOptions(parseResult.HasOption(PublishCommandDefinition.SelfContainedOption),
+            parseResult.HasOption(PublishCommandDefinition.NoSelfContainedOption));
 
-        bool noBuild = parseResult.HasOption(PublishCommandParser.NoBuildOption);
+        bool noBuild = parseResult.HasOption(PublishCommandDefinition.NoBuildOption);
 
-        bool noRestore = noBuild || parseResult.HasOption(PublishCommandParser.NoRestoreOption);
+        bool noRestore = noBuild || parseResult.HasOption(PublishCommandDefinition.NoRestoreOption);
 
         return CommandFactory.CreateVirtualOrPhysicalCommand(
             PublishCommandParser.GetCommand(),
-            PublishCommandParser.SlnOrProjectOrFileArgument,
+            PublishCommandDefinition.SlnOrProjectOrFileArgument,
             (msbuildArgs, appFilePath) => new VirtualProjectBuildingCommand(
                 entryPointFileFullPath: Path.GetFullPath(appFilePath),
                 msbuildArgs: msbuildArgs)
@@ -58,15 +58,15 @@ public static CommandBase FromParseResult(ParseResult parseResult, string? msbui
                 noRestore: noRestore,
                 msbuildPath: msbuildPath
             ),
-            [CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, PublishCommandParser.TargetOption, PublishCommandParser.VerbosityOption, PublishCommandParser.NoLogoOption],
+            [CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, PublishCommandDefinition.TargetOption, PublishCommandDefinition.VerbosityOption, PublishCommandDefinition.NoLogoOption],
             parseResult,
             msbuildPath,
             (msbuildArgs) =>
             {
                 var options = new ReleasePropertyProjectLocator.DependentCommandOptions(
                         nonBinLogArgs,
-                        parseResult.HasOption(PublishCommandParser.ConfigurationOption) ? parseResult.GetValue(PublishCommandParser.ConfigurationOption) : null,
-                        parseResult.HasOption(PublishCommandParser.FrameworkOption) ? parseResult.GetValue(PublishCommandParser.FrameworkOption) : null
+                        parseResult.HasOption(PublishCommandDefinition.ConfigurationOption) ? parseResult.GetValue(PublishCommandDefinition.ConfigurationOption) : null,
+                        parseResult.HasOption(PublishCommandDefinition.FrameworkOption) ? parseResult.GetValue(PublishCommandDefinition.FrameworkOption) : null
                     );
                 var projectLocator = new ReleasePropertyProjectLocator(parseResult, MSBuildPropertyNames.PUBLISH_RELEASE, options);
                 var releaseModeProperties = projectLocator.GetCustomDefaultConfigurationValueIfSpecified();
diff --git a/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs b/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
new file mode 100644
index 000000000000..19603b0b7cbb
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Publish/PublishCommandDefinition.cs
@@ -0,0 +1,93 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Build;
+using Microsoft.DotNet.Cli.Commands.Restore;
+using Microsoft.DotNet.Cli.Extensions;
+
+namespace Microsoft.DotNet.Cli.Commands.Publish;
+
+internal static class PublishCommandDefinition
+{
+    public static readonly string DocsLink = "https://aka.ms/dotnet-publish";
+
+    public static readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
+    {
+        Description = CliStrings.SolutionOrProjectOrFileArgumentDescription,
+        Arity = ArgumentArity.ZeroOrMore
+    };
+
+    public static readonly Option<string> OutputOption = new Option<string>("--output", "-o")
+    {
+        Description = CliCommandStrings.PublishOutputOptionDescription,
+        HelpName = CliCommandStrings.PublishOutputOption
+    }.ForwardAsOutputPath("PublishDir");
+
+    public static readonly Option<IEnumerable<string>> ManifestOption = new Option<IEnumerable<string>>("--manifest")
+    {
+        Description = CliCommandStrings.ManifestOptionDescription,
+        HelpName = CliCommandStrings.ManifestOption
+    }.ForwardAsSingle(o => $"-property:TargetManifestFiles={string.Join("%3B", o.Select(CommandDirectoryContext.GetFullPath))}")
+    .AllowSingleArgPerToken();
+
+    public static readonly Option<bool> NoBuildOption = new Option<bool>("--no-build")
+    {
+        Description = CliCommandStrings.NoBuildOptionDescription,
+        Arity = ArgumentArity.Zero
+    }.ForwardAs("-property:NoBuild=true");
+
+    public static readonly Option<bool> NoLogoOption = CommonOptions.NoLogoOption();
+
+    public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+
+    public static readonly Option<bool> SelfContainedOption = CommonOptions.SelfContainedOption;
+
+    public static readonly Option<bool> NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
+
+    public static readonly Option<string> RuntimeOption = CommonOptions.RuntimeOption(CliCommandStrings.PublishRuntimeOptionDescription);
+
+    public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(CliCommandStrings.PublishFrameworkOptionDescription);
+
+    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(CliCommandStrings.PublishConfigurationOptionDescription);
+    public static readonly Option<string[]> TargetOption = CommonOptions.RequiredMSBuildTargetOption("Publish", [("_IsPublishing", "true")]);
+
+    public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = BuildCommandDefinition.VerbosityOption;
+
+    public static Command Create()
+    {
+        var command = new Command("publish", CliCommandStrings.PublishAppDescription)
+        {
+            DocsLink = DocsLink
+        };
+
+        command.Arguments.Add(SlnOrProjectOrFileArgument);
+        RestoreCommandDefinition.AddImplicitRestoreOptions(command, includeRuntimeOption: false, includeNoDependenciesOption: true);
+
+        command.Options.Add(OutputOption);
+        command.Options.Add(CommonOptions.ArtifactsPathOption);
+        command.Options.Add(ManifestOption);
+        command.Options.Add(NoBuildOption);
+        command.Options.Add(SelfContainedOption);
+        command.Options.Add(NoSelfContainedOption);
+        command.Options.Add(NoLogoOption);
+        command.Options.Add(FrameworkOption);
+        command.Options.Add(RuntimeOption);
+        command.Options.Add(ConfigurationOption);
+        command.Options.Add(CommonOptions.VersionSuffixOption);
+        command.Options.Add(CommonOptions.InteractiveMsBuildForwardOption);
+        command.Options.Add(NoRestoreOption);
+        command.Options.Add(VerbosityOption);
+        command.Options.Add(CommonOptions.ArchitectureOption);
+        command.Options.Add(CommonOptions.OperatingSystemOption);
+        command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(TargetOption);
+        command.Options.Add(CommonOptions.GetPropertyOption);
+        command.Options.Add(CommonOptions.GetItemOption);
+        command.Options.Add(CommonOptions.GetTargetResultOption);
+        command.Options.Add(CommonOptions.GetResultOutputFileOption);
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs b/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs
index 2c2b1b20e36f..623c4cadfeab 100644
--- a/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Publish/PublishCommandParser.cs
@@ -2,101 +2,21 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
-using Microsoft.DotNet.Cli.CommandLine;
-using Microsoft.DotNet.Cli.Commands.Build;
-using Microsoft.DotNet.Cli.Commands.Restore;
-using Microsoft.DotNet.Cli.Extensions;
 
 namespace Microsoft.DotNet.Cli.Commands.Publish;
 
 internal static class PublishCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-publish";
-
-    public static readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
-    {
-        Description = CliStrings.SolutionOrProjectOrFileArgumentDescription,
-        Arity = ArgumentArity.ZeroOrMore
-    };
-
-    public static readonly Option<string> OutputOption = new Option<string>("--output", "-o")
-    {
-        Description = CliCommandStrings.PublishOutputOptionDescription,
-        HelpName = CliCommandStrings.PublishOutputOption
-    }.ForwardAsOutputPath("PublishDir");
-
-    public static readonly Option<IEnumerable<string>> ManifestOption = new Option<IEnumerable<string>>("--manifest")
-    {
-        Description = CliCommandStrings.ManifestOptionDescription,
-        HelpName = CliCommandStrings.ManifestOption
-    }.ForwardAsSingle(o => $"-property:TargetManifestFiles={string.Join("%3B", o.Select(CommandDirectoryContext.GetFullPath))}")
-    .AllowSingleArgPerToken();
-
-    public static readonly Option<bool> NoBuildOption = new Option<bool>("--no-build")
-    {
-        Description = CliCommandStrings.NoBuildOptionDescription,
-        Arity = ArgumentArity.Zero
-    }.ForwardAs("-property:NoBuild=true");
-
-    public static readonly Option<bool> NoLogoOption = CommonOptions.NoLogoOption();
-
-    public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
-
-    public static readonly Option<bool> SelfContainedOption = CommonOptions.SelfContainedOption;
-
-    public static readonly Option<bool> NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
-
-    public static readonly Option<string> RuntimeOption = CommonOptions.RuntimeOption(CliCommandStrings.PublishRuntimeOptionDescription);
-
-    public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(CliCommandStrings.PublishFrameworkOptionDescription);
-
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(CliCommandStrings.PublishConfigurationOptionDescription);
-    public static readonly Option<string[]> TargetOption = CommonOptions.RequiredMSBuildTargetOption("Publish", [("_IsPublishing", "true")]);
-
-    public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = BuildCommandParser.VerbosityOption;
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = SetAction(PublishCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command SetAction(Command command)
     {
-        var command = new Command("publish", CliCommandStrings.PublishAppDescription)
-        {
-            DocsLink = DocsLink
-        };
-
-        command.Arguments.Add(SlnOrProjectOrFileArgument);
-        RestoreCommandParser.AddImplicitRestoreOptions(command, includeRuntimeOption: false, includeNoDependenciesOption: true);
-
-        command.Options.Add(OutputOption);
-        command.Options.Add(CommonOptions.ArtifactsPathOption);
-        command.Options.Add(ManifestOption);
-        command.Options.Add(NoBuildOption);
-        command.Options.Add(SelfContainedOption);
-        command.Options.Add(NoSelfContainedOption);
-        command.Options.Add(NoLogoOption);
-        command.Options.Add(FrameworkOption);
-        command.Options.Add(RuntimeOption);
-        command.Options.Add(ConfigurationOption);
-        command.Options.Add(CommonOptions.VersionSuffixOption);
-        command.Options.Add(CommonOptions.InteractiveMsBuildForwardOption);
-        command.Options.Add(NoRestoreOption);
-        command.Options.Add(VerbosityOption);
-        command.Options.Add(CommonOptions.ArchitectureOption);
-        command.Options.Add(CommonOptions.OperatingSystemOption);
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
-        command.Options.Add(TargetOption);
-        command.Options.Add(CommonOptions.GetPropertyOption);
-        command.Options.Add(CommonOptions.GetItemOption);
-        command.Options.Add(CommonOptions.GetTargetResultOption);
-        command.Options.Add(CommonOptions.GetResultOutputFileOption);
-
         command.SetAction(PublishCommand.Run);
-
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Reference/Add/ReferenceAddCommand.cs b/src/Cli/dotnet/Commands/Reference/Add/ReferenceAddCommand.cs
index 10340392c0db..347fc1a17dc3 100644
--- a/src/Cli/dotnet/Commands/Reference/Add/ReferenceAddCommand.cs
+++ b/src/Cli/dotnet/Commands/Reference/Add/ReferenceAddCommand.cs
@@ -14,22 +14,22 @@ namespace Microsoft.DotNet.Cli.Commands.Reference.Add;
 
 internal class ReferenceAddCommand(ParseResult parseResult) : CommandBase(parseResult)
 {
-    private readonly string _fileOrDirectory = parseResult.HasOption(ReferenceCommandParser.ProjectOption) ?
-            parseResult.GetValue(ReferenceCommandParser.ProjectOption) :
-            parseResult.GetValue(PackageCommandParser.ProjectOrFileArgument);
+    private readonly string _fileOrDirectory = parseResult.HasOption(ReferenceCommandDefinition.ProjectOption) ?
+            parseResult.GetValue(ReferenceCommandDefinition.ProjectOption) :
+            parseResult.GetValue(PackageCommandDefinition.ProjectOrFileArgument);
 
     public override int Execute()
     {
         using var projects = new ProjectCollection();
-        bool interactive = _parseResult.GetValue(ReferenceAddCommandParser.InteractiveOption);
+        bool interactive = _parseResult.GetValue(ReferenceAddCommandDefinition.InteractiveOption);
         MsbuildProject msbuildProj = MsbuildProject.FromFileOrDirectory(
             projects,
             _fileOrDirectory,
             interactive);
 
-        var frameworkString = _parseResult.GetValue(ReferenceAddCommandParser.FrameworkOption);
+        var frameworkString = _parseResult.GetValue(ReferenceAddCommandDefinition.FrameworkOption);
 
-        var arguments = _parseResult.GetValue(ReferenceAddCommandParser.ProjectPathArgument).ToList().AsReadOnly();
+        var arguments = _parseResult.GetValue(ReferenceAddCommandDefinition.ProjectPathArgument).ToList().AsReadOnly();
         PathUtility.EnsureAllPathsExist(arguments,
             CliStrings.CouldNotFindProjectOrDirectory, true);
         List<MsbuildProject> refs = [.. arguments.Select((r) => MsbuildProject.FromFileOrDirectory(projects, r, interactive))];
diff --git a/src/Cli/dotnet/Commands/Reference/Add/ReferenceAddCommandParser.cs b/src/Cli/dotnet/Commands/Reference/Add/ReferenceAddCommandDefinition.cs
similarity index 78%
rename from src/Cli/dotnet/Commands/Reference/Add/ReferenceAddCommandParser.cs
rename to src/Cli/dotnet/Commands/Reference/Add/ReferenceAddCommandDefinition.cs
index 777f74585018..b595c26274e0 100644
--- a/src/Cli/dotnet/Commands/Reference/Add/ReferenceAddCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Reference/Add/ReferenceAddCommandDefinition.cs
@@ -9,8 +9,10 @@
 
 namespace Microsoft.DotNet.Cli.Commands.Reference.Add;
 
-internal static class ReferenceAddCommandParser
+internal static class ReferenceAddCommandDefinition
 {
+    public const string Name = "add";
+
     public static readonly Argument<IEnumerable<string>> ProjectPathArgument = new(CliCommandStrings.ReferenceAddProjectPathArgumentName)
     {
         Description = CliCommandStrings.ReferenceAddProjectPathArgumentDescription,
@@ -33,23 +35,14 @@ internal static class ReferenceAddCommandParser
 
     public static readonly Option<bool> InteractiveOption = CommonOptions.InteractiveOption();
 
-    private static readonly Command Command = ConstructCommand();
-
-    public static Command GetCommand()
-    {
-        return Command;
-    }
-
-    private static Command ConstructCommand()
+    public static Command Create()
     {
-        Command command = new("add", CliCommandStrings.ReferenceAddAppFullName);
+        Command command = new(Name, CliCommandStrings.ReferenceAddAppFullName);
 
         command.Arguments.Add(ProjectPathArgument);
         command.Options.Add(FrameworkOption);
         command.Options.Add(InteractiveOption);
 
-        command.SetAction((parseResult) => new ReferenceAddCommand(parseResult).Execute());
-
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Reference/List/ReferenceListCommand.cs b/src/Cli/dotnet/Commands/Reference/List/ReferenceListCommand.cs
index cbd7a84e3a73..6fa690ef0d76 100644
--- a/src/Cli/dotnet/Commands/Reference/List/ReferenceListCommand.cs
+++ b/src/Cli/dotnet/Commands/Reference/List/ReferenceListCommand.cs
@@ -22,9 +22,9 @@ public ReferenceListCommand(ParseResult parseResult) : base(parseResult)
     {
         ShowHelpOrErrorIfAppropriate(parseResult);
 
-        _fileOrDirectory = parseResult.HasOption(ReferenceCommandParser.ProjectOption) ?
-            parseResult.GetValue(ReferenceCommandParser.ProjectOption) :
-            parseResult.GetValue(ListCommandParser.SlnOrProjectArgument) ??
+        _fileOrDirectory = parseResult.HasOption(ReferenceCommandDefinition.ProjectOption) ?
+            parseResult.GetValue(ReferenceCommandDefinition.ProjectOption) :
+            parseResult.GetValue(ListCommandDefinition.SlnOrProjectArgument) ??
             Directory.GetCurrentDirectory();
     }
 
diff --git a/src/Cli/dotnet/Commands/Reference/List/ReferenceListCommandDefinition.cs b/src/Cli/dotnet/Commands/Reference/List/ReferenceListCommandDefinition.cs
new file mode 100644
index 000000000000..49cd04505b24
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Reference/List/ReferenceListCommandDefinition.cs
@@ -0,0 +1,14 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+
+namespace Microsoft.DotNet.Cli.Commands.Reference.List;
+
+internal static class ReferenceListCommandDefinition
+{
+    public const string Name = "list";
+
+    public static Command Create()
+        => new(Name, CliCommandStrings.ReferenceListAppFullName);
+}
diff --git a/src/Cli/dotnet/Commands/Reference/List/ReferenceListCommandParser.cs b/src/Cli/dotnet/Commands/Reference/List/ReferenceListCommandParser.cs
deleted file mode 100644
index 01d7ed85c67f..000000000000
--- a/src/Cli/dotnet/Commands/Reference/List/ReferenceListCommandParser.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-using System.CommandLine;
-
-namespace Microsoft.DotNet.Cli.Commands.Reference.List;
-
-internal static class ReferenceListCommandParser
-{
-    private static readonly Command Command = ConstructCommand();
-
-    public static Command GetCommand()
-    {
-        return Command;
-    }
-
-    private static Command ConstructCommand()
-    {
-        var command = new Command("list", CliCommandStrings.ReferenceListAppFullName);
-
-        command.SetAction((parseResult) => new ReferenceListCommand(parseResult).Execute());
-
-        return command;
-    }
-}
diff --git a/src/Cli/dotnet/Commands/Reference/ReferenceCommandDefinition.cs b/src/Cli/dotnet/Commands/Reference/ReferenceCommandDefinition.cs
new file mode 100644
index 000000000000..544d4df27bf3
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Reference/ReferenceCommandDefinition.cs
@@ -0,0 +1,36 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Reference.Add;
+using Microsoft.DotNet.Cli.Commands.Reference.List;
+using Microsoft.DotNet.Cli.Commands.Reference.Remove;
+
+namespace Microsoft.DotNet.Cli.Commands.Reference;
+
+internal static class ReferenceCommandDefinition
+{
+    public static readonly string DocsLink = "https://aka.ms/dotnet-reference";
+
+    public static readonly Option<string> ProjectOption = new Option<string>("--project")
+    {
+        Description = CliStrings.ProjectArgumentDescription,
+        Recursive = true
+    };
+
+    public static Command Create()
+    {
+        var command = new Command("reference", CliCommandStrings.NetRemoveCommand)
+        {
+            DocsLink = DocsLink
+        };
+
+        command.Subcommands.Add(ReferenceAddCommandDefinition.Create());
+        command.Subcommands.Add(ReferenceListCommandDefinition.Create());
+        command.Subcommands.Add(ReferenceRemoveCommandDefinition.Create());
+        command.Options.Add(ProjectOption);
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Reference/ReferenceCommandParser.cs b/src/Cli/dotnet/Commands/Reference/ReferenceCommandParser.cs
index e26cd6cd8c35..6f7afc9b0cde 100644
--- a/src/Cli/dotnet/Commands/Reference/ReferenceCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Reference/ReferenceCommandParser.cs
@@ -1,47 +1,31 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
 using Microsoft.DotNet.Cli.Commands.Reference.Add;
 using Microsoft.DotNet.Cli.Commands.Reference.List;
 using Microsoft.DotNet.Cli.Commands.Reference.Remove;
-using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Extensions;
 
 namespace Microsoft.DotNet.Cli.Commands.Reference;
 
 internal static class ReferenceCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-reference";
-
-    public static readonly Option<string> ProjectOption = new Option<string>("--project")
-    {
-        Description = CliStrings.ProjectArgumentDescription,
-        Recursive = true
-    };
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = ConfigureCommand(ReferenceCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command ConfigureCommand(Command command)
     {
-        var command = new Command("reference", CliCommandStrings.NetRemoveCommand)
-        {
-            DocsLink = DocsLink
-        };
-
-        command.Subcommands.Add(ReferenceAddCommandParser.GetCommand());
-        command.Subcommands.Add(ReferenceListCommandParser.GetCommand());
-        command.Subcommands.Add(ReferenceRemoveCommandParser.GetCommand());
-        command.Options.Add(ProjectOption);
         command.SetAction((parseResult) => parseResult.HandleMissingCommand());
 
+        command.Subcommands.Single(c => c.Name == ReferenceAddCommandDefinition.Name).SetAction((parseResult) => new ReferenceAddCommand(parseResult).Execute());
+        command.Subcommands.Single(c => c.Name == ReferenceListCommandDefinition.Name).SetAction((parseResult) => new ReferenceListCommand(parseResult).Execute());
+        command.Subcommands.Single(c => c.Name == ReferenceRemoveCommandDefinition.Name).SetAction((parseResult) => new ReferenceRemoveCommand(parseResult).Execute());
+
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Reference/Remove/ReferenceRemoveCommand.cs b/src/Cli/dotnet/Commands/Reference/Remove/ReferenceRemoveCommand.cs
index 3a71f6b761ac..15a94b053360 100644
--- a/src/Cli/dotnet/Commands/Reference/Remove/ReferenceRemoveCommand.cs
+++ b/src/Cli/dotnet/Commands/Reference/Remove/ReferenceRemoveCommand.cs
@@ -19,10 +19,10 @@ internal class ReferenceRemoveCommand : CommandBase
     public ReferenceRemoveCommand(
         ParseResult parseResult) : base(parseResult)
     {
-        _fileOrDirectory = parseResult.HasOption(ReferenceCommandParser.ProjectOption) ?
-            parseResult.GetValue(ReferenceCommandParser.ProjectOption) :
-            parseResult.GetValue(PackageCommandParser.ProjectOrFileArgument);
-        _arguments = parseResult.GetValue(ReferenceRemoveCommandParser.ProjectPathArgument).ToList().AsReadOnly();
+        _fileOrDirectory = parseResult.HasOption(ReferenceCommandDefinition.ProjectOption) ?
+            parseResult.GetValue(ReferenceCommandDefinition.ProjectOption) :
+            parseResult.GetValue(PackageCommandDefinition.ProjectOrFileArgument);
+        _arguments = parseResult.GetValue(ReferenceRemoveCommandDefinition.ProjectPathArgument).ToList().AsReadOnly();
 
         if (_arguments.Count == 0)
         {
@@ -48,7 +48,7 @@ public override int Execute()
         });
 
         int numberOfRemovedReferences = msbuildProj.RemoveProjectToProjectReferences(
-            _parseResult.GetValue(ReferenceRemoveCommandParser.FrameworkOption),
+            _parseResult.GetValue(ReferenceRemoveCommandDefinition.FrameworkOption),
             references);
 
         if (numberOfRemovedReferences != 0)
diff --git a/src/Cli/dotnet/Commands/Reference/Remove/ReferenceRemoveCommandParser.cs b/src/Cli/dotnet/Commands/Reference/Remove/ReferenceRemoveCommandDefinition.cs
similarity index 70%
rename from src/Cli/dotnet/Commands/Reference/Remove/ReferenceRemoveCommandParser.cs
rename to src/Cli/dotnet/Commands/Reference/Remove/ReferenceRemoveCommandDefinition.cs
index 03e67bdbb37c..0e06192bb1ed 100644
--- a/src/Cli/dotnet/Commands/Reference/Remove/ReferenceRemoveCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Reference/Remove/ReferenceRemoveCommandDefinition.cs
@@ -1,8 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
 using System.CommandLine.StaticCompletions;
 
@@ -10,8 +8,10 @@
 
 namespace Microsoft.DotNet.Cli.Commands.Reference.Remove;
 
-internal static class ReferenceRemoveCommandParser
+internal static class ReferenceRemoveCommandDefinition
 {
+    public const string Name = "remove";
+
     public static readonly Argument<IEnumerable<string>> ProjectPathArgument = new Argument<IEnumerable<string>>(CliCommandStrings.ReferenceRemoveProjectPathArgumentName)
     {
         Description = CliCommandStrings.ReferenceRemoveProjectPathArgumentDescription,
@@ -25,22 +25,13 @@ internal static class ReferenceRemoveCommandParser
         HelpName = CliStrings.CommonCmdFramework
     };
 
-    private static readonly Command Command = ConstructCommand();
-
-    public static Command GetCommand()
+    public static Command Create()
     {
-        return Command;
-    }
-
-    private static Command ConstructCommand()
-    {
-        var command = new Command("remove", CliCommandStrings.ReferenceRemoveAppFullName);
+        var command = new Command(Name, CliCommandStrings.ReferenceRemoveAppFullName);
 
         command.Arguments.Add(ProjectPathArgument);
         command.Options.Add(FrameworkOption);
 
-        command.SetAction((parseResult) => new ReferenceRemoveCommand(parseResult).Execute());
-
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Restore/RestoreCommand.cs b/src/Cli/dotnet/Commands/Restore/RestoreCommand.cs
index 5a9ff6a37056..f0e3fdff688b 100644
--- a/src/Cli/dotnet/Commands/Restore/RestoreCommand.cs
+++ b/src/Cli/dotnet/Commands/Restore/RestoreCommand.cs
@@ -24,7 +24,7 @@ public static CommandBase FromParseResult(ParseResult result, string? msbuildPat
 
         return CommandFactory.CreateVirtualOrPhysicalCommand(
             RestoreCommandParser.GetCommand(),
-            RestoreCommandParser.SlnOrProjectOrFileArgument,
+            RestoreCommandDefinition.SlnOrProjectOrFileArgument,
             static (msbuildArgs, appFilePath) =>
             {
                 return new VirtualProjectBuildingCommand(
@@ -40,7 +40,7 @@ public static CommandBase FromParseResult(ParseResult result, string? msbuildPat
             {
                 return CreateForwarding(msbuildArgs, msbuildPath);
             },
-            [CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, RestoreCommandParser.TargetOption, RestoreCommandParser.VerbosityOption, RestoreCommandParser.NoLogoOption],
+            [CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, RestoreCommandDefinition.TargetOption, RestoreCommandDefinition.VerbosityOption, RestoreCommandDefinition.NoLogoOption],
             result,
             msbuildPath
         );
diff --git a/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs b/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
new file mode 100644
index 000000000000..4d0afd1e93d9
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Restore/RestoreCommandDefinition.cs
@@ -0,0 +1,222 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using System.CommandLine.StaticCompletions;
+using Microsoft.DotNet.Cli.CommandLine;
+using NuGet.Packaging;
+
+namespace Microsoft.DotNet.Cli.Commands.Restore;
+
+internal static class RestoreCommandDefinition
+{
+    public static readonly string DocsLink = "https://aka.ms/dotnet-restore";
+
+    public static readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
+    {
+        Description = CliStrings.SolutionOrProjectOrFileArgumentDescription,
+        Arity = ArgumentArity.ZeroOrMore
+    };
+
+    public static readonly Option<IEnumerable<string>> SourceOption = new Option<IEnumerable<string>>("--source", "-s")
+    {
+        Description = CliCommandStrings.CmdSourceOptionDescription,
+        HelpName = CliCommandStrings.CmdSourceOption
+    }.ForwardAsSingle(o => $"-property:RestoreSources={string.Join("%3B", o)}")
+    .AllowSingleArgPerToken();
+
+    public static readonly Option<string[]> TargetOption = CommonOptions.RequiredMSBuildTargetOption("Restore");
+    public static readonly Option<Utils.VerbosityOptions> VerbosityOption = CommonOptions.VerbosityOption(Utils.VerbosityOptions.minimal);
+    public static readonly Option<bool> NoLogoOption = CommonOptions.NoLogoOption();
+
+    private static IEnumerable<Option> FullRestoreOptions() => [
+        ..ImplicitRestoreOptions(true, true, true, true),
+        VerbosityOption,
+        CommonOptions.InteractiveMsBuildForwardOption,
+        CommonOptions.ArtifactsPathOption,
+        new Option<bool>("--use-lock-file")
+        {
+            Description = CliCommandStrings.CmdUseLockFileOptionDescription,
+            Arity = ArgumentArity.Zero
+        }.ForwardAs("-property:RestorePackagesWithLockFile=true"),
+        new Option<bool>("--locked-mode")
+        {
+            Description = CliCommandStrings.CmdLockedModeOptionDescription,
+            Arity = ArgumentArity.Zero
+        }.ForwardAs("-property:RestoreLockedMode=true"),
+        new Option<string>("--lock-file-path")
+        {
+            Description = CliCommandStrings.CmdLockFilePathOptionDescription,
+            HelpName = CliCommandStrings.CmdLockFilePathOption
+        }.ForwardAsSingle(o => $"-property:NuGetLockFilePath={o}"),
+        new Option<bool>("--force-evaluate")
+        {
+            Description = CliCommandStrings.CmdReevaluateOptionDescription,
+            Arity = ArgumentArity.Zero
+        }.ForwardAs("-property:RestoreForceEvaluate=true"),
+        TargetOption,
+        NoLogoOption
+    ];
+
+    public static Command Create()
+    {
+        var command = new Command("restore", CliCommandStrings.RestoreAppFullName)
+        {
+            DocsLink = DocsLink
+        };
+
+        command.Arguments.Add(SlnOrProjectOrFileArgument);
+        command.Options.Add(CommonOptions.DisableBuildServersOption);
+
+        command.Options.AddRange(FullRestoreOptions());
+
+        command.Options.Add(CommonOptions.ArchitectureOption);
+        command.Options.Add(CommonOptions.OperatingSystemOption);
+        command.Options.Add(CommonOptions.GetPropertyOption);
+        command.Options.Add(CommonOptions.GetItemOption);
+        command.Options.Add(CommonOptions.GetTargetResultOption);
+        command.Options.Add(CommonOptions.GetResultOutputFileOption);
+
+        return command;
+    }
+
+    public static void AddImplicitRestoreOptions(Command command, bool showHelp = false, bool useShortOptions = false, bool includeRuntimeOption = true, bool includeNoDependenciesOption = true)
+    {
+        foreach (var option in ImplicitRestoreOptions(showHelp, useShortOptions, includeRuntimeOption, includeNoDependenciesOption))
+        {
+            command.Options.Add(option);
+        }
+    }
+    private static string GetOsFromRid(string rid) => rid.Substring(0, rid.LastIndexOf("-", StringComparison.InvariantCulture));
+    private static string GetArchFromRid(string rid) => rid.Substring(rid.LastIndexOf("-", StringComparison.InvariantCulture) + 1, rid.Length - rid.LastIndexOf("-", StringComparison.InvariantCulture) - 1);
+    public static string RestoreRuntimeArgFunc(IEnumerable<string> rids)
+    {
+        List<string> convertedRids = [];
+        foreach (string rid in rids)
+        {
+            if (GetArchFromRid(rid.ToString()) == "amd64")
+            {
+                convertedRids.Add($"{GetOsFromRid(rid.ToString())}-x64");
+            }
+            else
+            {
+                convertedRids.Add($"{rid}");
+            }
+        }
+        return $"-property:RuntimeIdentifiers={string.Join("%3B", convertedRids)}";
+    }
+
+    private static IEnumerable<Option> ImplicitRestoreOptions(bool showHelp, bool useShortOptions, bool includeRuntimeOption, bool includeNoDependenciesOption)
+    {
+        if (showHelp && useShortOptions)
+        {
+            yield return SourceOption;
+        }
+        else
+        {
+            Option<IEnumerable<string>> sourceOption = new Option<IEnumerable<string>>("--source")
+            {
+                Description = showHelp ? CliCommandStrings.CmdSourceOptionDescription : string.Empty,
+                HelpName = CliCommandStrings.CmdSourceOption,
+                Hidden = !showHelp
+            }.ForwardAsSingle(o => $"-property:RestoreSources={string.Join("%3B", o)}") // '%3B' corresponds to ';'
+            .AllowSingleArgPerToken();
+
+            if (useShortOptions)
+            {
+                sourceOption.Aliases.Add("-s");
+            }
+
+            yield return sourceOption;
+        }
+
+        yield return new Option<string>("--packages")
+        {
+            Description = showHelp ? CliCommandStrings.CmdPackagesOptionDescription : string.Empty,
+            HelpName = CliCommandStrings.CmdPackagesOption,
+            Hidden = !showHelp
+        }.ForwardAsSingle(o => $"-property:RestorePackagesPath={CommandDirectoryContext.GetFullPath(o)}");
+
+        yield return CommonOptions.CurrentRuntimeOption(CliCommandStrings.CmdCurrentRuntimeOptionDescription);
+
+        yield return new Option<bool>("--disable-parallel")
+        {
+            Description = showHelp ? CliCommandStrings.CmdDisableParallelOptionDescription : string.Empty,
+            Hidden = !showHelp,
+            Arity = ArgumentArity.Zero
+        }.ForwardAs("-property:RestoreDisableParallel=true");
+
+        yield return new Option<string>("--configfile")
+        {
+            Description = showHelp ? CliCommandStrings.CmdConfigFileOptionDescription : string.Empty,
+            HelpName = CliCommandStrings.CmdConfigFileOption,
+            Hidden = !showHelp
+        }.ForwardAsSingle(o => $"-property:RestoreConfigFile={CommandDirectoryContext.GetFullPath(o)}");
+
+        yield return new Option<bool>("--no-cache")
+        {
+            Description = string.Empty,
+            Hidden = true,
+            Arity = ArgumentArity.Zero
+        }.ForwardAs("-property:RestoreNoCache=true");
+
+        yield return new Option<bool>("--no-http-cache")
+        {
+            Description = showHelp ? CliCommandStrings.CmdNoHttpCacheOptionDescription : string.Empty,
+            Hidden = !showHelp,
+            Arity = ArgumentArity.Zero
+        }.ForwardAs("-property:RestoreNoHttpCache=true");
+
+        yield return new Option<bool>("--ignore-failed-sources")
+        {
+            Description = showHelp ? CliCommandStrings.CmdIgnoreFailedSourcesOptionDescription : string.Empty,
+            Hidden = !showHelp,
+            Arity = ArgumentArity.Zero
+        }.ForwardAs("-property:RestoreIgnoreFailedSources=true");
+
+        Option<bool> forceOption = new Option<bool>("--force")
+        {
+            Description = CliCommandStrings.CmdForceRestoreOptionDescription,
+            Hidden = !showHelp,
+            Arity = ArgumentArity.Zero
+        }.ForwardAs("-property:RestoreForce=true");
+        if (useShortOptions)
+        {
+            forceOption.Aliases.Add("-f");
+        }
+        yield return forceOption;
+
+        yield return CommonOptions.PropertiesOption;
+        yield return CommonOptions.RestorePropertiesOption;
+
+        if (includeRuntimeOption)
+        {
+            Option<IEnumerable<string>> runtimeOption = new Option<IEnumerable<string>>("--runtime")
+            {
+                Description = CliCommandStrings.CmdRuntimeOptionDescription,
+                HelpName = CliCommandStrings.CmdRuntimeOption,
+                Hidden = !showHelp,
+                IsDynamic = true
+            }.ForwardAsSingle(RestoreRuntimeArgFunc)
+             .AllowSingleArgPerToken()
+             .AddCompletions(CliCompletion.RunTimesFromProjectFile);
+
+            if (useShortOptions)
+            {
+                runtimeOption.Aliases.Add("-r");
+            }
+
+            yield return runtimeOption;
+        }
+
+        if (includeNoDependenciesOption)
+        {
+            yield return new Option<bool>("--no-dependencies")
+            {
+                Description = CliCommandStrings.CmdNoDependenciesOptionDescription,
+                Arity = ArgumentArity.Zero,
+                Hidden = !showHelp
+            }.ForwardAs("-property:RestoreRecursive=false");
+        }
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Restore/RestoreCommandParser.cs b/src/Cli/dotnet/Commands/Restore/RestoreCommandParser.cs
index f32a0b1545b7..023214f2afa1 100644
--- a/src/Cli/dotnet/Commands/Restore/RestoreCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Restore/RestoreCommandParser.cs
@@ -2,228 +2,21 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
-using System.CommandLine.StaticCompletions;
-using Microsoft.DotNet.Cli.CommandLine;
-using NuGet.Packaging;
 
 namespace Microsoft.DotNet.Cli.Commands.Restore;
 
 internal static class RestoreCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-restore";
-
-    public static readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
-    {
-        Description = CliStrings.SolutionOrProjectOrFileArgumentDescription,
-        Arity = ArgumentArity.ZeroOrMore
-    };
-
-    public static readonly Option<IEnumerable<string>> SourceOption = new Option<IEnumerable<string>>("--source", "-s")
-    {
-        Description = CliCommandStrings.CmdSourceOptionDescription,
-        HelpName = CliCommandStrings.CmdSourceOption
-    }.ForwardAsSingle(o => $"-property:RestoreSources={string.Join("%3B", o)}")
-    .AllowSingleArgPerToken();
-
-    public static readonly Option<string[]> TargetOption = CommonOptions.RequiredMSBuildTargetOption("Restore");
-    public static readonly Option<Utils.VerbosityOptions> VerbosityOption = CommonOptions.VerbosityOption(Utils.VerbosityOptions.minimal);
-    public static readonly Option<bool> NoLogoOption = CommonOptions.NoLogoOption();
-
-    private static IEnumerable<Option> FullRestoreOptions() => [
-        ..ImplicitRestoreOptions(true, true, true, true),
-        VerbosityOption,
-        CommonOptions.InteractiveMsBuildForwardOption,
-        CommonOptions.ArtifactsPathOption,
-        new Option<bool>("--use-lock-file")
-        {
-            Description = CliCommandStrings.CmdUseLockFileOptionDescription,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestorePackagesWithLockFile=true"),
-        new Option<bool>("--locked-mode")
-        {
-            Description = CliCommandStrings.CmdLockedModeOptionDescription,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestoreLockedMode=true"),
-        new Option<string>("--lock-file-path")
-        {
-            Description = CliCommandStrings.CmdLockFilePathOptionDescription,
-            HelpName = CliCommandStrings.CmdLockFilePathOption
-        }.ForwardAsSingle(o => $"-property:NuGetLockFilePath={o}"),
-        new Option<bool>("--force-evaluate")
-        {
-            Description = CliCommandStrings.CmdReevaluateOptionDescription,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestoreForceEvaluate=true"),
-        TargetOption,
-        NoLogoOption
-    ];
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = SetAction(RestoreCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command SetAction(Command command)
     {
-        var command = new Command("restore", CliCommandStrings.RestoreAppFullName)
-        {
-            DocsLink = DocsLink
-        };
-
-        command.Arguments.Add(SlnOrProjectOrFileArgument);
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
-
-        command.Options.AddRange(FullRestoreOptions());
-
-        command.Options.Add(CommonOptions.ArchitectureOption);
-        command.Options.Add(CommonOptions.OperatingSystemOption);
-        command.Options.Add(CommonOptions.GetPropertyOption);
-        command.Options.Add(CommonOptions.GetItemOption);
-        command.Options.Add(CommonOptions.GetTargetResultOption);
-        command.Options.Add(CommonOptions.GetResultOutputFileOption);
         command.SetAction(RestoreCommand.Run);
-
         return command;
     }
-
-    public static void AddImplicitRestoreOptions(Command command, bool showHelp = false, bool useShortOptions = false, bool includeRuntimeOption = true, bool includeNoDependenciesOption = true)
-    {
-        foreach (var option in ImplicitRestoreOptions(showHelp, useShortOptions, includeRuntimeOption, includeNoDependenciesOption))
-        {
-            command.Options.Add(option);
-        }
-    }
-    private static string GetOsFromRid(string rid) => rid.Substring(0, rid.LastIndexOf("-", StringComparison.InvariantCulture));
-    private static string GetArchFromRid(string rid) => rid.Substring(rid.LastIndexOf("-", StringComparison.InvariantCulture) + 1, rid.Length - rid.LastIndexOf("-", StringComparison.InvariantCulture) - 1);
-    public static string RestoreRuntimeArgFunc(IEnumerable<string> rids)
-    {
-        List<string> convertedRids = [];
-        foreach (string rid in rids)
-        {
-            if (GetArchFromRid(rid.ToString()) == "amd64")
-            {
-                convertedRids.Add($"{GetOsFromRid(rid.ToString())}-x64");
-            }
-            else
-            {
-                convertedRids.Add($"{rid}");
-            }
-        }
-        return $"-property:RuntimeIdentifiers={string.Join("%3B", convertedRids)}";
-    }
-
-    private static IEnumerable<Option> ImplicitRestoreOptions(bool showHelp, bool useShortOptions, bool includeRuntimeOption, bool includeNoDependenciesOption)
-    {
-        if (showHelp && useShortOptions)
-        {
-            yield return SourceOption;
-        }
-        else
-        {
-            Option<IEnumerable<string>> sourceOption = new Option<IEnumerable<string>>("--source")
-            {
-                Description = showHelp ? CliCommandStrings.CmdSourceOptionDescription : string.Empty,
-                HelpName = CliCommandStrings.CmdSourceOption,
-                Hidden = !showHelp
-            }.ForwardAsSingle(o => $"-property:RestoreSources={string.Join("%3B", o)}") // '%3B' corresponds to ';'
-            .AllowSingleArgPerToken();
-
-            if (useShortOptions)
-            {
-                sourceOption.Aliases.Add("-s");
-            }
-
-            yield return sourceOption;
-        }
-
-        yield return new Option<string>("--packages")
-        {
-            Description = showHelp ? CliCommandStrings.CmdPackagesOptionDescription : string.Empty,
-            HelpName = CliCommandStrings.CmdPackagesOption,
-            Hidden = !showHelp
-        }.ForwardAsSingle(o => $"-property:RestorePackagesPath={CommandDirectoryContext.GetFullPath(o)}");
-
-        yield return CommonOptions.CurrentRuntimeOption(CliCommandStrings.CmdCurrentRuntimeOptionDescription);
-
-        yield return new Option<bool>("--disable-parallel")
-        {
-            Description = showHelp ? CliCommandStrings.CmdDisableParallelOptionDescription : string.Empty,
-            Hidden = !showHelp,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestoreDisableParallel=true");
-
-        yield return new Option<string>("--configfile")
-        {
-            Description = showHelp ? CliCommandStrings.CmdConfigFileOptionDescription : string.Empty,
-            HelpName = CliCommandStrings.CmdConfigFileOption,
-            Hidden = !showHelp
-        }.ForwardAsSingle(o => $"-property:RestoreConfigFile={CommandDirectoryContext.GetFullPath(o)}");
-
-        yield return new Option<bool>("--no-cache")
-        {
-            Description = string.Empty,
-            Hidden = true,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestoreNoCache=true");
-
-        yield return new Option<bool>("--no-http-cache")
-        {
-            Description = showHelp ? CliCommandStrings.CmdNoHttpCacheOptionDescription : string.Empty,
-            Hidden = !showHelp,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestoreNoHttpCache=true");
-
-        yield return new Option<bool>("--ignore-failed-sources")
-        {
-            Description = showHelp ? CliCommandStrings.CmdIgnoreFailedSourcesOptionDescription : string.Empty,
-            Hidden = !showHelp,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestoreIgnoreFailedSources=true");
-
-        Option<bool> forceOption = new Option<bool>("--force")
-        {
-            Description = CliCommandStrings.CmdForceRestoreOptionDescription,
-            Hidden = !showHelp,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("-property:RestoreForce=true");
-        if (useShortOptions)
-        {
-            forceOption.Aliases.Add("-f");
-        }
-        yield return forceOption;
-
-        yield return CommonOptions.PropertiesOption;
-        yield return CommonOptions.RestorePropertiesOption;
-
-        if (includeRuntimeOption)
-        {
-            Option<IEnumerable<string>> runtimeOption = new Option<IEnumerable<string>>("--runtime")
-            {
-                Description = CliCommandStrings.CmdRuntimeOptionDescription,
-                HelpName = CliCommandStrings.CmdRuntimeOption,
-                Hidden = !showHelp,
-                IsDynamic = true
-            }.ForwardAsSingle(RestoreRuntimeArgFunc)
-             .AllowSingleArgPerToken()
-             .AddCompletions(CliCompletion.RunTimesFromProjectFile);
-
-            if (useShortOptions)
-            {
-                runtimeOption.Aliases.Add("-r");
-            }
-
-            yield return runtimeOption;
-        }
-
-        if (includeNoDependenciesOption)
-        {
-            yield return new Option<bool>("--no-dependencies")
-            {
-                Description = CliCommandStrings.CmdNoDependenciesOptionDescription,
-                Arity = ArgumentArity.Zero,
-                Hidden = !showHelp
-            }.ForwardAs("-property:RestoreRecursive=false");
-        }
-    }
 }
diff --git a/src/Cli/dotnet/Commands/Run/Api/RunApiCommandDefinition.cs b/src/Cli/dotnet/Commands/Run/Api/RunApiCommandDefinition.cs
new file mode 100644
index 000000000000..7d216ae1e2e8
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Run/Api/RunApiCommandDefinition.cs
@@ -0,0 +1,18 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+
+namespace Microsoft.DotNet.Cli.Commands.Run.Api;
+
+internal sealed class RunApiCommandDefinition
+{
+    public static Command Create()
+    {
+        Command command = new("run-api")
+        {
+            Hidden = true,
+        };
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Run/Api/RunApiCommandParser.cs b/src/Cli/dotnet/Commands/Run/Api/RunApiCommandParser.cs
index 483b0b9fecfd..dc9ea1dccec5 100644
--- a/src/Cli/dotnet/Commands/Run/Api/RunApiCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Run/Api/RunApiCommandParser.cs
@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
@@ -7,13 +7,15 @@ namespace Microsoft.DotNet.Cli.Commands.Run.Api;
 
 internal sealed class RunApiCommandParser
 {
+    private static readonly Command Command = SetAction(RunApiCommandDefinition.Create());
+
     public static Command GetCommand()
     {
-        Command command = new("run-api")
-        {
-            Hidden = true,
-        };
+        return Command;
+    }
 
+    private static Command SetAction(Command command)
+    {
         command.SetAction((parseResult) => new RunApiCommand(parseResult).Execute());
         return command;
     }
diff --git a/src/Cli/dotnet/Commands/Run/RunCommand.cs b/src/Cli/dotnet/Commands/Run/RunCommand.cs
index a07f6358606c..28b45c03797d 100644
--- a/src/Cli/dotnet/Commands/Run/RunCommand.cs
+++ b/src/Cli/dotnet/Commands/Run/RunCommand.cs
@@ -157,7 +157,7 @@ public int Execute()
         {
             if (NoCache)
             {
-                throw new GracefulException(CliCommandStrings.CannotCombineOptions, RunCommandParser.NoCacheOption.Name, RunCommandParser.NoBuildOption.Name);
+                throw new GracefulException(CliCommandStrings.CannotCombineOptions, RunCommandDefinition.NoCacheOption.Name, RunCommandDefinition.NoBuildOption.Name);
             }
 
             if (EntryPointFileFullPath is not null)
@@ -687,7 +687,7 @@ public static RunCommand FromParseResult(ParseResult parseResult)
         // them to the restore args.
         // this is because we can't model the binlog command structure in MSbuild in the System.CommandLine parser, but we need
         // bl information to synchronize the restore and build logger configurations
-        var applicationArguments = parseResult.GetValue(RunCommandParser.ApplicationArguments)?.ToList();
+        var applicationArguments = parseResult.GetValue(RunCommandDefinition.ApplicationArguments)?.ToList();
 
         LoggerUtility.SeparateBinLogArguments(applicationArguments, out var binLogArgs, out var nonBinLogArgs);
 
@@ -703,12 +703,12 @@ public static RunCommand FromParseResult(ParseResult parseResult)
             parseResult.Tokens.TakeWhile(static t => t.Type != TokenType.DoubleDash)
                 .Any(static t => t is { Type: TokenType.Argument, Value: "-" });
 
-        string? projectOption = parseResult.GetValue(RunCommandParser.ProjectOption);
-        string? fileOption = parseResult.GetValue(RunCommandParser.FileOption);
+        string? projectOption = parseResult.GetValue(RunCommandDefinition.ProjectOption);
+        string? fileOption = parseResult.GetValue(RunCommandDefinition.FileOption);
 
         if (projectOption != null && fileOption != null)
         {
-            throw new GracefulException(CliCommandStrings.CannotCombineOptions, RunCommandParser.ProjectOption.Name, RunCommandParser.FileOption.Name);
+            throw new GracefulException(CliCommandStrings.CannotCombineOptions, RunCommandDefinition.ProjectOption.Name, RunCommandDefinition.FileOption.Name);
         }
 
         string[] args = [.. nonBinLogArgs];
@@ -719,8 +719,8 @@ public static RunCommand FromParseResult(ParseResult parseResult)
             ref args,
             out string? entryPointFilePath);
 
-        bool noBuild = parseResult.HasOption(RunCommandParser.NoBuildOption);
-        string launchProfile = parseResult.GetValue(RunCommandParser.LaunchProfileOption) ?? string.Empty;
+        bool noBuild = parseResult.HasOption(RunCommandDefinition.NoBuildOption);
+        string launchProfile = parseResult.GetValue(RunCommandDefinition.LaunchProfileOption) ?? string.Empty;
 
         if (readCodeFromStdin && entryPointFilePath != null)
         {
@@ -728,12 +728,12 @@ public static RunCommand FromParseResult(ParseResult parseResult)
 
             if (noBuild)
             {
-                throw new GracefulException(CliCommandStrings.InvalidOptionForStdin, RunCommandParser.NoBuildOption.Name);
+                throw new GracefulException(CliCommandStrings.InvalidOptionForStdin, RunCommandDefinition.NoBuildOption.Name);
             }
 
             if (!string.IsNullOrWhiteSpace(launchProfile))
             {
-                throw new GracefulException(CliCommandStrings.InvalidOptionForStdin, RunCommandParser.LaunchProfileOption.Name);
+                throw new GracefulException(CliCommandStrings.InvalidOptionForStdin, RunCommandDefinition.LaunchProfileOption.Name);
             }
 
             // If '-' is specified as the input file, read all text from stdin into a temporary file and use that as the entry point.
@@ -752,18 +752,18 @@ public static RunCommand FromParseResult(ParseResult parseResult)
             nonBinLogArgs[0] = entryPointFilePath;
         }
 
-        var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(msbuildProperties, CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.MSBuildTargetOption(), RunCommandParser.VerbosityOption);
+        var msbuildArgs = MSBuildArgs.AnalyzeMSBuildArguments(msbuildProperties, CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.MSBuildTargetOption(), RunCommandDefinition.VerbosityOption);
 
         var command = new RunCommand(
             noBuild: noBuild,
             projectFileFullPath: projectFilePath,
             entryPointFileFullPath: entryPointFilePath,
             launchProfile: launchProfile,
-            noLaunchProfile: parseResult.HasOption(RunCommandParser.NoLaunchProfileOption),
-            noLaunchProfileArguments: parseResult.HasOption(RunCommandParser.NoLaunchProfileArgumentsOption),
-            noRestore: parseResult.HasOption(RunCommandParser.NoRestoreOption) || parseResult.HasOption(RunCommandParser.NoBuildOption),
-            noCache: parseResult.HasOption(RunCommandParser.NoCacheOption),
-            interactive: parseResult.GetValue(RunCommandParser.InteractiveOption),
+            noLaunchProfile: parseResult.HasOption(RunCommandDefinition.NoLaunchProfileOption),
+            noLaunchProfileArguments: parseResult.HasOption(RunCommandDefinition.NoLaunchProfileArgumentsOption),
+            noRestore: parseResult.HasOption(RunCommandDefinition.NoRestoreOption) || parseResult.HasOption(RunCommandDefinition.NoBuildOption),
+            noCache: parseResult.HasOption(RunCommandDefinition.NoCacheOption),
+            interactive: parseResult.GetValue(RunCommandDefinition.InteractiveOption),
             msbuildArgs: msbuildArgs,
             applicationArgs: args,
             readCodeFromStdin: readCodeFromStdin,
diff --git a/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs b/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs
new file mode 100644
index 000000000000..080c2599a71a
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Run/RunCommandDefinition.cs
@@ -0,0 +1,111 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.ObjectModel;
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
+
+namespace Microsoft.DotNet.Cli.Commands.Run;
+
+internal static class RunCommandDefinition
+{
+    public static readonly string DocsLink = "https://aka.ms/dotnet-run";
+
+    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(CliCommandStrings.RunConfigurationOptionDescription);
+
+    public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(CliCommandStrings.RunFrameworkOptionDescription);
+
+    public static readonly Option<string> RuntimeOption = CommonOptions.RuntimeOption(CliCommandStrings.RunRuntimeOptionDescription);
+
+    public static readonly Option<string> ProjectOption = new("--project")
+    {
+        Description = CliCommandStrings.CmdProjectDescriptionFormat,
+        HelpName = CliCommandStrings.CommandOptionProjectHelpName
+    };
+
+    public static readonly Option<string> FileOption = new("--file")
+    {
+        Description = CliCommandStrings.CommandOptionFileDescription,
+        HelpName = CliCommandStrings.CommandOptionFileHelpName,
+    };
+
+    public static readonly Option<ReadOnlyDictionary<string, string>?> PropertyOption = CommonOptions.PropertiesOption;
+
+    public static readonly Option<string> LaunchProfileOption = new("--launch-profile", "-lp")
+    {
+        Description = CliCommandStrings.CommandOptionLaunchProfileDescription,
+        HelpName = CliCommandStrings.CommandOptionLaunchProfileHelpName
+    };
+
+    public static readonly Option<bool> NoLaunchProfileOption = new("--no-launch-profile")
+    {
+        Description = CliCommandStrings.CommandOptionNoLaunchProfileDescription,
+        Arity = ArgumentArity.Zero
+    };
+
+    public static readonly Option<bool> NoLaunchProfileArgumentsOption = new("--no-launch-profile-arguments")
+    {
+        Description = CliCommandStrings.CommandOptionNoLaunchProfileArgumentsDescription
+    };
+
+    public static readonly Option<bool> NoBuildOption = new("--no-build")
+    {
+        Description = CliCommandStrings.CommandOptionNoBuildDescription,
+        Arity = ArgumentArity.Zero
+    };
+
+    public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
+
+    public static readonly Option<bool> InteractiveOption = CommonOptions.InteractiveMsBuildForwardOption;
+
+    public static readonly Option<bool> NoCacheOption = new("--no-cache")
+    {
+        Description = CliCommandStrings.CommandOptionNoCacheDescription,
+        Arity = ArgumentArity.Zero,
+    };
+
+    public static readonly Option SelfContainedOption = CommonOptions.SelfContainedOption;
+
+    public static readonly Option NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
+
+    public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.VerbosityOption();
+
+    public static readonly Argument<string[]> ApplicationArguments = new("applicationArguments")
+    {
+        DefaultValueFactory = _ => [],
+        Description = "Arguments passed to the application that is being run."
+    };
+
+    public static Command Create()
+    {
+        Command command = new("run", CliCommandStrings.RunAppFullName)
+        {
+            DocsLink = DocsLink
+        };
+
+        command.Options.Add(ConfigurationOption);
+        command.Options.Add(FrameworkOption);
+        command.Options.Add(RuntimeOption);
+        command.Options.Add(ProjectOption);
+        command.Options.Add(FileOption);
+        command.Options.Add(PropertyOption);
+        command.Options.Add(LaunchProfileOption);
+        command.Options.Add(NoLaunchProfileOption);
+        command.Options.Add(NoBuildOption);
+        command.Options.Add(InteractiveOption);
+        command.Options.Add(NoRestoreOption);
+        command.Options.Add(NoCacheOption);
+        command.Options.Add(SelfContainedOption);
+        command.Options.Add(NoSelfContainedOption);
+        command.Options.Add(VerbosityOption);
+        command.Options.Add(CommonOptions.ArchitectureOption);
+        command.Options.Add(CommonOptions.OperatingSystemOption);
+        command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.ArtifactsPathOption);
+        command.Options.Add(CommonOptions.EnvOption);
+
+        command.Arguments.Add(ApplicationArguments);
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Run/RunCommandParser.cs b/src/Cli/dotnet/Commands/Run/RunCommandParser.cs
index 0f851f575c7e..1e25063f8c30 100644
--- a/src/Cli/dotnet/Commands/Run/RunCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Run/RunCommandParser.cs
@@ -1,120 +1,22 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Collections.ObjectModel;
 using System.CommandLine;
-using Microsoft.DotNet.Cli.CommandLine;
 
 namespace Microsoft.DotNet.Cli.Commands.Run;
 
 internal static class RunCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-run";
-
-    public static readonly Option<string?> ConfigurationOption = CommonOptions.ConfigurationOption(CliCommandStrings.RunConfigurationOptionDescription);
-
-    public static readonly Option<string> FrameworkOption = CommonOptions.FrameworkOption(CliCommandStrings.RunFrameworkOptionDescription);
-
-    public static readonly Option<string> RuntimeOption = CommonOptions.RuntimeOption(CliCommandStrings.RunRuntimeOptionDescription);
-
-    public static readonly Option<string> ProjectOption = new("--project")
-    {
-        Description = CliCommandStrings.CmdProjectDescriptionFormat,
-        HelpName = CliCommandStrings.CommandOptionProjectHelpName
-    };
-
-    public static readonly Option<string> FileOption = new("--file")
-    {
-        Description = CliCommandStrings.CommandOptionFileDescription,
-        HelpName = CliCommandStrings.CommandOptionFileHelpName,
-    };
-
-    public static readonly Option<ReadOnlyDictionary<string, string>?> PropertyOption = CommonOptions.PropertiesOption;
-
-    public static readonly Option<string> LaunchProfileOption = new("--launch-profile", "-lp")
-    {
-        Description = CliCommandStrings.CommandOptionLaunchProfileDescription,
-        HelpName = CliCommandStrings.CommandOptionLaunchProfileHelpName
-    };
-
-    public static readonly Option<bool> NoLaunchProfileOption = new("--no-launch-profile")
-    {
-        Description = CliCommandStrings.CommandOptionNoLaunchProfileDescription,
-        Arity = ArgumentArity.Zero
-    };
-
-    public static readonly Option<bool> NoLaunchProfileArgumentsOption = new("--no-launch-profile-arguments")
-    {
-        Description = CliCommandStrings.CommandOptionNoLaunchProfileArgumentsDescription
-    };
-
-    public static readonly Option<bool> NoBuildOption = new("--no-build")
-    {
-        Description = CliCommandStrings.CommandOptionNoBuildDescription,
-        Arity = ArgumentArity.Zero
-    };
-
-    public static readonly Option<bool> NoRestoreOption = CommonOptions.NoRestoreOption;
-
-    public static readonly Option<bool> InteractiveOption = CommonOptions.InteractiveMsBuildForwardOption;
-
-    public static readonly Option<bool> NoCacheOption = new("--no-cache")
-    {
-        Description = CliCommandStrings.CommandOptionNoCacheDescription,
-        Arity = ArgumentArity.Zero,
-    };
-
-    public static readonly Option SelfContainedOption = CommonOptions.SelfContainedOption;
-
-    public static readonly Option NoSelfContainedOption = CommonOptions.NoSelfContainedOption;
-
-    public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = CommonOptions.VerbosityOption();
-
-    public static readonly Argument<string[]> ApplicationArguments = new("applicationArguments")
-    {
-        DefaultValueFactory = _ => [],
-        Description = "Arguments passed to the application that is being run."
-    };
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = SetAction(RunCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command SetAction(Command command)
     {
-        Command command = new("run", CliCommandStrings.RunAppFullName)
-        {
-            DocsLink = DocsLink
-        };
-
-        command.Options.Add(ConfigurationOption);
-        command.Options.Add(FrameworkOption);
-        command.Options.Add(RuntimeOption);
-        command.Options.Add(ProjectOption);
-        command.Options.Add(FileOption);
-        command.Options.Add(PropertyOption);
-        command.Options.Add(LaunchProfileOption);
-        command.Options.Add(NoLaunchProfileOption);
-        command.Options.Add(NoBuildOption);
-        command.Options.Add(InteractiveOption);
-        command.Options.Add(NoRestoreOption);
-        command.Options.Add(NoCacheOption);
-        command.Options.Add(SelfContainedOption);
-        command.Options.Add(NoSelfContainedOption);
-        command.Options.Add(VerbosityOption);
-        command.Options.Add(CommonOptions.ArchitectureOption);
-        command.Options.Add(CommonOptions.OperatingSystemOption);
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
-        command.Options.Add(CommonOptions.ArtifactsPathOption);
-        command.Options.Add(CommonOptions.EnvOption);
-
-        command.Arguments.Add(ApplicationArguments);
-
         command.SetAction(RunCommand.Run);
-
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Sdk/Check/SdkCheckCommandDefinition.cs b/src/Cli/dotnet/Commands/Sdk/Check/SdkCheckCommandDefinition.cs
new file mode 100644
index 000000000000..e13f53ee231c
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Sdk/Check/SdkCheckCommandDefinition.cs
@@ -0,0 +1,14 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+
+namespace Microsoft.DotNet.Cli.Commands.Sdk.Check;
+
+internal static class SdkCheckCommandDefinition
+{
+    public const string Name = "check";
+
+    public static Command Create()
+        => new(Name, CliCommandStrings.SdkCheckAppFullName);
+}
diff --git a/src/Cli/dotnet/Commands/Sdk/Check/SdkCheckCommandParser.cs b/src/Cli/dotnet/Commands/Sdk/Check/SdkCheckCommandParser.cs
deleted file mode 100644
index 41a5a4c793bc..000000000000
--- a/src/Cli/dotnet/Commands/Sdk/Check/SdkCheckCommandParser.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-using System.CommandLine;
-
-namespace Microsoft.DotNet.Cli.Commands.Sdk.Check;
-
-internal static class SdkCheckCommandParser
-{
-    private static readonly Command Command = ConstructCommand();
-
-    public static Command GetCommand()
-    {
-        return Command;
-    }
-
-    private static Command ConstructCommand()
-    {
-        Command command = new("check", CliCommandStrings.SdkCheckAppFullName);
-
-        command.SetAction(SdkCheckCommand.Run);
-
-        return command;
-    }
-}
diff --git a/src/Cli/dotnet/Commands/Sdk/SdkCommandDefinition.cs b/src/Cli/dotnet/Commands/Sdk/SdkCommandDefinition.cs
new file mode 100644
index 000000000000..98b6b88c30e6
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Sdk/SdkCommandDefinition.cs
@@ -0,0 +1,24 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Sdk.Check;
+
+namespace Microsoft.DotNet.Cli.Commands.Sdk;
+
+internal static class SdkCommandDefinition
+{
+    public static readonly string DocsLink = "https://aka.ms/dotnet-sdk";
+
+    public static Command Create()
+    {
+        Command command = new("sdk", CliCommandStrings.SdkAppFullName)
+        {
+            DocsLink = DocsLink
+        };
+        command.Subcommands.Add(SdkCheckCommandDefinition.Create());
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Sdk/SdkCommandParser.cs b/src/Cli/dotnet/Commands/Sdk/SdkCommandParser.cs
index 0911409cee7a..53222f9631a0 100644
--- a/src/Cli/dotnet/Commands/Sdk/SdkCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Sdk/SdkCommandParser.cs
@@ -1,36 +1,27 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
 using Microsoft.DotNet.Cli.Commands.Sdk.Check;
-using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Extensions;
 
 namespace Microsoft.DotNet.Cli.Commands.Sdk;
 
 internal static class SdkCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-sdk";
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = ConfigureCommand(SdkCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command ConfigureCommand(Command command)
     {
-        Command command = new("sdk", CliCommandStrings.SdkAppFullName)
-        {
-            DocsLink = DocsLink
-        };
-        command.Subcommands.Add(SdkCheckCommandParser.GetCommand());
-
         command.SetAction((parseResult) => parseResult.HandleMissingCommand());
 
+        command.Subcommands.Single(c => c.Name == SdkCheckCommandDefinition.Name).SetAction(SdkCheckCommand.Run);
+
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Solution/Add/SolutionAddCommand.cs b/src/Cli/dotnet/Commands/Solution/Add/SolutionAddCommand.cs
index 338271e6c8cf..9aa48a7b289b 100644
--- a/src/Cli/dotnet/Commands/Solution/Add/SolutionAddCommand.cs
+++ b/src/Cli/dotnet/Commands/Solution/Add/SolutionAddCommand.cs
@@ -39,11 +39,11 @@ private static bool IsSolutionFolderPathInDirectoryScope(string relativePath)
 
     public SolutionAddCommand(ParseResult parseResult) : base(parseResult)
     {
-        _fileOrDirectory = parseResult.GetValue(SolutionCommandParser.SlnArgument)!;
-        _projects = (IReadOnlyCollection<string>)(parseResult.GetValue(SolutionAddCommandParser.ProjectPathArgument) ?? []);
-        _inRoot = parseResult.GetValue(SolutionAddCommandParser.InRootOption);
-        _solutionFolderPath = parseResult.GetValue(SolutionAddCommandParser.SolutionFolderOption);
-        _includeReferences = parseResult.GetValue(SolutionAddCommandParser.IncludeReferencesOption);
+        _fileOrDirectory = parseResult.GetValue(SolutionCommandDefinition.SlnArgument)!;
+        _projects = (IReadOnlyCollection<string>)(parseResult.GetValue(SolutionAddCommandDefinition.ProjectPathArgument) ?? []);
+        _inRoot = parseResult.GetValue(SolutionAddCommandDefinition.InRootOption);
+        _solutionFolderPath = parseResult.GetValue(SolutionAddCommandDefinition.SolutionFolderOption);
+        _includeReferences = parseResult.GetValue(SolutionAddCommandDefinition.IncludeReferencesOption);
         SolutionArgumentValidator.ParseAndValidateArguments(_fileOrDirectory, _projects, SolutionArgumentValidator.CommandType.Add, _inRoot, _solutionFolderPath);
         _solutionFileFullPath = SlnFileFactory.GetSolutionFileFullPath(_fileOrDirectory);
     }
diff --git a/src/Cli/dotnet/Commands/Solution/Add/SolutionAddCommandParser.cs b/src/Cli/dotnet/Commands/Solution/Add/SolutionAddCommandDefinition.cs
similarity index 75%
rename from src/Cli/dotnet/Commands/Solution/Add/SolutionAddCommandParser.cs
rename to src/Cli/dotnet/Commands/Solution/Add/SolutionAddCommandDefinition.cs
index 4925520938d4..100223b9af7e 100644
--- a/src/Cli/dotnet/Commands/Solution/Add/SolutionAddCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Solution/Add/SolutionAddCommandDefinition.cs
@@ -1,15 +1,14 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
-using System.CommandLine.Parsing;
 
 namespace Microsoft.DotNet.Cli.Commands.Solution.Add;
 
-public static class SolutionAddCommandParser
+public static class SolutionAddCommandDefinition
 {
+    public const string Name = "add";
+
     public static readonly Argument<IEnumerable<string>> ProjectPathArgument = new(CliCommandStrings.AddProjectPathArgumentName)
     {
         HelpName = CliCommandStrings.AddProjectPathArgumentName,
@@ -33,24 +32,15 @@ public static class SolutionAddCommandParser
         DefaultValueFactory = (_) => true,
     };
 
-    private static readonly Command Command = ConstructCommand();
-
-    public static Command GetCommand()
+    public static Command Create()
     {
-        return Command;
-    }
-
-    private static Command ConstructCommand()
-    {
-        Command command = new("add", CliCommandStrings.AddAppFullName);
+        Command command = new(Name, CliCommandStrings.AddAppFullName);
 
         command.Arguments.Add(ProjectPathArgument);
         command.Options.Add(InRootOption);
         command.Options.Add(SolutionFolderOption);
         command.Options.Add(IncludeReferencesOption);
 
-        command.SetAction((parseResult) => new SolutionAddCommand(parseResult).Execute());
-
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Solution/List/SolutionListCommand.cs b/src/Cli/dotnet/Commands/Solution/List/SolutionListCommand.cs
index a2093d9cbbba..f2600dc645d9 100644
--- a/src/Cli/dotnet/Commands/Solution/List/SolutionListCommand.cs
+++ b/src/Cli/dotnet/Commands/Solution/List/SolutionListCommand.cs
@@ -12,8 +12,8 @@ namespace Microsoft.DotNet.Cli.Commands.Solution.List;
 internal class SolutionListCommand(
     ParseResult parseResult) : CommandBase(parseResult)
 {
-    private readonly string _fileOrDirectory = parseResult.GetValue(SolutionCommandParser.SlnArgument);
-    private readonly bool _displaySolutionFolders = parseResult.GetValue(SolutionListCommandParser.SolutionFolderOption);
+    private readonly string _fileOrDirectory = parseResult.GetValue(SolutionCommandDefinition.SlnArgument);
+    private readonly bool _displaySolutionFolders = parseResult.GetValue(SolutionListCommandDefinition.SolutionFolderOption);
 
     public override int Execute()
     {
diff --git a/src/Cli/dotnet/Commands/Solution/List/SolutionListCommandParser.cs b/src/Cli/dotnet/Commands/Solution/List/SolutionListCommandDefinition.cs
similarity index 55%
rename from src/Cli/dotnet/Commands/Solution/List/SolutionListCommandParser.cs
rename to src/Cli/dotnet/Commands/Solution/List/SolutionListCommandDefinition.cs
index a3319d9c2dd0..b29d95e2c565 100644
--- a/src/Cli/dotnet/Commands/Solution/List/SolutionListCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Solution/List/SolutionListCommandDefinition.cs
@@ -1,34 +1,24 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
 
 namespace Microsoft.DotNet.Cli.Commands.Solution.List;
 
-public static class SolutionListCommandParser
+public static class SolutionListCommandDefinition
 {
+    public const string Name = "list";
+
     public static readonly Option<bool> SolutionFolderOption = new("--solution-folders")
     {
         Description = CliCommandStrings.ListSolutionFoldersArgumentDescription,
         Arity = ArgumentArity.Zero
     };
 
-    private static readonly Command Command = ConstructCommand();
-
-    public static Command GetCommand()
-    {
-        return Command;
-    }
-
-    private static Command ConstructCommand()
+    public static Command Create()
     {
-        Command command = new("list", CliCommandStrings.ListAppFullName);
-
+        Command command = new(Name, CliCommandStrings.ListAppFullName);
         command.Options.Add(SolutionFolderOption);
-        command.SetAction((parseResult) => new SolutionListCommand(parseResult).Execute());
-
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Solution/Migrate/SolutionMigrateCommand.cs b/src/Cli/dotnet/Commands/Solution/Migrate/SolutionMigrateCommand.cs
index 074431c8981b..28f874e70883 100644
--- a/src/Cli/dotnet/Commands/Solution/Migrate/SolutionMigrateCommand.cs
+++ b/src/Cli/dotnet/Commands/Solution/Migrate/SolutionMigrateCommand.cs
@@ -14,7 +14,7 @@ internal class SolutionMigrateCommand(
     ParseResult parseResult,
     IReporter reporter = null) : CommandBase(parseResult)
 {
-    private readonly string _slnFileOrDirectory = parseResult.GetValue(SolutionCommandParser.SlnArgument);
+    private readonly string _slnFileOrDirectory = parseResult.GetValue(SolutionCommandDefinition.SlnArgument);
     private readonly IReporter _reporter = reporter ?? Reporter.Output;
 
     public override int Execute()
diff --git a/src/Cli/dotnet/Commands/Solution/Migrate/SolutionMigrateCommandDefinition.cs b/src/Cli/dotnet/Commands/Solution/Migrate/SolutionMigrateCommandDefinition.cs
new file mode 100644
index 000000000000..0d705d30024e
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Solution/Migrate/SolutionMigrateCommandDefinition.cs
@@ -0,0 +1,18 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+
+namespace Microsoft.DotNet.Cli.Commands.Solution.Migrate;
+
+public static class SolutionMigrateCommandDefinition
+{
+    public const string Name = "migrate";
+
+    public static Command Create()
+    {
+        Command command = new(Name, CliCommandStrings.MigrateAppFullName);
+        command.Arguments.Add(SolutionCommandDefinition.SlnArgument);
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Solution/Migrate/SolutionMigrateCommandParser.cs b/src/Cli/dotnet/Commands/Solution/Migrate/SolutionMigrateCommandParser.cs
deleted file mode 100644
index 9eb23e1dfcf8..000000000000
--- a/src/Cli/dotnet/Commands/Solution/Migrate/SolutionMigrateCommandParser.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-using System.CommandLine;
-
-namespace Microsoft.DotNet.Cli.Commands.Solution.Migrate;
-
-public static class SolutionMigrateCommandParser
-{
-    private static readonly Command Command = ConstructCommand();
-
-    public static Command GetCommand()
-    {
-        return Command;
-    }
-
-    private static Command ConstructCommand()
-    {
-        Command command = new("migrate", CliCommandStrings.MigrateAppFullName);
-
-        command.Arguments.Add(SolutionCommandParser.SlnArgument);
-
-        command.SetAction((parseResult) => new SolutionMigrateCommand(parseResult).Execute());
-
-        return command;
-    }
-}
diff --git a/src/Cli/dotnet/Commands/Solution/Remove/SolutionRemoveCommand.cs b/src/Cli/dotnet/Commands/Solution/Remove/SolutionRemoveCommand.cs
index 36030bd22621..468fbe6acdf0 100644
--- a/src/Cli/dotnet/Commands/Solution/Remove/SolutionRemoveCommand.cs
+++ b/src/Cli/dotnet/Commands/Solution/Remove/SolutionRemoveCommand.cs
@@ -18,9 +18,9 @@ internal class SolutionRemoveCommand : CommandBase
 
     public SolutionRemoveCommand(ParseResult parseResult) : base(parseResult)
     {
-        _fileOrDirectory = parseResult.GetValue(SolutionCommandParser.SlnArgument);
+        _fileOrDirectory = parseResult.GetValue(SolutionCommandDefinition.SlnArgument);
 
-        _projects = (parseResult.GetValue(SolutionRemoveCommandParser.ProjectPathArgument) ?? []).ToList().AsReadOnly();
+        _projects = (parseResult.GetValue(SolutionRemoveCommandDefinition.ProjectPathArgument) ?? []).ToList().AsReadOnly();
 
         SolutionArgumentValidator.ParseAndValidateArguments(_fileOrDirectory, _projects, SolutionArgumentValidator.CommandType.Remove);
     }
diff --git a/src/Cli/dotnet/Commands/Solution/Remove/SolutionRemoveCommandParser.cs b/src/Cli/dotnet/Commands/Solution/Remove/SolutionRemoveCommandDefinition.cs
similarity index 60%
rename from src/Cli/dotnet/Commands/Solution/Remove/SolutionRemoveCommandParser.cs
rename to src/Cli/dotnet/Commands/Solution/Remove/SolutionRemoveCommandDefinition.cs
index d86a03f7f122..be3d2445ced9 100644
--- a/src/Cli/dotnet/Commands/Solution/Remove/SolutionRemoveCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Solution/Remove/SolutionRemoveCommandDefinition.cs
@@ -1,14 +1,14 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
 
 namespace Microsoft.DotNet.Cli.Commands.Solution.Remove;
 
-public static class SolutionRemoveCommandParser
+public static class SolutionRemoveCommandDefinition
 {
+    public const string Name = "remove";
+
     public static readonly Argument<IEnumerable<string>> ProjectPathArgument = new(CliCommandStrings.RemoveProjectPathArgumentName)
     {
         HelpName = CliCommandStrings.RemoveProjectPathArgumentName,
@@ -16,21 +16,10 @@ public static class SolutionRemoveCommandParser
         Arity = ArgumentArity.ZeroOrMore
     };
 
-    private static readonly Command Command = ConstructCommand();
-
-    public static Command GetCommand()
+    public static Command Create()
     {
-        return Command;
-    }
-
-    private static Command ConstructCommand()
-    {
-        Command command = new("remove", CliCommandStrings.RemoveAppFullName);
-
+        Command command = new(Name, CliCommandStrings.RemoveAppFullName);
         command.Arguments.Add(ProjectPathArgument);
-
-        command.SetAction((parseResult) => new SolutionRemoveCommand(parseResult).Execute());
-
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Solution/SolutionArgumentValidator.cs b/src/Cli/dotnet/Commands/Solution/SolutionArgumentValidator.cs
index 29be57c76894..56417d6b8a55 100644
--- a/src/Cli/dotnet/Commands/Solution/SolutionArgumentValidator.cs
+++ b/src/Cli/dotnet/Commands/Solution/SolutionArgumentValidator.cs
@@ -38,11 +38,11 @@ public static void ParseAndValidateArguments(string _fileOrDirectory, IReadOnlyC
             string args;
             if (_inRoot)
             {
-                args = $"--{SolutionAddCommandParser.InRootOption.Name} ";
+                args = $"--{SolutionAddCommandDefinition.InRootOption.Name} ";
             }
             else if (hasRelativeRoot)
             {
-                args = $"--{SolutionAddCommandParser.SolutionFolderOption.Name} {string.Join(" ", relativeRoot)} ";
+                args = $"--{SolutionAddCommandDefinition.SolutionFolderOption.Name} {string.Join(" ", relativeRoot)} ";
             }
             else
             {
diff --git a/src/Cli/dotnet/Commands/Solution/SolutionCommandDefinition.cs b/src/Cli/dotnet/Commands/Solution/SolutionCommandDefinition.cs
new file mode 100644
index 000000000000..32d23c13a8bf
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Solution/SolutionCommandDefinition.cs
@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Solution.Add;
+using Microsoft.DotNet.Cli.Commands.Solution.List;
+using Microsoft.DotNet.Cli.Commands.Solution.Migrate;
+using Microsoft.DotNet.Cli.Commands.Solution.Remove;
+
+namespace Microsoft.DotNet.Cli.Commands.Solution;
+
+internal static class SolutionCommandDefinition
+{
+    public static readonly string DocsLink = "https://aka.ms/dotnet-sln";
+
+    public static readonly string CommandName = "solution";
+    public static readonly string CommandAlias = "sln";
+    public static readonly Argument<string> SlnArgument = new Argument<string>(CliCommandStrings.SolutionArgumentName)
+    {
+        HelpName = CliCommandStrings.SolutionArgumentName,
+        Description = CliCommandStrings.SolutionArgumentDescription,
+        Arity = ArgumentArity.ZeroOrOne
+    }.DefaultToCurrentDirectory();
+
+    public static Command Create()
+    {
+        Command command = new(CommandName, CliCommandStrings.SolutionAppFullName)
+        {
+            DocsLink = DocsLink
+        };
+
+        command.Aliases.Add(CommandAlias);
+
+        command.Arguments.Add(SlnArgument);
+        command.Subcommands.Add(SolutionAddCommandDefinition.Create());
+        command.Subcommands.Add(SolutionListCommandDefinition.Create());
+        command.Subcommands.Add(SolutionRemoveCommandDefinition.Create());
+        command.Subcommands.Add(SolutionMigrateCommandDefinition.Create());
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Solution/SolutionCommandParser.cs b/src/Cli/dotnet/Commands/Solution/SolutionCommandParser.cs
index f5cc8869a10f..0f02b475bbd0 100644
--- a/src/Cli/dotnet/Commands/Solution/SolutionCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Solution/SolutionCommandParser.cs
@@ -1,54 +1,32 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
 using Microsoft.DotNet.Cli.Commands.Solution.Add;
 using Microsoft.DotNet.Cli.Commands.Solution.List;
 using Microsoft.DotNet.Cli.Commands.Solution.Migrate;
 using Microsoft.DotNet.Cli.Commands.Solution.Remove;
-using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Extensions;
 
 namespace Microsoft.DotNet.Cli.Commands.Solution;
 
 internal static class SolutionCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-sln";
-
-    public static readonly string CommandName = "solution";
-    public static readonly string CommandAlias = "sln";
-    public static readonly Argument<string> SlnArgument = new Argument<string>(CliCommandStrings.SolutionArgumentName)
-    {
-        HelpName = CliCommandStrings.SolutionArgumentName,
-        Description = CliCommandStrings.SolutionArgumentDescription,
-        Arity = ArgumentArity.ZeroOrOne
-    }.DefaultToCurrentDirectory();
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = ConfigureCommand(SolutionCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command ConfigureCommand(Command command)
     {
-        Command command = new(CommandName, CliCommandStrings.SolutionAppFullName)
-        {
-            DocsLink = DocsLink
-        };
-
-        command.Aliases.Add(CommandAlias);
-
-        command.Arguments.Add(SlnArgument);
-        command.Subcommands.Add(SolutionAddCommandParser.GetCommand());
-        command.Subcommands.Add(SolutionListCommandParser.GetCommand());
-        command.Subcommands.Add(SolutionRemoveCommandParser.GetCommand());
-        command.Subcommands.Add(SolutionMigrateCommandParser.GetCommand());
+        command.SetAction(parseResult => parseResult.HandleMissingCommand());
 
-        command.SetAction((parseResult) => parseResult.HandleMissingCommand());
+        command.Subcommands.Single(c => c.Name == SolutionAddCommandDefinition.Name).SetAction(parseResult => new SolutionAddCommand(parseResult).Execute());
+        command.Subcommands.Single(c => c.Name == SolutionListCommandDefinition.Name).SetAction(parseResult => new SolutionListCommand(parseResult).Execute());
+        command.Subcommands.Single(c => c.Name == SolutionMigrateCommandDefinition.Name).SetAction(parseResult => new SolutionMigrateCommand(parseResult).Execute());
+        command.Subcommands.Single(c => c.Name == SolutionRemoveCommandDefinition.Name).SetAction(parseResult => new SolutionRemoveCommand(parseResult).Execute());
 
         return command;
     }
diff --git a/src/Cli/dotnet/Commands/Store/StoreCommand.cs b/src/Cli/dotnet/Commands/Store/StoreCommand.cs
index 8ced53fdb48f..6c5b2953f7be 100644
--- a/src/Cli/dotnet/Commands/Store/StoreCommand.cs
+++ b/src/Cli/dotnet/Commands/Store/StoreCommand.cs
@@ -30,14 +30,14 @@ public static StoreCommand FromParseResult(ParseResult result, string msbuildPat
 
         result.ShowHelpOrErrorIfAppropriate();
 
-        if (!result.HasOption(StoreCommandParser.ManifestOption))
+        if (!result.HasOption(StoreCommandDefinition.ManifestOption))
         {
             throw new GracefulException(CliCommandStrings.SpecifyManifests);
         }
 
         msbuildArgs.AddRange(result.OptionValuesToBeForwarded(StoreCommandParser.GetCommand()));
 
-        msbuildArgs.AddRange(result.GetValue(StoreCommandParser.Argument) ?? []);
+        msbuildArgs.AddRange(result.GetValue(StoreCommandDefinition.Argument) ?? []);
 
         return new StoreCommand(msbuildArgs, msbuildPath);
     }
diff --git a/src/Cli/dotnet/Commands/Store/StoreCommandDefinition.cs b/src/Cli/dotnet/Commands/Store/StoreCommandDefinition.cs
new file mode 100644
index 000000000000..3a2241194f40
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Store/StoreCommandDefinition.cs
@@ -0,0 +1,93 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
+using Microsoft.DotNet.Cli.Extensions;
+
+namespace Microsoft.DotNet.Cli.Commands.Store;
+
+internal static class StoreCommandDefinition
+{
+    public static readonly string DocsLink = "https://aka.ms/dotnet-store";
+
+    public static readonly Argument<IEnumerable<string>> Argument = new("argument")
+    {
+        Arity = ArgumentArity.ZeroOrMore,
+    };
+
+    public static readonly Option<IEnumerable<string>> ManifestOption = new Option<IEnumerable<string>>("--manifest", "-m")
+    {
+        Description = CliCommandStrings.ProjectManifestDescription,
+        HelpName = CliCommandStrings.ProjectManifest,
+        Arity = ArgumentArity.OneOrMore
+    }.ForwardAsMany(o =>
+    {
+        // the first path doesn't need to go through CommandDirectoryContext.ExpandPath
+        // since it is a direct argument to MSBuild, not a property
+        var materializedString = $"{o!.First()}";
+
+        if (o!.Count() == 1)
+        {
+            return [materializedString];
+        }
+        else
+        {
+            return [materializedString, $"-property:AdditionalProjects={string.Join("%3B", o!.Skip(1).Select(CommandDirectoryContext.GetFullPath))}"];
+        }
+    }).AllowSingleArgPerToken();
+
+    public static readonly Option<string> FrameworkVersionOption = new Option<string>("--framework-version")
+    {
+        Description = CliCommandStrings.FrameworkVersionOptionDescription,
+        HelpName = CliCommandStrings.FrameworkVersionOption
+    }.ForwardAsSingle(o => $"-property:RuntimeFrameworkVersion={o}");
+
+    public static readonly Option<string> OutputOption = new Option<string>("--output", "-o")
+    {
+        Description = CliCommandStrings.StoreOutputOptionDescription,
+        HelpName = CliCommandStrings.StoreOutputOption
+    }.ForwardAsOutputPath("ComposeDir");
+
+    public static readonly Option<string> WorkingDirOption = new Option<string>("--working-dir", "-w")
+    {
+        Description = CliCommandStrings.IntermediateWorkingDirOptionDescription,
+        HelpName = CliCommandStrings.IntermediateWorkingDirOption
+    }.ForwardAsSingle(o => $"-property:ComposeWorkingDir={CommandDirectoryContext.GetFullPath(o)}");
+
+    public static readonly Option<bool> SkipOptimizationOption = new Option<bool>("--skip-optimization")
+    {
+        Description = CliCommandStrings.SkipOptimizationOptionDescription,
+        Arity = ArgumentArity.Zero
+    }.ForwardAs("-property:SkipOptimization=true");
+
+    public static readonly Option<bool> SkipSymbolsOption = new Option<bool>("--skip-symbols")
+    {
+        Description = CliCommandStrings.SkipSymbolsOptionDescription,
+        Arity = ArgumentArity.Zero
+    }.ForwardAs("-property:CreateProfilingSymbols=false");
+
+    public static Command Create()
+    {
+        Command command = new("store", CliCommandStrings.StoreAppDescription)
+        {
+            DocsLink = DocsLink
+        };
+
+        command.Arguments.Add(Argument);
+        command.Options.Add(ManifestOption);
+        command.Options.Add(FrameworkVersionOption);
+        command.Options.Add(OutputOption);
+        command.Options.Add(WorkingDirOption);
+        command.Options.Add(SkipOptimizationOption);
+        command.Options.Add(SkipSymbolsOption);
+        command.Options.Add(CommonOptions.FrameworkOption(CliCommandStrings.StoreFrameworkOptionDescription));
+        command.Options.Add(CommonOptions.RuntimeOption(CliCommandStrings.StoreRuntimeOptionDescription));
+        command.Options.Add(CommonOptions.VerbosityOption());
+        command.Options.Add(CommonOptions.CurrentRuntimeOption(CliCommandStrings.CurrentRuntimeOptionDescription));
+        command.Options.Add(CommonOptions.DisableBuildServersOption);
+        command.Options.Add(CommonOptions.NoLogoOption(true));
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Store/StoreCommandParser.cs b/src/Cli/dotnet/Commands/Store/StoreCommandParser.cs
index 0c963fefaa5a..b96a3b30b931 100644
--- a/src/Cli/dotnet/Commands/Store/StoreCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Store/StoreCommandParser.cs
@@ -2,101 +2,21 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
-using Microsoft.DotNet.Cli.CommandLine;
-using Microsoft.DotNet.Cli.Extensions;
 
 namespace Microsoft.DotNet.Cli.Commands.Store;
 
 internal static class StoreCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-store";
-
-    public static readonly Argument<IEnumerable<string>> Argument = new("argument")
-    {
-        Arity = ArgumentArity.ZeroOrMore,
-    };
-
-    public static readonly Option<IEnumerable<string>> ManifestOption = new Option<IEnumerable<string>>("--manifest", "-m")
-    {
-        Description = CliCommandStrings.ProjectManifestDescription,
-        HelpName = CliCommandStrings.ProjectManifest,
-        Arity = ArgumentArity.OneOrMore
-    }.ForwardAsMany(o =>
-    {
-        // the first path doesn't need to go through CommandDirectoryContext.ExpandPath
-        // since it is a direct argument to MSBuild, not a property
-        var materializedString = $"{o!.First()}";
-
-        if (o!.Count() == 1)
-        {
-            return [materializedString];
-        }
-        else
-        {
-            return [materializedString, $"-property:AdditionalProjects={string.Join("%3B", o!.Skip(1).Select(CommandDirectoryContext.GetFullPath))}"];
-        }
-    }).AllowSingleArgPerToken();
-
-    public static readonly Option<string> FrameworkVersionOption = new Option<string>("--framework-version")
-    {
-        Description = CliCommandStrings.FrameworkVersionOptionDescription,
-        HelpName = CliCommandStrings.FrameworkVersionOption
-    }.ForwardAsSingle(o => $"-property:RuntimeFrameworkVersion={o}");
-
-    public static readonly Option<string> OutputOption = new Option<string>("--output", "-o")
-    {
-        Description = CliCommandStrings.StoreOutputOptionDescription,
-        HelpName = CliCommandStrings.StoreOutputOption
-    }.ForwardAsOutputPath("ComposeDir");
-
-    public static readonly Option<string> WorkingDirOption = new Option<string>("--working-dir", "-w")
-    {
-        Description = CliCommandStrings.IntermediateWorkingDirOptionDescription,
-        HelpName = CliCommandStrings.IntermediateWorkingDirOption
-    }.ForwardAsSingle(o => $"-property:ComposeWorkingDir={CommandDirectoryContext.GetFullPath(o)}");
-
-    public static readonly Option<bool> SkipOptimizationOption = new Option<bool>("--skip-optimization")
-    {
-        Description = CliCommandStrings.SkipOptimizationOptionDescription,
-        Arity = ArgumentArity.Zero
-    }.ForwardAs("-property:SkipOptimization=true");
-
-    public static readonly Option<bool> SkipSymbolsOption = new Option<bool>("--skip-symbols")
-    {
-        Description = CliCommandStrings.SkipSymbolsOptionDescription,
-        Arity = ArgumentArity.Zero
-    }.ForwardAs("-property:CreateProfilingSymbols=false");
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = SetAction(StoreCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command SetAction(Command command)
     {
-        Command command = new("store", CliCommandStrings.StoreAppDescription)
-        {
-            DocsLink = DocsLink
-        };
-
-        command.Arguments.Add(Argument);
-        command.Options.Add(ManifestOption);
-        command.Options.Add(FrameworkVersionOption);
-        command.Options.Add(OutputOption);
-        command.Options.Add(WorkingDirOption);
-        command.Options.Add(SkipOptimizationOption);
-        command.Options.Add(SkipSymbolsOption);
-        command.Options.Add(CommonOptions.FrameworkOption(CliCommandStrings.StoreFrameworkOptionDescription));
-        command.Options.Add(CommonOptions.RuntimeOption(CliCommandStrings.StoreRuntimeOptionDescription));
-        command.Options.Add(CommonOptions.VerbosityOption());
-        command.Options.Add(CommonOptions.CurrentRuntimeOption(CliCommandStrings.CurrentRuntimeOptionDescription));
-        command.Options.Add(CommonOptions.DisableBuildServersOption);
-        command.Options.Add(CommonOptions.NoLogoOption(true));
-
         command.SetAction(StoreCommand.Run);
-
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Tool/ToolCommandDefinition.cs b/src/Cli/dotnet/Commands/Tool/ToolCommandDefinition.cs
new file mode 100644
index 000000000000..665f6aade75c
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Tool/ToolCommandDefinition.cs
@@ -0,0 +1,39 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.CommandLine;
+using Microsoft.DotNet.Cli.CommandLine;
+using Microsoft.DotNet.Cli.Commands.Tool.Execute;
+using Microsoft.DotNet.Cli.Commands.Tool.Install;
+using Microsoft.DotNet.Cli.Commands.Tool.List;
+using Microsoft.DotNet.Cli.Commands.Tool.Restore;
+using Microsoft.DotNet.Cli.Commands.Tool.Run;
+using Microsoft.DotNet.Cli.Commands.Tool.Search;
+using Microsoft.DotNet.Cli.Commands.Tool.Uninstall;
+using Microsoft.DotNet.Cli.Commands.Tool.Update;
+
+namespace Microsoft.DotNet.Cli.Commands.Tool;
+
+internal static class ToolCommandDefinition
+{
+    public static readonly string DocsLink = "https://aka.ms/dotnet-tool";
+
+    public static Command Create()
+    {
+        Command command = new("tool", CliCommandStrings.ToolCommandDescription)
+        {
+            DocsLink = DocsLink
+        };
+
+        command.Subcommands.Add(ToolInstallCommandParser.GetCommand());
+        command.Subcommands.Add(ToolUninstallCommandParser.GetCommand());
+        command.Subcommands.Add(ToolUpdateCommandParser.GetCommand());
+        command.Subcommands.Add(ToolListCommandParser.GetCommand());
+        command.Subcommands.Add(ToolRunCommandParser.GetCommand());
+        command.Subcommands.Add(ToolSearchCommandParser.GetCommand());
+        command.Subcommands.Add(ToolRestoreCommandParser.GetCommand());
+        command.Subcommands.Add(ToolExecuteCommandParser.GetCommand());
+
+        return command;
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Tool/ToolCommandParser.cs b/src/Cli/dotnet/Commands/Tool/ToolCommandParser.cs
index 5354c9355e67..dcd2e9434884 100644
--- a/src/Cli/dotnet/Commands/Tool/ToolCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Tool/ToolCommandParser.cs
@@ -1,8 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
 using Microsoft.DotNet.Cli.Commands.Tool.Execute;
 using Microsoft.DotNet.Cli.Commands.Tool.Install;
@@ -12,40 +10,22 @@
 using Microsoft.DotNet.Cli.Commands.Tool.Search;
 using Microsoft.DotNet.Cli.Commands.Tool.Uninstall;
 using Microsoft.DotNet.Cli.Commands.Tool.Update;
-using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Extensions;
 
 namespace Microsoft.DotNet.Cli.Commands.Tool;
 
 internal static class ToolCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-tool";
-
-    private static readonly Command Command = ConstructCommand();
+    private static readonly Command Command = ConfigureCommand(ToolCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static Command ConstructCommand()
+    private static Command ConfigureCommand(Command command)
     {
-        Command command = new("tool", CliCommandStrings.ToolCommandDescription)
-        {
-            DocsLink = DocsLink
-        };
-
-        command.Subcommands.Add(ToolInstallCommandParser.GetCommand());
-        command.Subcommands.Add(ToolUninstallCommandParser.GetCommand());
-        command.Subcommands.Add(ToolUpdateCommandParser.GetCommand());
-        command.Subcommands.Add(ToolListCommandParser.GetCommand());
-        command.Subcommands.Add(ToolRunCommandParser.GetCommand());
-        command.Subcommands.Add(ToolSearchCommandParser.GetCommand());
-        command.Subcommands.Add(ToolRestoreCommandParser.GetCommand());
-        command.Subcommands.Add(ToolExecuteCommandParser.GetCommand());
-
         command.SetAction((parseResult) => parseResult.HandleMissingCommand());
-
         return command;
     }
 }
diff --git a/src/Cli/dotnet/Commands/Workload/WorkloadCommandDefinition.cs b/src/Cli/dotnet/Commands/Workload/WorkloadCommandDefinition.cs
new file mode 100644
index 000000000000..a8f905e90215
--- /dev/null
+++ b/src/Cli/dotnet/Commands/Workload/WorkloadCommandDefinition.cs
@@ -0,0 +1,191 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#nullable disable
+
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using Microsoft.DotNet.Cli.Commands.Workload.Clean;
+using Microsoft.DotNet.Cli.Commands.Workload.Config;
+using Microsoft.DotNet.Cli.Commands.Workload.Elevate;
+using Microsoft.DotNet.Cli.Commands.Workload.History;
+using Microsoft.DotNet.Cli.Commands.Workload.Install;
+using Microsoft.DotNet.Cli.Commands.Workload.List;
+using Microsoft.DotNet.Cli.Commands.Workload.Repair;
+using Microsoft.DotNet.Cli.Commands.Workload.Restore;
+using Microsoft.DotNet.Cli.Commands.Workload.Search;
+using Microsoft.DotNet.Cli.Commands.Workload.Uninstall;
+using Microsoft.DotNet.Cli.Commands.Workload.Update;
+using Microsoft.DotNet.Cli.Extensions;
+using Microsoft.DotNet.Cli.Utils;
+using Microsoft.NET.Sdk.WorkloadManifestReader;
+using Microsoft.TemplateEngine.Cli.Commands;
+using IReporter = Microsoft.DotNet.Cli.Utils.IReporter;
+using Command = System.CommandLine.Command;
+using Microsoft.DotNet.Cli.CommandLine;
+
+namespace Microsoft.DotNet.Cli.Commands.Workload;
+
+internal static class WorkloadCommandDefinition
+{
+    public static readonly string DocsLink = "https://aka.ms/dotnet-workload";
+    public static readonly Option<bool> InfoOption = new("--info")
+    {
+        Description = CliCommandStrings.WorkloadInfoDescription,
+        Arity = ArgumentArity.Zero,
+        Action = new ShowWorkloadsInfoAction()
+    };
+
+    public static readonly Option<bool> VersionOption = new("--version")
+    {
+        Description = CliCommandStrings.WorkloadVersionDescription,
+        Arity = ArgumentArity.Zero,
+        Action = new ShowWorkloadsVersionOption()
+    };
+
+    internal static string GetWorkloadsVersion(WorkloadInfoHelper workloadInfoHelper = null)
+    {
+        workloadInfoHelper ??= new WorkloadInfoHelper(false);
+
+        var versionInfo = workloadInfoHelper.ManifestProvider.GetWorkloadVersion();
+
+        // The explicit space here is intentional, as it's easy to miss in localization and crucial for parsing
+        return versionInfo.Version + (versionInfo.IsInstalled ? string.Empty : ' ' + CliCommandStrings.WorkloadVersionNotInstalledShort);
+    }
+
+    internal static void ShowWorkloadsInfo(ParseResult parseResult = null, WorkloadInfoHelper workloadInfoHelper = null, IReporter reporter = null, string dotnetDir = null, bool showVersion = true)
+    {
+        workloadInfoHelper ??= new WorkloadInfoHelper(parseResult != null ? parseResult.HasOption(SharedOptions.InteractiveOption) : false);
+        reporter ??= Reporter.Output;
+        var versionInfo = workloadInfoHelper.ManifestProvider.GetWorkloadVersion();
+
+        void WriteUpdateModeAndAnyError(string indent = "")
+        {
+            var useWorkloadSets = InstallStateContents.FromPath(Path.Combine(WorkloadInstallType.GetInstallStateFolder(workloadInfoHelper._currentSdkFeatureBand, workloadInfoHelper.UserLocalPath), "default.json")).ShouldUseWorkloadSets();
+            var configurationMessage = useWorkloadSets
+                ? CliCommandStrings.WorkloadManifestInstallationConfigurationWorkloadSets
+                : CliCommandStrings.WorkloadManifestInstallationConfigurationLooseManifests;
+            reporter.WriteLine(indent + configurationMessage);
+
+            if (!versionInfo.IsInstalled)
+            {
+                reporter.WriteLine(indent + string.Format(CliCommandStrings.WorkloadSetFromGlobalJsonNotInstalled, versionInfo.Version, versionInfo.GlobalJsonPath));
+            }
+            else if (versionInfo.WorkloadSetsEnabledWithoutWorkloadSet)
+            {
+                reporter.WriteLine(indent + CliCommandStrings.ShouldInstallAWorkloadSet);
+            }
+        }
+
+        if (showVersion)
+        {
+            reporter.WriteLine($" Workload version: {GetWorkloadsVersion()}");
+
+            WriteUpdateModeAndAnyError(indent: " ");
+            reporter.WriteLine();
+        }
+
+        if (versionInfo.IsInstalled)
+        {
+            IEnumerable<WorkloadId> installedList = workloadInfoHelper.InstalledSdkWorkloadIds;
+            InstalledWorkloadsCollection installedWorkloads = workloadInfoHelper.AddInstalledVsWorkloads(installedList);
+            string dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
+
+            if (installedWorkloads.Count == 0)
+            {
+                reporter.WriteLine(CliCommandStrings.NoWorkloadsInstalledInfoWarning);
+            }
+            else
+            {
+                var manifestInfoDict = workloadInfoHelper.WorkloadResolver.GetInstalledManifests().ToDictionary(info => info.Id, StringComparer.OrdinalIgnoreCase);
+
+                foreach (var workload in installedWorkloads.AsEnumerable())
+                {
+                    var workloadManifest = workloadInfoHelper.WorkloadResolver.GetManifestFromWorkload(new WorkloadId(workload.Key));
+                    var workloadFeatureBand = manifestInfoDict[workloadManifest.Id].ManifestFeatureBand;
+
+                    const int align = 10;
+                    const string separator = "   ";
+
+                    reporter.WriteLine($" [{workload.Key}]");
+
+                    reporter.Write($"{separator}{CliCommandStrings.WorkloadSourceColumn}:");
+                    reporter.WriteLine($" {workload.Value,align}");
+
+                    reporter.Write($"{separator}{CliCommandStrings.WorkloadManifestVersionColumn}:");
+                    reporter.WriteLine($"    {workloadManifest.Version + '/' + workloadFeatureBand,align}");
+
+                    reporter.Write($"{separator}{CliCommandStrings.WorkloadManifestPathColumn}:");
+                    reporter.WriteLine($"       {workloadManifest.ManifestPath,align}");
+
+                    reporter.Write($"{separator}{CliCommandStrings.WorkloadInstallTypeColumn}:");
+                    reporter.WriteLine($"       {WorkloadInstallType.GetWorkloadInstallType(new SdkFeatureBand(Product.Version), dotnetPath).ToString(),align}"
+                    );
+                    reporter.WriteLine("");
+                }
+            }
+        }
+
+        if (!showVersion)
+        {
+            WriteUpdateModeAndAnyError();
+        }
+    }
+
+    public static Command Create()
+    {
+        Command command = new("workload", CliCommandStrings.WorkloadCommandDescription)
+        {
+            DocsLink = DocsLink
+        };
+
+        command.Subcommands.Add(WorkloadInstallCommandParser.GetCommand());
+        command.Subcommands.Add(WorkloadUpdateCommandParser.GetCommand());
+        command.Subcommands.Add(WorkloadListCommandParser.GetCommand());
+        command.Subcommands.Add(WorkloadSearchCommandParser.GetCommand());
+        command.Subcommands.Add(WorkloadUninstallCommandParser.GetCommand());
+        command.Subcommands.Add(WorkloadRepairCommandParser.GetCommand());
+        command.Subcommands.Add(WorkloadRestoreCommandParser.GetCommand());
+        command.Subcommands.Add(WorkloadCleanCommandParser.GetCommand());
+        command.Subcommands.Add(WorkloadElevateCommandParser.GetCommand());
+        command.Subcommands.Add(WorkloadConfigCommandParser.GetCommand());
+        command.Subcommands.Add(WorkloadHistoryCommandParser.GetCommand());
+
+        command.Options.Add(InfoOption);
+        command.Options.Add(VersionOption);
+
+        command.Validators.Add(commandResult =>
+        {
+            if (commandResult.HasOption(InfoOption) && commandResult.HasOption(VersionOption) && !commandResult.Children.Any(child => child is System.CommandLine.Parsing.CommandResult))
+            {
+                commandResult.AddError(CliStrings.RequiredCommandNotPassed);
+            }
+        });
+
+        return command;
+    }
+
+    private class ShowWorkloadsInfoAction : SynchronousCommandLineAction
+    {
+        public override bool Terminating => true;
+
+        public override int Invoke(ParseResult parseResult)
+        {
+            ShowWorkloadsInfo(parseResult);
+            Reporter.Output.WriteLine(string.Empty);
+            return 0;
+        }
+    }
+
+    private class ShowWorkloadsVersionOption : SynchronousCommandLineAction
+    {
+        public override bool Terminating => true;
+
+        public override int Invoke(ParseResult parseResult)
+        {
+            Reporter.Output.WriteLine(GetWorkloadsVersion());
+            Reporter.Output.WriteLine(string.Empty);
+            return 0;
+        }
+    }
+}
diff --git a/src/Cli/dotnet/Commands/Workload/WorkloadCommandParser.cs b/src/Cli/dotnet/Commands/Workload/WorkloadCommandParser.cs
index 753413943036..b9f7815e2fc9 100644
--- a/src/Cli/dotnet/Commands/Workload/WorkloadCommandParser.cs
+++ b/src/Cli/dotnet/Commands/Workload/WorkloadCommandParser.cs
@@ -1,8 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
 using System.CommandLine.Invocation;
 using Microsoft.DotNet.Cli.Commands.Workload.Clean;
@@ -20,183 +18,23 @@
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.NET.Sdk.WorkloadManifestReader;
 using Microsoft.TemplateEngine.Cli.Commands;
-using IReporter = Microsoft.DotNet.Cli.Utils.IReporter;
 using Command = System.CommandLine.Command;
-using Microsoft.DotNet.Cli.CommandLine;
+using IReporter = Microsoft.DotNet.Cli.Utils.IReporter;
 
 namespace Microsoft.DotNet.Cli.Commands.Workload;
 
 internal static class WorkloadCommandParser
 {
-    public static readonly string DocsLink = "https://aka.ms/dotnet-workload";
-    public static readonly Option<bool> InfoOption = new("--info")
-    {
-        Description = CliCommandStrings.WorkloadInfoDescription,
-        Arity = ArgumentArity.Zero,
-        Action = new ShowWorkloadsInfoAction()
-    };
-
-    public static readonly Option<bool> VersionOption = new("--version")
-    {
-        Description = CliCommandStrings.WorkloadVersionDescription,
-        Arity = ArgumentArity.Zero,
-        Action = new ShowWorkloadsVersionOption()
-    };
+    private static readonly Command Command = ConfigureCommand(WorkloadCommandDefinition.Create());
 
     public static Command GetCommand()
     {
         return Command;
     }
 
-    private static readonly Command Command = ConstructCommand();
-
-    internal static string GetWorkloadsVersion(WorkloadInfoHelper workloadInfoHelper = null)
-    {
-        workloadInfoHelper ??= new WorkloadInfoHelper(false);
-
-        var versionInfo = workloadInfoHelper.ManifestProvider.GetWorkloadVersion();
-
-        // The explicit space here is intentional, as it's easy to miss in localization and crucial for parsing
-        return versionInfo.Version + (versionInfo.IsInstalled ? string.Empty : ' ' + CliCommandStrings.WorkloadVersionNotInstalledShort);
-    }
-
-    internal static void ShowWorkloadsInfo(ParseResult parseResult = null, WorkloadInfoHelper workloadInfoHelper = null, IReporter reporter = null, string dotnetDir = null, bool showVersion = true)
+    private static Command ConfigureCommand(Command command)
     {
-        workloadInfoHelper ??= new WorkloadInfoHelper(parseResult != null ? parseResult.HasOption(SharedOptions.InteractiveOption) : false);
-        reporter ??= Reporter.Output;
-        var versionInfo = workloadInfoHelper.ManifestProvider.GetWorkloadVersion();
-
-        void WriteUpdateModeAndAnyError(string indent = "")
-        {
-            var useWorkloadSets = InstallStateContents.FromPath(Path.Combine(WorkloadInstallType.GetInstallStateFolder(workloadInfoHelper._currentSdkFeatureBand, workloadInfoHelper.UserLocalPath), "default.json")).ShouldUseWorkloadSets();
-            var configurationMessage = useWorkloadSets
-                ? CliCommandStrings.WorkloadManifestInstallationConfigurationWorkloadSets
-                : CliCommandStrings.WorkloadManifestInstallationConfigurationLooseManifests;
-            reporter.WriteLine(indent + configurationMessage);
-
-            if (!versionInfo.IsInstalled)
-            {
-                reporter.WriteLine(indent + string.Format(CliCommandStrings.WorkloadSetFromGlobalJsonNotInstalled, versionInfo.Version, versionInfo.GlobalJsonPath));
-            }
-            else if (versionInfo.WorkloadSetsEnabledWithoutWorkloadSet)
-            {
-                reporter.WriteLine(indent + CliCommandStrings.ShouldInstallAWorkloadSet);
-            }
-        }
-
-        if (showVersion)
-        {
-            reporter.WriteLine($" Workload version: {GetWorkloadsVersion()}");
-
-            WriteUpdateModeAndAnyError(indent: " ");
-            reporter.WriteLine();
-        }
-
-        if (versionInfo.IsInstalled)
-        {
-            IEnumerable<WorkloadId> installedList = workloadInfoHelper.InstalledSdkWorkloadIds;
-            InstalledWorkloadsCollection installedWorkloads = workloadInfoHelper.AddInstalledVsWorkloads(installedList);
-            string dotnetPath = dotnetDir ?? Path.GetDirectoryName(Environment.ProcessPath);
-
-            if (installedWorkloads.Count == 0)
-            {
-                reporter.WriteLine(CliCommandStrings.NoWorkloadsInstalledInfoWarning);
-            }
-            else
-            {
-                var manifestInfoDict = workloadInfoHelper.WorkloadResolver.GetInstalledManifests().ToDictionary(info => info.Id, StringComparer.OrdinalIgnoreCase);
-
-                foreach (var workload in installedWorkloads.AsEnumerable())
-                {
-                    var workloadManifest = workloadInfoHelper.WorkloadResolver.GetManifestFromWorkload(new WorkloadId(workload.Key));
-                    var workloadFeatureBand = manifestInfoDict[workloadManifest.Id].ManifestFeatureBand;
-
-                    const int align = 10;
-                    const string separator = "   ";
-
-                    reporter.WriteLine($" [{workload.Key}]");
-
-                    reporter.Write($"{separator}{CliCommandStrings.WorkloadSourceColumn}:");
-                    reporter.WriteLine($" {workload.Value,align}");
-
-                    reporter.Write($"{separator}{CliCommandStrings.WorkloadManifestVersionColumn}:");
-                    reporter.WriteLine($"    {workloadManifest.Version + '/' + workloadFeatureBand,align}");
-
-                    reporter.Write($"{separator}{CliCommandStrings.WorkloadManifestPathColumn}:");
-                    reporter.WriteLine($"       {workloadManifest.ManifestPath,align}");
-
-                    reporter.Write($"{separator}{CliCommandStrings.WorkloadInstallTypeColumn}:");
-                    reporter.WriteLine($"       {WorkloadInstallType.GetWorkloadInstallType(new SdkFeatureBand(Product.Version), dotnetPath).ToString(),align}"
-                    );
-                    reporter.WriteLine("");
-                }
-            }
-        }
-
-        if (!showVersion)
-        {
-            WriteUpdateModeAndAnyError();
-        }
-    }
-
-    private static int ProcessArgs(ParseResult parseResult) => parseResult.HandleMissingCommand();
-
-    private static Command ConstructCommand()
-    {
-        Command command = new("workload", CliCommandStrings.WorkloadCommandDescription)
-        {
-            DocsLink = DocsLink
-        };
-
-        command.Subcommands.Add(WorkloadInstallCommandParser.GetCommand());
-        command.Subcommands.Add(WorkloadUpdateCommandParser.GetCommand());
-        command.Subcommands.Add(WorkloadListCommandParser.GetCommand());
-        command.Subcommands.Add(WorkloadSearchCommandParser.GetCommand());
-        command.Subcommands.Add(WorkloadUninstallCommandParser.GetCommand());
-        command.Subcommands.Add(WorkloadRepairCommandParser.GetCommand());
-        command.Subcommands.Add(WorkloadRestoreCommandParser.GetCommand());
-        command.Subcommands.Add(WorkloadCleanCommandParser.GetCommand());
-        command.Subcommands.Add(WorkloadElevateCommandParser.GetCommand());
-        command.Subcommands.Add(WorkloadConfigCommandParser.GetCommand());
-        command.Subcommands.Add(WorkloadHistoryCommandParser.GetCommand());
-
-        command.Options.Add(InfoOption);
-        command.Options.Add(VersionOption);
-
-        command.Validators.Add(commandResult =>
-        {
-            if (commandResult.HasOption(InfoOption) && commandResult.HasOption(VersionOption) && !commandResult.Children.Any(child => child is System.CommandLine.Parsing.CommandResult))
-            {
-                commandResult.AddError(CliStrings.RequiredCommandNotPassed);
-            }
-        });
-
-        command.SetAction(ProcessArgs);
-
+        command.SetAction(parseResult => parseResult.HandleMissingCommand());
         return command;
     }
-
-    private class ShowWorkloadsInfoAction : SynchronousCommandLineAction
-    {
-        public override bool Terminating => true;
-
-        public override int Invoke(ParseResult parseResult)
-        {
-            ShowWorkloadsInfo(parseResult);
-            Reporter.Output.WriteLine(string.Empty);
-            return 0;
-        }
-    }
-
-    private class ShowWorkloadsVersionOption : SynchronousCommandLineAction
-    {
-        public override bool Terminating => true;
-
-        public override int Invoke(ParseResult parseResult)
-        {
-            Reporter.Output.WriteLine(GetWorkloadsVersion());
-            Reporter.Output.WriteLine(string.Empty);
-            return 0;
-        }
-    }
 }
diff --git a/src/Cli/dotnet/CommonOptions.cs b/src/Cli/dotnet/CommonOptions.cs
index 4547a00a730e..4816872b8e59 100644
--- a/src/Cli/dotnet/CommonOptions.cs
+++ b/src/Cli/dotnet/CommonOptions.cs
@@ -353,7 +353,7 @@ public static Option<bool> InteractiveOption(bool acceptArgument = false) =>
     };
 
     public static readonly Option<IReadOnlyDictionary<string, string>> EnvOption = CreateEnvOption(CliStrings.CmdEnvironmentVariableDescription);
-
+    
     public static readonly Option<IReadOnlyDictionary<string, string>> TestEnvOption = CreateEnvOption(CliStrings.CmdTestEnvironmentVariableDescription);
 
     private static IReadOnlyDictionary<string, string> ParseEnvironmentVariables(ArgumentResult argumentResult)
diff --git a/src/Cli/dotnet/Extensions/CollectionExtensions.cs b/src/Cli/dotnet/Extensions/CollectionExtensions.cs
new file mode 100644
index 000000000000..475b812ffc24
--- /dev/null
+++ b/src/Cli/dotnet/Extensions/CollectionExtensions.cs
@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.DotNet.Cli;
+
+internal static class CollectionExtensions
+{
+    public static void AddRange<T>(this IList<T> list, IEnumerable<T> items)
+    {
+        foreach (T item in items)
+        {
+            list.Add(item);
+        }
+    }
+}
diff --git a/src/Cli/dotnet/Extensions/ParseResultExtensions.cs b/src/Cli/dotnet/Extensions/ParseResultExtensions.cs
index 6bcf5f84ff8c..eb87125030f0 100644
--- a/src/Cli/dotnet/Extensions/ParseResultExtensions.cs
+++ b/src/Cli/dotnet/Extensions/ParseResultExtensions.cs
@@ -177,12 +177,12 @@ public static bool BothArchAndOsOptionsSpecified(this ParseResult parseResult) =
 
     public static bool UsingRunCommandShorthandProjectOption(this ParseResult parseResult)
     {
-        if (parseResult.HasOption(RunCommandParser.PropertyOption) && parseResult.GetValue(RunCommandParser.PropertyOption)!.Any())
+        if (parseResult.HasOption(RunCommandDefinition.PropertyOption) && parseResult.GetValue(RunCommandDefinition.PropertyOption)!.Any())
         {
             var projVals = parseResult.GetRunCommandShorthandProjectValues();
             if (projVals?.Any() is true)
             {
-                if (projVals.Count() != 1 || parseResult.HasOption(RunCommandParser.ProjectOption))
+                if (projVals.Count() != 1 || parseResult.HasOption(RunCommandDefinition.ProjectOption))
                 {
                     throw new GracefulException(CliStrings.OnlyOneProjectAllowed);
                 }
diff --git a/src/Cli/dotnet/Parser.cs b/src/Cli/dotnet/Parser.cs
index 23dd3d6ebef3..9a44f4a9436d 100644
--- a/src/Cli/dotnet/Parser.cs
+++ b/src/Cli/dotnet/Parser.cs
@@ -369,12 +369,12 @@ public override void Write(HelpContext context)
             {
                 new VSTestForwardingApp(helpArgs).Execute();
             }
-            else if (command.Name.Equals(FormatCommandParser.GetCommand().Name))
+            else if (command.Name.Equals(FormatCommandDefinition.Name))
             {
-                var arguments = context.ParseResult.GetValue(FormatCommandParser.Arguments);
+                var arguments = context.ParseResult.GetValue(FormatCommandDefinition.Arguments);
                 new FormatForwardingApp([.. arguments, .. helpArgs]).Execute();
             }
-            else if (command.Name.Equals(FsiCommandParser.GetCommand().Name))
+            else if (command.Name.Equals(FsiCommandDefinition.Name))
             {
                 new FsiForwardingApp(helpArgs).Execute();
             }
@@ -386,17 +386,17 @@ public override void Write(HelpContext context)
                     block(context);
                 }
             }
-            else if (command.Name.Equals(FormatCommandParser.GetCommand().Name))
+            else if (command.Name.Equals(FormatCommandDefinition.Name))
             {
                 new FormatForwardingApp(helpArgs).Execute();
             }
-            else if (command.Name.Equals(FsiCommandParser.GetCommand().Name))
+            else if (command.Name.Equals(FsiCommandDefinition.Name))
             {
                 new FsiForwardingApp(helpArgs).Execute();
             }
             else
             {
-                if (command.Name.Equals(ListReferenceCommandParser.GetCommand().Name))
+                if (command.Name.Equals(ListReferenceCommandDefinition.Name))
                 {
                     Command listCommand = command.Parents.Single() as Command;
 
@@ -405,14 +405,14 @@ public override void Write(HelpContext context)
                         if (listCommand.Arguments[i].Name == CliStrings.SolutionOrProjectArgumentName)
                         {
                             // Name is immutable now, so we create a new Argument with the right name..
-                            listCommand.Arguments[i] = ListCommandParser.CreateSlnOrProjectArgument(CliStrings.ProjectArgumentName, CliStrings.ProjectArgumentDescription);
+                            listCommand.Arguments[i] = ListCommandDefinition.CreateSlnOrProjectArgument(CliStrings.ProjectArgumentName, CliStrings.ProjectArgumentDescription);
                         }
                     }
                 }
-                else if (command.Name.Equals(AddPackageCommandParser.GetCommand().Name) || command.Name.Equals(AddCommandParser.GetCommand().Name))
+                else if (command.Name.Equals(AddPackageCommandDefinition.Name) || command.Name.Equals(AddCommandDefinition.Name))
                 {
                     // Don't show package completions in help
-                    PackageAddCommandParser.CmdPackageArgument.CompletionSources.Clear();
+                    PackageAddCommandDefinition.CmdPackageArgument.CompletionSources.Clear();
                 }
                 else if (command.Name.Equals(WorkloadSearchCommandParser.GetCommand().Name))
                 {
diff --git a/src/Cli/dotnet/Telemetry/TelemetryFilter.cs b/src/Cli/dotnet/Telemetry/TelemetryFilter.cs
index 730daae1ed57..76c30928a112 100644
--- a/src/Cli/dotnet/Telemetry/TelemetryFilter.cs
+++ b/src/Cli/dotnet/Telemetry/TelemetryFilter.cs
@@ -110,21 +110,21 @@ public IEnumerable<ApplicationInsightsEntryFormat> Filter(object objectToFilter)
         new TopLevelCommandNameAndOptionToLog
         (
             topLevelCommandName: ["build", "publish"],
-            optionsToLog: [ BuildCommandParser.FrameworkOption, PublishCommandParser.FrameworkOption,
-                BuildCommandParser.RuntimeOption, PublishCommandParser.RuntimeOption, BuildCommandParser.ConfigurationOption,
-                PublishCommandParser.ConfigurationOption ]
+            optionsToLog: [ BuildCommandDefinition.FrameworkOption, PublishCommandDefinition.FrameworkOption,
+                BuildCommandDefinition.RuntimeOption, PublishCommandDefinition.RuntimeOption, BuildCommandDefinition.ConfigurationOption,
+                PublishCommandDefinition.ConfigurationOption ]
         ),
         new TopLevelCommandNameAndOptionToLog
         (
             topLevelCommandName: ["run", "clean", "test"],
-            optionsToLog: [ RunCommandParser.FrameworkOption, CleanCommandParser.FrameworkOption,
-                TestCommandDefinition.FrameworkOption, RunCommandParser.ConfigurationOption, CleanCommandParser.ConfigurationOption,
+            optionsToLog: [ RunCommandDefinition.FrameworkOption, CleanCommandDefinition.FrameworkOption,
+                TestCommandDefinition.FrameworkOption, RunCommandDefinition.ConfigurationOption, CleanCommandDefinition.ConfigurationOption,
                 TestCommandDefinition.ConfigurationOption ]
         ),
         new TopLevelCommandNameAndOptionToLog
         (
             topLevelCommandName: ["pack"],
-            optionsToLog: [PackCommandParser.ConfigurationOption]
+            optionsToLog: [PackCommandDefinition.ConfigurationOption]
         ),
         new TopLevelCommandNameAndOptionToLog
         (
@@ -135,7 +135,7 @@ TestCommandDefinition.ConfigurationOption ]
         new TopLevelCommandNameAndOptionToLog
         (
             topLevelCommandName: ["publish"],
-            optionsToLog: [PublishCommandParser.RuntimeOption]
+            optionsToLog: [PublishCommandDefinition.RuntimeOption]
         ),
         new AllowListToSendVerbSecondVerbFirstArgument(["workload", "tool", "new"]),
     ];
diff --git a/test/ArgumentForwarding.Tests/ArgumentForwardingTests.cs b/test/ArgumentForwarding.Tests/ArgumentForwardingTests.cs
index 52c6f65b2af6..8f7538e9c3a7 100644
--- a/test/ArgumentForwarding.Tests/ArgumentForwardingTests.cs
+++ b/test/ArgumentForwarding.Tests/ArgumentForwardingTests.cs
@@ -150,7 +150,7 @@ public void TestArgumentForwardingCmdFailsWithUnbalancedQuote(string testArgStri
         [Fact]
         public void ForwardAsWorks()
         {
-            var cmd = Microsoft.DotNet.Cli.Commands.Package.Add.PackageAddCommandParser.GetCommand();
+            var cmd = Microsoft.DotNet.Cli.Commands.Package.Add.PackageAddCommandDefinition.Create();
             var parseResult = cmd.Parse(["package", "add", "thing", "--prerelease"]);
             var forwardedValues = parseResult.OptionValuesToBeForwarded();
             forwardedValues.Should().Contain("--prerelease");
diff --git a/test/dotnet-new.IntegrationTests/DotnetClassTemplateTests.cs b/test/dotnet-new.IntegrationTests/DotnetClassTemplateTests.cs
index 1d1817c5f359..9b2d505d0eb9 100644
--- a/test/dotnet-new.IntegrationTests/DotnetClassTemplateTests.cs
+++ b/test/dotnet-new.IntegrationTests/DotnetClassTemplateTests.cs
@@ -3,7 +3,6 @@
 
 using Microsoft.Extensions.Logging;
 using Microsoft.TemplateEngine.Authoring.TemplateVerifier;
-using NuGet.Packaging;
 
 namespace Microsoft.DotNet.Cli.New.IntegrationTests
 {
diff --git a/test/dotnet.Tests/CommandTests/BuildServer/Shutdown/BuildServerShutdownParserTests.cs b/test/dotnet.Tests/CommandTests/BuildServer/Shutdown/BuildServerShutdownParserTests.cs
index 1f14f6072979..537c6388eaa9 100644
--- a/test/dotnet.Tests/CommandTests/BuildServer/Shutdown/BuildServerShutdownParserTests.cs
+++ b/test/dotnet.Tests/CommandTests/BuildServer/Shutdown/BuildServerShutdownParserTests.cs
@@ -20,9 +20,9 @@ public void GivenNoOptionsAllFlagsAreFalse()
         {
             var result = Parser.Parse(["dotnet", "build-server", "shutdown"]);
 
-            result.GetValue<bool>(BuildServerShutdownCommandParser.MSBuildOption).Should().Be(false);
-            result.GetValue<bool>(BuildServerShutdownCommandParser.VbcsOption).Should().Be(false);
-            result.GetValue<bool>(BuildServerShutdownCommandParser.RazorOption).Should().Be(false);
+            result.GetValue<bool>(BuildServerShutdownCommandDefinition.MSBuildOption).Should().Be(false);
+            result.GetValue<bool>(BuildServerShutdownCommandDefinition.VbcsOption).Should().Be(false);
+            result.GetValue<bool>(BuildServerShutdownCommandDefinition.RazorOption).Should().Be(false);
         }
 
         [Fact]
@@ -30,9 +30,9 @@ public void GivenMSBuildOptionIsItTrue()
         {
             var result = Parser.Parse(["dotnet", "build-server", "shutdown", "--msbuild"]);
 
-            result.GetValue<bool>(BuildServerShutdownCommandParser.MSBuildOption).Should().Be(true);
-            result.GetValue<bool>(BuildServerShutdownCommandParser.VbcsOption).Should().Be(false);
-            result.GetValue<bool>(BuildServerShutdownCommandParser.RazorOption).Should().Be(false);
+            result.GetValue<bool>(BuildServerShutdownCommandDefinition.MSBuildOption).Should().Be(true);
+            result.GetValue<bool>(BuildServerShutdownCommandDefinition.VbcsOption).Should().Be(false);
+            result.GetValue<bool>(BuildServerShutdownCommandDefinition.RazorOption).Should().Be(false);
         }
 
         [Fact]
@@ -40,9 +40,9 @@ public void GivenVBCSCompilerOptionIsItTrue()
         {
             var result = Parser.Parse(["dotnet", "build-server", "shutdown", "--vbcscompiler"]);
 
-            result.GetValue<bool>(BuildServerShutdownCommandParser.MSBuildOption).Should().Be(false);
-            result.GetValue<bool>(BuildServerShutdownCommandParser.VbcsOption).Should().Be(true);
-            result.GetValue<bool>(BuildServerShutdownCommandParser.RazorOption).Should().Be(false);
+            result.GetValue<bool>(BuildServerShutdownCommandDefinition.MSBuildOption).Should().Be(false);
+            result.GetValue<bool>(BuildServerShutdownCommandDefinition.VbcsOption).Should().Be(true);
+            result.GetValue<bool>(BuildServerShutdownCommandDefinition.RazorOption).Should().Be(false);
         }
 
         [Fact]
@@ -50,9 +50,9 @@ public void GivenRazorOptionIsItTrue()
         {
             var result = Parser.Parse(["dotnet", "build-server", "shutdown", "--razor"]);
 
-            result.GetValue<bool>(BuildServerShutdownCommandParser.MSBuildOption).Should().Be(false);
-            result.GetValue<bool>(BuildServerShutdownCommandParser.VbcsOption).Should().Be(false);
-            result.GetValue<bool>(BuildServerShutdownCommandParser.RazorOption).Should().Be(true);
+            result.GetValue<bool>(BuildServerShutdownCommandDefinition.MSBuildOption).Should().Be(false);
+            result.GetValue<bool>(BuildServerShutdownCommandDefinition.VbcsOption).Should().Be(false);
+            result.GetValue<bool>(BuildServerShutdownCommandDefinition.RazorOption).Should().Be(true);
         }
 
         [Fact]
@@ -60,9 +60,9 @@ public void GivenMultipleOptionsThoseAreTrue()
         {
             var result = Parser.Parse(["dotnet", "build-server", "shutdown", "--razor", "--msbuild"]);
 
-            result.GetValue<bool>(BuildServerShutdownCommandParser.MSBuildOption).Should().Be(true);
-            result.GetValue<bool>(BuildServerShutdownCommandParser.VbcsOption).Should().Be(false);
-            result.GetValue<bool>(BuildServerShutdownCommandParser.RazorOption).Should().Be(true);
+            result.GetValue<bool>(BuildServerShutdownCommandDefinition.MSBuildOption).Should().Be(true);
+            result.GetValue<bool>(BuildServerShutdownCommandDefinition.VbcsOption).Should().Be(false);
+            result.GetValue<bool>(BuildServerShutdownCommandDefinition.RazorOption).Should().Be(true);
         }
     }
 }
diff --git a/test/dotnet.Tests/CommandTests/MSBuild/GivenDotnetRunInvocation.cs b/test/dotnet.Tests/CommandTests/MSBuild/GivenDotnetRunInvocation.cs
index 0bd410308b59..8ddf0e1d9ea5 100644
--- a/test/dotnet.Tests/CommandTests/MSBuild/GivenDotnetRunInvocation.cs
+++ b/test/dotnet.Tests/CommandTests/MSBuild/GivenDotnetRunInvocation.cs
@@ -43,7 +43,7 @@ public void MsbuildInvocationIsCorrect(string[] args, string[] expectedArgs)
                     var command = RunCommand.FromArgs(args);
                     command.MSBuildArgs
                         .Should()
-                        .BeEquivalentTo(MSBuildArgs.AnalyzeMSBuildArguments([.. ConstantRestoreArgs, .. expectedArgs, NuGetDisabledProperty ], CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.MSBuildTargetOption(), RunCommandParser.VerbosityOption, CommonOptions.NoLogoOption()));
+                        .BeEquivalentTo(MSBuildArgs.AnalyzeMSBuildArguments([.. ConstantRestoreArgs, .. expectedArgs, NuGetDisabledProperty ], CommonOptions.PropertiesOption, CommonOptions.RestorePropertiesOption, CommonOptions.MSBuildTargetOption(), RunCommandDefinition.VerbosityOption, CommonOptions.NoLogoOption()));
                 });
             }
             finally
diff --git a/test/dotnet.Tests/CommandTests/Package/List/ListPackageParserTests.cs b/test/dotnet.Tests/CommandTests/Package/List/ListPackageParserTests.cs
index dea7d9c699cd..2f657fe06f66 100644
--- a/test/dotnet.Tests/CommandTests/Package/List/ListPackageParserTests.cs
+++ b/test/dotnet.Tests/CommandTests/Package/List/ListPackageParserTests.cs
@@ -14,7 +14,7 @@ public void ListPackageCanForwardInteractiveFlag()
         {
             var result = Parser.Parse(["dotnet", "list", "package", "--interactive"]);
 
-            result.OptionValuesToBeForwarded(ListPackageCommandParser.GetCommand()).Should().ContainSingle("--interactive");
+            result.OptionValuesToBeForwarded(ListPackageCommandDefinition.Create()).Should().ContainSingle("--interactive");
             result.Errors.Should().BeEmpty();
         }
 
@@ -49,7 +49,7 @@ public void ListPackageCanForwardVerbosityFlag(string inputOption, string value)
             var result = Parser.Parse(["dotnet", "list", "package", inputOption, value]);
 
             result
-                .OptionValuesToBeForwarded(ListPackageCommandParser.GetCommand())
+                .OptionValuesToBeForwarded(ListPackageCommandDefinition.Create())
                 .Should()
                 .Contain($"--verbosity:{value.ToLowerInvariant()}");
             result.Errors.Should().BeEmpty();
@@ -61,7 +61,7 @@ public void ListPackageDoesNotForwardVerbosityByDefault()
             var result = Parser.Parse(["dotnet", "list", "package"]);
 
             result
-                .OptionValuesToBeForwarded(ListPackageCommandParser.GetCommand())
+                .OptionValuesToBeForwarded(ListPackageCommandDefinition.Create())
                 .Should()
                 .NotContain(i => i.Contains("--verbosity", StringComparison.OrdinalIgnoreCase))
                 .And.NotContain(i => i.Contains("-v", StringComparison.OrdinalIgnoreCase));
diff --git a/test/dotnet.Tests/CommandTests/Reference/Add/AddReferenceParserTests.cs b/test/dotnet.Tests/CommandTests/Reference/Add/AddReferenceParserTests.cs
index b4119e5ffbaa..a516b1074185 100644
--- a/test/dotnet.Tests/CommandTests/Reference/Add/AddReferenceParserTests.cs
+++ b/test/dotnet.Tests/CommandTests/Reference/Add/AddReferenceParserTests.cs
@@ -23,7 +23,7 @@ public void AddReferenceHasDefaultArgumentSetToCurrentDirectory()
         {
             var result = Parser.Parse(["dotnet", "add", "reference", "my.csproj"]);
 
-            result.GetValue<string>(PackageCommandParser.ProjectOrFileArgument)
+            result.GetValue<string>(PackageCommandDefinition.ProjectOrFileArgument)
                 .Should()
                 .BeEquivalentTo(
                     PathUtility.EnsureTrailingSlash(Directory.GetCurrentDirectory()));
@@ -34,7 +34,7 @@ public void AddReferenceHasInteractiveFlag()
         {
             var result = Parser.Parse(["dotnet", "add", "reference", "my.csproj", "--interactive"]);
 
-            result.GetValue<bool>(ReferenceAddCommandParser.InteractiveOption)
+            result.GetValue<bool>(ReferenceAddCommandDefinition.InteractiveOption)
                 .Should().BeTrue();
         }
 
@@ -47,7 +47,7 @@ public void AddReferenceWithoutArgumentResultsInAnError()
 
             var argument = (result.Errors.SingleOrDefault()?.SymbolResult as ArgumentResult)?.Argument;
 
-            argument.Should().Be(ReferenceAddCommandParser.ProjectPathArgument);
+            argument.Should().Be(ReferenceAddCommandDefinition.ProjectPathArgument);
         }
     }
 }
diff --git a/test/dotnet.Tests/CommandTests/Restore/RestoreParserTests.cs b/test/dotnet.Tests/CommandTests/Restore/RestoreParserTests.cs
index aedcae11a0c3..ae8c54776d9f 100644
--- a/test/dotnet.Tests/CommandTests/Restore/RestoreParserTests.cs
+++ b/test/dotnet.Tests/CommandTests/Restore/RestoreParserTests.cs
@@ -21,7 +21,7 @@ public void RestoreCapturesArgumentsToForwardToMSBuildWhenTargetIsSpecified()
         {
             var result = Parser.Parse(["dotnet", "restore", @".\some.csproj", "--packages", @"c:\.nuget\packages", "/p:SkipInvalidConfigurations=true"]);
 
-            result.GetValue(RestoreCommandParser.SlnOrProjectOrFileArgument).Should().BeEquivalentTo(@".\some.csproj");
+            result.GetValue(RestoreCommandDefinition.SlnOrProjectOrFileArgument).Should().BeEquivalentTo(@".\some.csproj");
             result.OptionValuesToBeForwarded(RestoreCommandParser.GetCommand()).Should().Contain(@"--property:SkipInvalidConfigurations=true");
         }
 
@@ -39,9 +39,9 @@ public void RestoreDistinguishesRepeatSourceArgsFromCommandArgs()
             var restore =
                 Parser.Parse(["dotnet", "restore", "--no-cache", "--packages", @"D:\OSS\corefx\packages", "--source", "https://dotnet.myget.org/F/dotnet-buildtools/api/v3/index.json", "--source", "https://dotnet.myget.org/F/dotnet-core/api/v3/index.json", "--source", "https://api.nuget.org/v3/index.json", @"D:\OSS\corefx\external\runtime\runtime.depproj"]);
 
-            restore.GetValue(RestoreCommandParser.SlnOrProjectOrFileArgument).Should().BeEquivalentTo(@"D:\OSS\corefx\external\runtime\runtime.depproj");
+            restore.GetValue(RestoreCommandDefinition.SlnOrProjectOrFileArgument).Should().BeEquivalentTo(@"D:\OSS\corefx\external\runtime\runtime.depproj");
 
-            restore.GetValue(RestoreCommandParser.SourceOption)
+            restore.GetValue(RestoreCommandDefinition.SourceOption)
                 .Should()
                 .BeEquivalentTo(
                     "https://dotnet.myget.org/F/dotnet-buildtools/api/v3/index.json",
diff --git a/test/dotnet.Tests/CommandTests/Run/RunFileTests.cs b/test/dotnet.Tests/CommandTests/Run/RunFileTests.cs
index c367320353ba..b9398c02338f 100644
--- a/test/dotnet.Tests/CommandTests/Run/RunFileTests.cs
+++ b/test/dotnet.Tests/CommandTests/Run/RunFileTests.cs
@@ -172,7 +172,7 @@ public void FilePath(string? path, bool differentCasing)
                 .And.HaveStdErrContaining(string.Format(
                     CliCommandStrings.RunCommandExceptionNoProjects,
                     testInstance.Path,
-                    RunCommandParser.ProjectOption.Name));
+                    RunCommandDefinition.ProjectOption.Name));
         }
     }
 
@@ -290,7 +290,7 @@ public void FilePath_DifferentCasing()
                 .And.HaveStdErrContaining(string.Format(
                     CliCommandStrings.RunCommandExceptionNoProjects,
                     testInstance.Path,
-                    RunCommandParser.ProjectOption.Name));
+                    RunCommandDefinition.ProjectOption.Name));
         }
     }
 
@@ -476,7 +476,7 @@ public void ReadFromStdin_NoBuild()
         new DotnetCommand(Log, "run", "-", "--no-build")
             .Execute()
             .Should().Fail()
-            .And.HaveStdErrContaining(string.Format(CliCommandStrings.InvalidOptionForStdin, RunCommandParser.NoBuildOption.Name));
+            .And.HaveStdErrContaining(string.Format(CliCommandStrings.InvalidOptionForStdin, RunCommandDefinition.NoBuildOption.Name));
     }
 
     [Fact]
@@ -485,7 +485,7 @@ public void ReadFromStdin_LaunchProfile()
         new DotnetCommand(Log, "run", "-", "--launch-profile=test")
             .Execute()
             .Should().Fail()
-            .And.HaveStdErrContaining(string.Format(CliCommandStrings.InvalidOptionForStdin, RunCommandParser.LaunchProfileOption.Name));
+            .And.HaveStdErrContaining(string.Format(CliCommandStrings.InvalidOptionForStdin, RunCommandDefinition.LaunchProfileOption.Name));
     }
 
     /// <summary>
@@ -501,7 +501,7 @@ public void ReadFromStdin_AfterDoubleDash()
             .WithStandardInput("""Console.WriteLine("stdin code");""")
             .Execute()
             .Should().Fail()
-            .And.HaveStdErrContaining(string.Format(CliCommandStrings.RunCommandExceptionNoProjects, testInstance.Path, RunCommandParser.ProjectOption.Name));
+            .And.HaveStdErrContaining(string.Format(CliCommandStrings.RunCommandExceptionNoProjects, testInstance.Path, RunCommandDefinition.ProjectOption.Name));
     }
 
     /// <summary>
@@ -526,7 +526,7 @@ public void FolderPath(string? path)
             .And.HaveStdErrContaining(string.Format(
                 CliCommandStrings.RunCommandExceptionNoProjects,
                 testInstance.Path,
-                RunCommandParser.ProjectOption.Name));
+                RunCommandDefinition.ProjectOption.Name));
     }
 
     /// <summary>
@@ -545,7 +545,7 @@ public void ProjectPath_DoesNotExist()
             .And.HaveStdErrContaining(string.Format(
                 CliCommandStrings.RunCommandExceptionNoProjects,
                 testInstance.Path,
-                RunCommandParser.ProjectOption.Name));
+                RunCommandDefinition.ProjectOption.Name));
     }
 
     /// <summary>
@@ -648,7 +648,7 @@ public void NonCsFileExtensionWithNoShebang(string fileName)
             .And.HaveStdErrContaining(string.Format(
                 CliCommandStrings.RunCommandExceptionNoProjects,
                 testInstance.Path,
-                RunCommandParser.ProjectOption.Name));
+                RunCommandDefinition.ProjectOption.Name));
     }
 
     [Fact]
@@ -686,7 +686,7 @@ public void NoCode()
             .And.HaveStdErrContaining(string.Format(
                 CliCommandStrings.RunCommandExceptionNoProjects,
                 testInstance.Path,
-                RunCommandParser.ProjectOption.Name));
+                RunCommandDefinition.ProjectOption.Name));
     }
 
     /// <summary>
@@ -721,7 +721,7 @@ public void ClassLibrary_EntryPointFileDoesNotExist()
             .And.HaveStdErrContaining(string.Format(
                 CliCommandStrings.RunCommandExceptionNoProjects,
                 testInstance.Path,
-                RunCommandParser.ProjectOption.Name));
+                RunCommandDefinition.ProjectOption.Name));
     }
 
     /// <summary>
@@ -845,7 +845,7 @@ public void RunNestedProjectFile()
             .And.HaveStdErrContaining(string.Format(
                 CliCommandStrings.RunCommandExceptionNoProjects,
                 workDir,
-                RunCommandParser.ProjectOption.Name));
+                RunCommandDefinition.ProjectOption.Name));
     }
 
     /// <summary>
@@ -1112,7 +1112,7 @@ public void Arguments_Unrecognized()
             .And.HaveStdErrContaining(string.Format(
                 CliCommandStrings.RunCommandExceptionNoProjects,
                 testInstance.Path,
-                RunCommandParser.ProjectOption.Name));
+                RunCommandDefinition.ProjectOption.Name));
     }
 
     /// <summary>
@@ -3282,7 +3282,7 @@ public void UpToDate_InvalidOptions()
             .WithWorkingDirectory(testInstance.Path)
             .Execute()
             .Should().Fail()
-            .And.HaveStdErrContaining(string.Format(CliCommandStrings.CannotCombineOptions, RunCommandParser.NoCacheOption.Name, RunCommandParser.NoBuildOption.Name));
+            .And.HaveStdErrContaining(string.Format(CliCommandStrings.CannotCombineOptions, RunCommandDefinition.NoCacheOption.Name, RunCommandDefinition.NoBuildOption.Name));
     }
 
     /// <summary>
diff --git a/test/dotnet.Tests/CommandTests/Workload/Install/GivenDotnetWorkloadInstall.cs b/test/dotnet.Tests/CommandTests/Workload/Install/GivenDotnetWorkloadInstall.cs
index 316337d5712a..8c5a232827b1 100644
--- a/test/dotnet.Tests/CommandTests/Workload/Install/GivenDotnetWorkloadInstall.cs
+++ b/test/dotnet.Tests/CommandTests/Workload/Install/GivenDotnetWorkloadInstall.cs
@@ -183,7 +183,7 @@ public void GivenNoWorkloadsInstalledInfoOptionRemarksOnThat()
             var parseResult = Parser.Parse(new string[] { "dotnet", "workload", "install", "xamarin-android" });
 
             WorkloadInfoHelper workloadInfoHelper = new WorkloadInfoHelper(isInteractive: false, workloadResolver: workloadResolver);
-            WorkloadCommandParser.ShowWorkloadsInfo(parseResult, workloadInfoHelper: workloadInfoHelper, reporter: _reporter);
+            WorkloadCommandDefinition.ShowWorkloadsInfo(parseResult, workloadInfoHelper: workloadInfoHelper, reporter: _reporter);
             _reporter.Lines.Should().Contain("There are no installed workloads to display.");
         }
 
diff --git a/test/dotnet.Tests/CommandTests/Workload/Update/GivenDotnetWorkloadUpdate.cs b/test/dotnet.Tests/CommandTests/Workload/Update/GivenDotnetWorkloadUpdate.cs
index 3f0a820e801d..f2d30f3dc299 100644
--- a/test/dotnet.Tests/CommandTests/Workload/Update/GivenDotnetWorkloadUpdate.cs
+++ b/test/dotnet.Tests/CommandTests/Workload/Update/GivenDotnetWorkloadUpdate.cs
@@ -41,7 +41,7 @@ public void GivenWorkloadUpdateFromHistory()
             string workloadHistoryRecord = @"{
               ""TimeStarted"": ""2023-11-13T13:25:49.8011987-08:00"",
               ""TimeCompleted"": ""2023-11-13T13:25:52.8522942-08:00"",
-              ""CommandName"": ""update"",
+              ""Name"": ""update"",
               ""WorkloadArguments"": [],
               ""RollbackFileContents"": null,
               ""CommandLineArgs"": [],