diff --git a/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt b/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt
index 1dc2f6a0b0..b43629d19f 100644
--- a/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt
+++ b/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt
@@ -46,20 +46,15 @@ System.CommandLine
     public static Argument<T> AcceptExistingOnly<T>(this Argument<T> argument)
   public class Command : IdentifierSymbol, System.Collections.Generic.IEnumerable<Symbol>, System.Collections.IEnumerable
     .ctor(System.String name, System.String description = null)
-    public System.Collections.Generic.IReadOnlyList<Argument> Arguments { get; }
+    public System.Collections.Generic.IList<Argument> Arguments { get; }
     public System.Collections.Generic.IEnumerable<Symbol> Children { get; }
     public ICommandHandler Handler { get; set; }
-    public System.Collections.Generic.IReadOnlyList<Option> Options { get; }
-    public System.Collections.Generic.IReadOnlyList<Command> Subcommands { get; }
+    public System.Collections.Generic.IList<Option> Options { get; }
+    public System.Collections.Generic.IList<Command> Subcommands { get; }
     public System.Boolean TreatUnmatchedTokensAsErrors { get; set; }
     public System.Collections.Generic.List<System.Action<System.CommandLine.Parsing.CommandResult>> Validators { get; }
-    public System.Void Add(Option option)
-    public System.Void Add(Argument argument)
-    public System.Void Add(Command command)
-    public System.Void AddArgument(Argument argument)
-    public System.Void AddCommand(Command command)
+    public System.Void Add(Symbol symbol)
     public System.Void AddGlobalOption(Option option)
-    public System.Void AddOption(Option option)
     public System.Collections.Generic.IEnumerable<System.CommandLine.Completions.CompletionItem> GetCompletions(System.CommandLine.Completions.CompletionContext context)
     public System.Collections.Generic.IEnumerator<Symbol> GetEnumerator()
   public static class CommandExtensions
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_CustomScenarios.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_CustomScenarios.cs
index 74d9215dbd..4fa64d7cea 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_CustomScenarios.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_CustomScenarios.cs
@@ -21,8 +21,8 @@ public void SetupOneOptWithNestedCommand()
             var rootCommand = new Command("root_command");
             var nestedCommand = new Command("nested_command");
             var option = new Option<int>("-opt1", () => 123);
-            nestedCommand.AddOption(option);
-            rootCommand.AddCommand(nestedCommand);
+            nestedCommand.Options.Add(option);
+            rootCommand.Subcommands.Add(nestedCommand);
 
             _testParser = new Parser(rootCommand);
             _testSymbolsAsString = "root_command nested_command -opt1 321";
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_NestedCommands.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_NestedCommands.cs
index 5f495c264d..e530aa8107 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_NestedCommands.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Parser_NestedCommands.cs
@@ -40,7 +40,7 @@ private void GenerateTestNestedCommands(Command parent, int depth, int countPerL
             {
                 string cmdName = $"{parent.Name}_{depth}.{i}";
                 Command cmd = new(cmdName);
-                parent.AddCommand(cmd);
+                parent.Subcommands.Add(cmd);
                 GenerateTestNestedCommands(cmd, depth - 1, countPerLevel);
             }
         }
diff --git a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Suggestions.cs b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Suggestions.cs
index cd84312277..d51c247476 100644
--- a/src/System.CommandLine.Benchmarks/CommandLine/Perf_Suggestions.cs
+++ b/src/System.CommandLine.Benchmarks/CommandLine/Perf_Suggestions.cs
@@ -54,7 +54,7 @@ public void Setup_FromParseResult()
 
             foreach (var option in GenerateOptionsArray(TestSuggestionsCount))
             {
-                testCommand.AddOption(option);
+                testCommand.Options.Add(option);
             }
 
             _testParseResult = testCommand.Parse("--wrong");
diff --git a/src/System.CommandLine.DragonFruit/CommandLine.cs b/src/System.CommandLine.DragonFruit/CommandLine.cs
index 582ace0701..40f8a55fc9 100644
--- a/src/System.CommandLine.DragonFruit/CommandLine.cs
+++ b/src/System.CommandLine.DragonFruit/CommandLine.cs
@@ -160,12 +160,12 @@ public static void ConfigureFromMethod(
 
             foreach (var option in method.BuildOptions())
             {
-                command.AddOption(option);
+                command.Options.Add(option);
             }
 
             if (method.GetParameters().FirstOrDefault(p => _argumentParameterNames.Contains(p.Name)) is { } argsParam)
             {
-                command.AddArgument(ArgumentBuilder.CreateArgument(argsParam));
+                command.Arguments.Add(ArgumentBuilder.CreateArgument(argsParam));
             }
 
             command.Handler = CommandHandler.Create(method, target);
diff --git a/src/System.CommandLine.Generator.Tests/GeneratedCommandHandlerTests.cs b/src/System.CommandLine.Generator.Tests/GeneratedCommandHandlerTests.cs
index 187e605e79..1ba6b23c9e 100644
--- a/src/System.CommandLine.Generator.Tests/GeneratedCommandHandlerTests.cs
+++ b/src/System.CommandLine.Generator.Tests/GeneratedCommandHandlerTests.cs
@@ -95,9 +95,9 @@ void Execute(Character character, IConsole console)
 
             var command = new Command("command");
             var nameOption = new Option<string>("--name");
-            command.AddOption(nameOption);
+            command.Options.Add(nameOption);
             var ageOption = new Option<int>("--age");
-            command.AddOption(ageOption);
+            command.Options.Add(ageOption);
 
             command.SetHandler<Action<Character, IConsole>>(Execute, nameOption, ageOption);
 
@@ -118,9 +118,9 @@ int Execute(int first, int second)
 
             var command = new Command("add");
             var firstArgument = new Argument<int>("first");
-            command.AddArgument(firstArgument);
+            command.Arguments.Add(firstArgument);
             var secondArgument = new Argument<int>("second");
-            command.AddArgument(secondArgument);
+            command.Arguments.Add(secondArgument);
 
             command.SetHandler<Func<int, int, int>>(Execute, firstArgument, secondArgument);
 
@@ -243,12 +243,12 @@ void Execute2(string value)
 
             var command1 = new Command("first");
             var argument1 = new Argument<string>("first-value");
-            command1.AddArgument(argument1);
+            command1.Arguments.Add(argument1);
             command1.SetHandler<Action<string>>(Execute1, argument1);
 
             var command2 = new Command("second");
             var argument2 = new Argument<string>("second-value");
-            command2.AddArgument(argument2);
+            command2.Arguments.Add(argument2);
             command2.SetHandler<Action<string>>(Execute2, argument2);
 
             await command1.InvokeAsync("first v1", _console);
diff --git a/src/System.CommandLine.Hosting.Tests/HostingHandlerTest.cs b/src/System.CommandLine.Hosting.Tests/HostingHandlerTest.cs
index a087097f3c..c874ff5fb7 100644
--- a/src/System.CommandLine.Hosting.Tests/HostingHandlerTest.cs
+++ b/src/System.CommandLine.Hosting.Tests/HostingHandlerTest.cs
@@ -59,8 +59,8 @@ public static async Task Can_have_diferent_handlers_based_on_command()
         {
             var root = new RootCommand();
 
-            root.AddCommand(new MyCommand());
-            root.AddCommand(new MyOtherCommand());
+            root.Subcommands.Add(new MyCommand());
+            root.Subcommands.Add(new MyOtherCommand());
             var parser = new CommandLineBuilder(root)
                 .UseHost(host =>
                 {
@@ -90,7 +90,7 @@ public static async Task Can_bind_to_arguments_via_injection()
         {
             var service = new MyService();
             var cmd = new RootCommand();
-            cmd.AddCommand(new MyOtherCommand());
+            cmd.Subcommands.Add(new MyOtherCommand());
             var parser = new CommandLineBuilder(cmd)
                 .UseHost(host =>
                 {
@@ -113,8 +113,8 @@ public static async Task Invokes_DerivedClass()
             var service = new MyService();
 
             var cmd = new RootCommand();
-            cmd.AddCommand(new MyCommand());
-            cmd.AddCommand(new MyOtherCommand());
+            cmd.Subcommands.Add(new MyCommand());
+            cmd.Subcommands.Add(new MyOtherCommand());
             var parser = new CommandLineBuilder(cmd)
                          .UseHost((builder) => {
                              builder.ConfigureServices(services =>
@@ -155,7 +155,7 @@ public class MyCommand : Command
         {
             public MyCommand() : base(name: "mycommand")
             {
-                AddOption(new Option<int>("--int-option")); // or nameof(Handler.IntOption).ToKebabCase() if you don't like the string literal
+                Options.Add(new Option<int>("--int-option")); // or nameof(Handler.IntOption).ToKebabCase() if you don't like the string literal
             }
 
             public class MyHandler : ICommandHandler
@@ -204,8 +204,8 @@ public class MyOtherCommand : Command
         {
             public MyOtherCommand() : base(name: "myothercommand")
             {
-                AddOption(new Option<int>("--int-option")); // or nameof(Handler.IntOption).ToKebabCase() if you don't like the string literal
-                AddArgument(new Argument<string>("One"));
+                Options.Add(new Option<int>("--int-option")); // or nameof(Handler.IntOption).ToKebabCase() if you don't like the string literal
+                Arguments.Add(new Argument<string>("One"));
             }
 
             public class MyHandler : ICommandHandler
diff --git a/src/System.CommandLine.Hosting.Tests/HostingTests.cs b/src/System.CommandLine.Hosting.Tests/HostingTests.cs
index 12e06c8007..83b6210606 100644
--- a/src/System.CommandLine.Hosting.Tests/HostingTests.cs
+++ b/src/System.CommandLine.Hosting.Tests/HostingTests.cs
@@ -202,7 +202,7 @@ public static void UseHost_binds_parsed_arguments_to_options()
             MyOptions options = null;
 
             var rootCmd = new RootCommand();
-            rootCmd.AddOption(new Option<int>($"-{nameof(MyOptions.MyArgument)}"));
+            rootCmd.Options.Add(new Option<int>($"-{nameof(MyOptions.MyArgument)}"));
             rootCmd.Handler = CommandHandler.Create((IHost host) =>
             {
                 options = host.Services
diff --git a/src/System.CommandLine.NamingConventionBinder.Tests/ModelBinderTests.cs b/src/System.CommandLine.NamingConventionBinder.Tests/ModelBinderTests.cs
index a93a3ca6d8..950122041a 100644
--- a/src/System.CommandLine.NamingConventionBinder.Tests/ModelBinderTests.cs
+++ b/src/System.CommandLine.NamingConventionBinder.Tests/ModelBinderTests.cs
@@ -101,7 +101,7 @@ public void Explicitly_configured_default_values_can_be_bound_by_name_to_constru
         var option = new Option<string>("--string-option", () => "the default");
 
         var command = new Command("the-command");
-        command.AddOption(option);
+        command.Options.Add(option);
         var binder = new ModelBinder(typeof(ClassWithMultiLetterCtorParameters));
 
         var parser = new Parser(command);
@@ -176,7 +176,7 @@ public void Types_having_constructors_accepting_a_single_string_are_bound_using_
         var option = new Option<DirectoryInfo>("--value");
 
         var command = new Command("the-command");
-        command.AddOption(option);
+        command.Options.Add(option);
         var binder = new ModelBinder(typeof(ClassWithCtorParameter<DirectoryInfo>));
         var bindingContext = new InvocationContext(command.Parse($"--value \"{tempPath}\"")).BindingContext;
 
@@ -191,7 +191,7 @@ public void Explicitly_configured_default_values_can_be_bound_by_name_to_propert
         var option = new Option<string>("--value", () => "the default");
 
         var command = new Command("the-command");
-        command.AddOption(option);
+        command.Options.Add(option);
         var binder = new ModelBinder(typeof(ClassWithSetter<string>));
 
         var parser = new Parser(command);
@@ -421,7 +421,7 @@ public void PropertyInfo_can_be_bound_to_argument()
     {
         var command = new Command("the-command");
         var argument = new Argument<int> { Arity = ArgumentArity.ExactlyOne };
-        command.AddArgument(argument);
+        command.Arguments.Add(argument);
 
         var type = typeof(ClassWithMultiLetterSetters);
         var binder = new ModelBinder(type);
@@ -441,7 +441,7 @@ public void PropertyExpression_can_be_bound_to_option()
     {
         var command = new Command("the-command");
         var option = new Option<int>("--fred");
-        command.AddOption(option);
+        command.Options.Add(option);
 
         var binder = new ModelBinder<ClassWithMultiLetterSetters>();
 
@@ -461,7 +461,7 @@ public void PropertyExpression_can_be_bound_to_argument()
     {
         var command = new Command("the-command");
         var argument = new Argument<int> { Arity = ArgumentArity.ExactlyOne };
-        command.AddArgument(argument);
+        command.Arguments.Add(argument);
 
         var binder = new ModelBinder<ClassWithMultiLetterSetters>();
 
@@ -493,7 +493,7 @@ public void Option_argument_is_bound_to_longest_constructor()
     public void Command_argument_is_bound_to_longest_constructor()
     {
         var rootCommand = new RootCommand();
-        rootCommand.AddArgument(new Argument<int> { Name = nameof(ClassWithMultipleCtor.IntProperty) });
+        rootCommand.Arguments.Add(new Argument<int> { Name = nameof(ClassWithMultipleCtor.IntProperty) });
         var parser = new Parser(rootCommand);
 
         var bindingContext = new InvocationContext(parser.Parse("42")).BindingContext;
diff --git a/src/System.CommandLine.NamingConventionBinder.Tests/ParameterBindingTests.cs b/src/System.CommandLine.NamingConventionBinder.Tests/ParameterBindingTests.cs
index a92a0a84bd..ae4e8bca79 100644
--- a/src/System.CommandLine.NamingConventionBinder.Tests/ParameterBindingTests.cs
+++ b/src/System.CommandLine.NamingConventionBinder.Tests/ParameterBindingTests.cs
@@ -30,8 +30,8 @@ void Execute(string name, int age)
         }
 
         var command = new Command("command");
-        command.AddOption(new Option<string>("--name"));
-        command.AddOption(new Option<int>("--age"));
+        command.Options.Add(new Option<string>("--name"));
+        command.Options.Add(new Option<int>("--age"));
         command.Handler = CommandHandler.Create<string, int>(Execute);
 
         await command.InvokeAsync("command --age 425 --name Gandalf", _console);
@@ -74,8 +74,8 @@ void Execute(string name, int AGE)
         }
 
         var command = new Command("command");
-        command.AddOption(new Option<string>("--NAME"));
-        command.AddOption(new Option<int>("--age"));
+        command.Options.Add(new Option<string>("--NAME"));
+        command.Options.Add(new Option<int>("--age"));
         command.Handler = CommandHandler.Create<string, int>(Execute);
 
         await command.InvokeAsync("command --age 425 --NAME Gandalf", _console);
@@ -350,8 +350,8 @@ void Execute(string name, int age)
         }
 
         var command = new Command("command");
-        command.AddArgument(new Argument<int>("age"));
-        command.AddArgument(new Argument<string>("name"));
+        command.Arguments.Add(new Argument<int>("age"));
+        command.Arguments.Add(new Argument<string>("name"));
         command.Handler = CommandHandler.Create<string, int>(Execute);
 
         await command.InvokeAsync("command 425 Gandalf", _console);
@@ -394,8 +394,8 @@ void Execute(string name, int AGE)
         }
 
         var command = new Command("command");
-        command.AddArgument(new Argument<int>("AGE"));
-        command.AddArgument(new Argument<string>("Name"));
+        command.Arguments.Add(new Argument<int>("AGE"));
+        command.Arguments.Add(new Argument<string>("Name"));
         command.Handler = CommandHandler.Create<string, int>(Execute);
 
         await command.InvokeAsync("command 425 Gandalf", _console);
@@ -417,8 +417,8 @@ void Execute(string fullnameOrNickname, int age)
         }
 
         var command = new Command("command");
-        command.AddArgument(new Argument<int>("age"));
-        command.AddArgument(new Argument<string>("fullname|nickname"));
+        command.Arguments.Add(new Argument<int>("age"));
+        command.Arguments.Add(new Argument<string>("fullname|nickname"));
         command.Handler = CommandHandler.Create<string, int>(Execute);
 
         await command.InvokeAsync("command 425 Gandalf", _console);
diff --git a/src/System.CommandLine.Tests/ArgumentTests.cs b/src/System.CommandLine.Tests/ArgumentTests.cs
index f674aa8a22..72717c61e5 100644
--- a/src/System.CommandLine.Tests/ArgumentTests.cs
+++ b/src/System.CommandLine.Tests/ArgumentTests.cs
@@ -352,7 +352,7 @@ public async Task Custom_argument_parser_is_only_called_once()
 
                 var command = new RootCommand();
                 command.SetHandler((int value) => handlerWasCalled = true, option);
-                command.AddOption(option);
+                command.Options.Add(option);
 
                 await command.InvokeAsync("--value 42");
 
diff --git a/src/System.CommandLine.Tests/Binding/SetHandlerTests.cs b/src/System.CommandLine.Tests/Binding/SetHandlerTests.cs
index eb4d168259..2a546b900d 100644
--- a/src/System.CommandLine.Tests/Binding/SetHandlerTests.cs
+++ b/src/System.CommandLine.Tests/Binding/SetHandlerTests.cs
@@ -85,7 +85,7 @@ public void Binding_is_correct_for_Action_overload_having_arity_(int arity)
 
             for (var i = 1; i <= arity; i++)
             {
-                command.AddArgument(new Argument<int>($"i{i}"));
+                command.Arguments.Add(new Argument<int>($"i{i}"));
 
                 commandLine += $" {i}";
             }
@@ -176,7 +176,7 @@ public void Binding_is_correct_for_Func_overload_having_arity_(int arity)
 
             for (var i = 1; i <= arity; i++)
             {
-                command.AddArgument(new Argument<int>($"i{i}"));
+                command.Arguments.Add(new Argument<int>($"i{i}"));
 
                 commandLine += $" {i}";
             }
diff --git a/src/System.CommandLine.Tests/CommandTests.cs b/src/System.CommandLine.Tests/CommandTests.cs
index 04d2f51a60..6cb58c8d40 100644
--- a/src/System.CommandLine.Tests/CommandTests.cs
+++ b/src/System.CommandLine.Tests/CommandTests.cs
@@ -98,7 +98,7 @@ public void Commands_at_multiple_levels_can_have_their_own_arguments()
             {
                 new Argument<string>()
             };
-            outer.AddCommand(
+            outer.Subcommands.Add(
                 new Command("inner")
                 {
                     new Argument<string[]>()
diff --git a/src/System.CommandLine.Tests/GlobalOptionTests.cs b/src/System.CommandLine.Tests/GlobalOptionTests.cs
index f02a15b214..74a8c524d7 100644
--- a/src/System.CommandLine.Tests/GlobalOptionTests.cs
+++ b/src/System.CommandLine.Tests/GlobalOptionTests.cs
@@ -19,7 +19,7 @@ public void Global_options_appear_in_options_list()
 
             var child = new Command("child");
 
-            root.AddCommand(child);
+            root.Subcommands.Add(child);
 
             root.Options.Should().Contain(option);
         }
@@ -90,7 +90,7 @@ public void Subcommands_added_after_a_global_option_is_added_to_parent_will_reco
 
             var child = new Command("child");
 
-            root.AddCommand(child);
+            root.Subcommands.Add(child);
 
             root.Parse("child --global 123").GetValue(option).Should().Be(123);
 
@@ -104,7 +104,7 @@ public void Subcommands_with_global_option_should_propagate_option_to_children()
             
             var firstChild = new Command("first");
             
-            root.AddCommand(firstChild);
+            root.Subcommands.Add(firstChild);
             
             var option = new Option<int>("--global");
             
@@ -112,7 +112,7 @@ public void Subcommands_with_global_option_should_propagate_option_to_children()
             
             var secondChild = new Command("second");
             
-            firstChild.AddCommand(secondChild);
+            firstChild.Subcommands.Add(secondChild);
             
             root.Parse("first second --global 123").GetValue(option).Should().Be(123);
             
diff --git a/src/System.CommandLine.Tests/Help/HelpBuilderTests.Customization.cs b/src/System.CommandLine.Tests/Help/HelpBuilderTests.Customization.cs
index edc6e506be..7979bb0a09 100644
--- a/src/System.CommandLine.Tests/Help/HelpBuilderTests.Customization.cs
+++ b/src/System.CommandLine.Tests/Help/HelpBuilderTests.Customization.cs
@@ -241,7 +241,7 @@ public void Option_can_fallback_to_default_when_customizing(bool conditionA, boo
                 var command = new Command("test");
                 var option = new Option<string>("--option", "description");
 
-                command.AddOption(option);
+                command.Options.Add(option);
 
                 var helpBuilder = new HelpBuilder(LocalizationResources.Instance, LargeMaxWidth);
                 helpBuilder.CustomizeSymbol(option,
@@ -278,7 +278,7 @@ public void Argument_can_fallback_to_default_when_customizing(
                 var argument = new Argument<string>("arg", "description");
                 argument.SetDefaultValue("default");
 
-                command.AddArgument(argument);
+                command.Arguments.Add(argument);
 
                 var helpBuilder = new HelpBuilder(LocalizationResources.Instance, LargeMaxWidth);
                 helpBuilder.CustomizeSymbol(argument,
diff --git a/src/System.CommandLine.Tests/Help/HelpBuilderTests.cs b/src/System.CommandLine.Tests/Help/HelpBuilderTests.cs
index 0c3e5cd5f3..25d00ccd57 100644
--- a/src/System.CommandLine.Tests/Help/HelpBuilderTests.cs
+++ b/src/System.CommandLine.Tests/Help/HelpBuilderTests.cs
@@ -144,7 +144,7 @@ public void Usage_section_shows_arguments_if_there_are_arguments_for_command_whe
                 }
             };
             var rootCommand = new RootCommand();
-            rootCommand.AddCommand(command);
+            rootCommand.Subcommands.Add(command);
 
             new HelpBuilder(LocalizationResources.Instance, LargeMaxWidth).Write(command, _console);
 
@@ -188,7 +188,7 @@ public void Usage_section_shows_arguments_if_there_are_arguments_for_command_whe
             };
 
             var rootCommand = new RootCommand();
-            rootCommand.AddCommand(command);
+            rootCommand.Subcommands.Add(command);
 
             _helpBuilder.Write(command, _console);
 
@@ -204,10 +204,10 @@ public void Usage_section_for_subcommand_shows_names_of_parent_commands()
         {
             var outer = new Command("outer", "the outer command");
             var inner = new Command("inner", "the inner command");
-            outer.AddCommand(inner);
+            outer.Subcommands.Add(inner);
             var innerEr = new Command("inner-er", "the inner-er command");
-            inner.AddCommand(innerEr);
-            innerEr.AddOption(new Option<string>("--some-option", "some option"));
+            inner.Subcommands.Add(innerEr);
+            innerEr.Options.Add(new Option<string>("--some-option", "some option"));
             var rootCommand = new RootCommand();
             rootCommand.Add(outer);
 
@@ -255,7 +255,7 @@ public void Usage_section_does_not_show_additional_arguments_when_TreatUnmatched
             var command = new Command(
                 "some-command",
                 "Does something");
-            command.AddOption(
+            command.Options.Add(
                 new Option<string>("-x", "Indicates whether x"));
 
             _helpBuilder.Write(command, _console);
@@ -268,8 +268,8 @@ public void Usage_section_does_not_show_additional_arguments_when_TreatUnmatched
         {
             var command = new RootCommand();
             var subcommand = new Command("some-command", "Does something");
-            command.AddCommand(subcommand);
-            subcommand.AddOption(new Option<string>("-x", "Indicates whether x"));
+            command.Subcommands.Add(subcommand);
+            subcommand.Options.Add(new Option<string>("-x", "Indicates whether x"));
             subcommand.TreatUnmatchedTokensAsErrors = true;
 
             _helpBuilder.Write(subcommand, _console);
@@ -282,8 +282,8 @@ public void Usage_section_shows_additional_arguments_when_TreatUnmatchedTokensAs
         {
             var command = new RootCommand();
             var subcommand = new Command("some-command", "Does something");
-            command.AddCommand(subcommand);
-            subcommand.AddOption(new Option<string>("-x", "Indicates whether x"));
+            command.Subcommands.Add(subcommand);
+            subcommand.Options.Add(new Option<string>("-x", "Indicates whether x"));
             subcommand.TreatUnmatchedTokensAsErrors = false;
 
             _helpBuilder.Write(subcommand, _console);
@@ -374,8 +374,8 @@ public void Usage_section_does_not_contain_hidden_argument()
                 Name = visibleArgName,
                 IsHidden = false
             };
-            command.AddArgument(hiddenArg);
-            command.AddArgument(visibleArg);
+            command.Arguments.Add(hiddenArg);
+            command.Arguments.Add(visibleArg);
 
             _helpBuilder.Write(command, _console);
 
@@ -543,8 +543,8 @@ public void Arguments_section_does_not_contain_hidden_argument()
                 Description = visibleDesc,
                 IsHidden = false
             };
-            command.AddArgument(hiddenArg);
-            command.AddArgument(visibleArg);
+            command.Arguments.Add(hiddenArg);
+            command.Arguments.Add(visibleArg);
 
             var expected =
                 $"Arguments:{NewLine}" +
@@ -986,7 +986,7 @@ public void Options_section_is_not_included_if_no_options_configured()
         public void Options_section_is_not_included_if_only_subcommands_configured()
         {
             var command = new Command("outer", "description for outer");
-            command.AddCommand(new Command("inner"));
+            command.Subcommands.Add(new Command("inner"));
 
             _helpBuilder.Write(command, _console);
 
@@ -1013,11 +1013,11 @@ public void Options_section_includes_option_with_empty_description()
         public void Options_section_does_not_contain_option_with_HelpDefinition_that_IsHidden()
         {
             var command = new Command("the-command");
-            command.AddOption(new Option<string>("-x", "Is Hidden")
+            command.Options.Add(new Option<string>("-x", "Is Hidden")
             {
                 IsHidden = true
             });
-            command.AddOption(new Option<string>("-n", "Not Hidden")
+            command.Options.Add(new Option<string>("-n", "Not Hidden")
             {
                 IsHidden = false
             });
@@ -1496,7 +1496,7 @@ public void Subcommand_help_contains_command_with_empty_description()
         {
             var command = new Command("the-command", "Does things.");
             var subCommand = new Command("the-subcommand", description: null);
-            command.AddCommand(subCommand);
+            command.Subcommands.Add(subCommand);
 
             _helpBuilder.Write(command, _console);
             var help = _console.ToString();
@@ -1516,8 +1516,8 @@ public void Subcommand_help_does_not_contain_hidden_command()
             {
                 IsHidden = false
             };
-            command.AddCommand(hiddenSubCommand);
-            command.AddCommand(visibleSubCommand);
+            command.Subcommands.Add(hiddenSubCommand);
+            command.Subcommands.Add(visibleSubCommand);
 
             _helpBuilder.Write(command, _console);
             var help = _console.ToString();
@@ -1541,9 +1541,9 @@ public void Subcommand_help_does_not_contain_hidden_argument()
                 Name = "the-visible",
                 IsHidden = false
             };
-            subCommand.AddArgument(hidden);
-            subCommand.AddArgument(visible);
-            command.AddCommand(subCommand);
+            subCommand.Arguments.Add(hidden);
+            subCommand.Arguments.Add(visible);
+            command.Subcommands.Add(subCommand);
 
             _helpBuilder.Write(command, _console);
             var help = _console.ToString();
diff --git a/src/System.CommandLine.Tests/Invocation/InvocationPipelineTests.cs b/src/System.CommandLine.Tests/Invocation/InvocationPipelineTests.cs
index 1938f9548b..d67eda24d4 100644
--- a/src/System.CommandLine.Tests/Invocation/InvocationPipelineTests.cs
+++ b/src/System.CommandLine.Tests/Invocation/InvocationPipelineTests.cs
@@ -180,7 +180,7 @@ public async Task ParseResult_can_be_replaced_by_middleware()
             var wasCalled = false;
             var command = new Command("the-command");
             var implicitInnerCommand = new Command("implicit-inner-command");
-            command.AddCommand(implicitInnerCommand);
+            command.Subcommands.Add(implicitInnerCommand);
             implicitInnerCommand.SetHandler(context =>
             {
                 wasCalled = true;
diff --git a/src/System.CommandLine.Tests/ParseDirectiveTests.cs b/src/System.CommandLine.Tests/ParseDirectiveTests.cs
index 9e15dd5fd6..666d9bc468 100644
--- a/src/System.CommandLine.Tests/ParseDirectiveTests.cs
+++ b/src/System.CommandLine.Tests/ParseDirectiveTests.cs
@@ -24,9 +24,9 @@ public async Task Parse_directive_writes_parse_diagram()
         {
             var rootCommand = new RootCommand();
             var subcommand = new Command("subcommand");
-            rootCommand.AddCommand(subcommand);
+            rootCommand.Subcommands.Add(subcommand);
             var option = new Option<int>(new[] { "-c", "--count" });
-            subcommand.AddOption(option);
+            subcommand.Options.Add(option);
 
             var parser = new CommandLineBuilder(rootCommand)
                          .UseParseDirective()
diff --git a/src/System.CommandLine.Tests/ParserTests.cs b/src/System.CommandLine.Tests/ParserTests.cs
index 103a10f646..40a965e8e5 100644
--- a/src/System.CommandLine.Tests/ParserTests.cs
+++ b/src/System.CommandLine.Tests/ParserTests.cs
@@ -121,9 +121,9 @@ public void Long_form_options_can_be_specified_using_colon_delimiter()
         public void Option_short_forms_can_be_bundled()
         {
             var command = new Command("the-command");
-            command.AddOption(new Option<bool>("-x"));
-            command.AddOption(new Option<bool>("-y"));
-            command.AddOption(new Option<bool>("-z"));
+            command.Options.Add(new Option<bool>("-x"));
+            command.Options.Add(new Option<bool>("-y"));
+            command.Options.Add(new Option<bool>("-z"));
 
             var result = command.Parse("the-command -xyz");
 
@@ -181,14 +181,14 @@ public void Option_long_forms_do_not_get_unbundled()
         public void Options_do_not_get_unbundled_unless_all_resulting_options_would_be_valid_for_the_current_command()
         {
             var outer = new Command("outer");
-            outer.AddOption(new Option<bool>("-a"));
+            outer.Options.Add(new Option<bool>("-a"));
             var inner = new Command("inner")
             {
                 new Argument<string[]>()
             };
-            inner.AddOption(new Option<bool>("-b"));
-            inner.AddOption(new Option<bool>("-c"));
-            outer.AddCommand(inner);
+            inner.Options.Add(new Option<bool>("-b"));
+            inner.Options.Add(new Option<bool>("-c"));
+            outer.Subcommands.Add(inner);
 
             var parser = new Parser(outer);
 
@@ -680,10 +680,10 @@ public void When_options_with_the_same_name_are_defined_on_parent_and_child_comm
         public void When_options_with_the_same_name_are_defined_on_parent_and_child_commands_and_specified_in_between_then_it_attaches_to_the_outer_command()
         {
             var outer = new Command("outer");
-            outer.AddOption(new Option<bool>("-x"));
+            outer.Options.Add(new Option<bool>("-x"));
             var inner = new Command("inner");
-            inner.AddOption(new Option<bool>("-x"));
-            outer.AddCommand(inner);
+            inner.Options.Add(new Option<bool>("-x"));
+            outer.Subcommands.Add(inner);
 
             var result = outer.Parse("outer -x inner");
 
@@ -834,7 +834,7 @@ public void When_an_option_with_a_default_value_is_not_matched_then_the_option_c
         {
             var command = new Command("command");
             var option = new Option<string>(new[] { "-o", "--option" }, () => "the-default");
-            command.AddOption(option);
+            command.Options.Add(option);
 
             ParseResult result = command.Parse("command");
 
@@ -1310,9 +1310,9 @@ public void When_a_command_line_has_unmatched_tokens_they_are_not_applied_to_sub
                 TreatUnmatchedTokensAsErrors = false
             };
             var optionX = new Option<string>("-x");
-            command.AddOption(optionX);
+            command.Options.Add(optionX);
             var optionY = new Option<string>("-y");
-            command.AddOption(optionY);
+            command.Options.Add(optionY);
 
             var result = command.Parse("-x 23 unmatched-token -y 42");
 
diff --git a/src/System.CommandLine.Tests/ParsingValidationTests.cs b/src/System.CommandLine.Tests/ParsingValidationTests.cs
index b7a20a2329..4c4e7b2d57 100644
--- a/src/System.CommandLine.Tests/ParsingValidationTests.cs
+++ b/src/System.CommandLine.Tests/ParsingValidationTests.cs
@@ -1050,8 +1050,8 @@ public void A_command_with_subcommands_is_invalid_to_invoke_if_it_has_no_handler
             var outer = new Command("outer");
             var inner = new Command("inner");
             var innerer = new Command("inner-er");
-            outer.AddCommand(inner);
-            inner.AddCommand(innerer);
+            outer.Subcommands.Add(inner);
+            inner.Subcommands.Add(innerer);
 
             var result = outer.Parse("outer inner arg");
 
@@ -1085,8 +1085,8 @@ public void A_command_with_subcommands_is_valid_to_invoke_if_it_has_a_handler()
             var inner = new Command("inner");
             inner.SetHandler(() => { });
             var innerer = new Command("inner-er");
-            outer.AddCommand(inner);
-            inner.AddCommand(innerer);
+            outer.Subcommands.Add(inner);
+            inner.Subcommands.Add(innerer);
 
             var result = outer.Parse("outer inner");
 
diff --git a/src/System.CommandLine.Tests/UseHelpTests.cs b/src/System.CommandLine.Tests/UseHelpTests.cs
index 8e9e4f9280..a3cebae75d 100644
--- a/src/System.CommandLine.Tests/UseHelpTests.cs
+++ b/src/System.CommandLine.Tests/UseHelpTests.cs
@@ -23,7 +23,7 @@ public async Task UseHelp_writes_help_for_the_specified_command()
         {
             var command = new Command("command");
             var subcommand = new Command("subcommand");
-            command.AddCommand(subcommand);
+            command.Subcommands.Add(subcommand);
 
             var parser =
                 new CommandLineBuilder(new RootCommand
@@ -47,7 +47,7 @@ public async Task UseHelp_interrupts_execution_of_the_specified_command()
             var command = new Command("command");
             var subcommand = new Command("subcommand");
             subcommand.SetHandler(() => wasCalled = true);
-            command.AddCommand(subcommand);
+            command.Subcommands.Add(subcommand);
 
             var parser =
                 new CommandLineBuilder(new RootCommand
@@ -86,7 +86,7 @@ public async Task UseHelp_accepts_default_values(string value)
         public async Task UseHelp_does_not_display_when_option_defined_with_same_alias()
         {
             var command = new Command("command");
-            command.AddOption(new Option<bool>("-h"));
+            command.Options.Add(new Option<bool>("-h"));
             
             var parser =
                 new CommandLineBuilder(new RootCommand
diff --git a/src/System.CommandLine/Builder/CommandLineBuilderExtensions.cs b/src/System.CommandLine/Builder/CommandLineBuilderExtensions.cs
index 0fb3088725..29ac9fef5e 100644
--- a/src/System.CommandLine/Builder/CommandLineBuilderExtensions.cs
+++ b/src/System.CommandLine/Builder/CommandLineBuilderExtensions.cs
@@ -641,7 +641,7 @@ public static CommandLineBuilder UseVersionOption(
             var versionOption = new VersionOption(builder);
 
             builder.VersionOption = versionOption;
-            builder.Command.AddOption(versionOption);
+            builder.Command.Options.Add(versionOption);
 
             builder.AddMiddleware(async (context, next) =>
             {
@@ -682,7 +682,7 @@ public static CommandLineBuilder UseVersionOption(
             var versionOption = new VersionOption(aliases, builder);
 
             builder.VersionOption = versionOption;
-            command.AddOption(versionOption);
+            command.Options.Add(versionOption);
 
             builder.AddMiddleware(async (context, next) =>
             {
diff --git a/src/System.CommandLine/ChildList.cs b/src/System.CommandLine/ChildList.cs
new file mode 100644
index 0000000000..21a0a2e66e
--- /dev/null
+++ b/src/System.CommandLine/ChildList.cs
@@ -0,0 +1,65 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections;
+using System.Collections.Generic;
+
+namespace System.CommandLine
+{
+    /// <summary>
+    /// a wrapper of List<typeparamref name="T"/> that sets parent for every added element
+    /// </summary>
+    internal sealed class ChildList<T> : IList<T> where T : Symbol
+    {
+        private readonly List<T> _children;
+        private readonly Command _parent;
+
+        public ChildList(Command parent)
+        {
+            _parent = parent;
+            _children = new();
+        }
+
+        public T this[int index]
+        {
+            get => _children[index];
+            set
+            {
+                _children[index] = value;
+                value.AddParent(_parent);
+            }
+        }
+
+        public int Count => _children.Count;
+
+        public bool IsReadOnly => false;
+
+        public void Add(T item)
+        {
+            item.AddParent(_parent);
+            _children.Add(item);
+        }
+
+        public void Clear() => _children.Clear();
+
+        public bool Contains(T item) => _children.Contains(item);
+
+        public void CopyTo(T[] array, int arrayIndex) => _children.CopyTo(array, arrayIndex);
+
+        public IEnumerator<T> GetEnumerator() => _children.GetEnumerator();
+
+        public int IndexOf(T item) => _children.IndexOf(item);
+
+        public void Insert(int index, T item)
+        {
+            item.AddParent(_parent);
+            _children.Insert(index, item);
+        }
+
+        public bool Remove(T item) => _children.Remove(item);
+
+        public void RemoveAt(int index) => _children.RemoveAt(index);
+
+        IEnumerator IEnumerable.GetEnumerator() => _children.GetEnumerator();
+    }
+}
diff --git a/src/System.CommandLine/Command.cs b/src/System.CommandLine/Command.cs
index d4d16d9f60..c24d041660 100644
--- a/src/System.CommandLine/Command.cs
+++ b/src/System.CommandLine/Command.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.CommandLine.Completions;
 using System.CommandLine.Parsing;
+using System.ComponentModel;
 using System.Linq;
 
 namespace System.CommandLine
@@ -19,9 +20,9 @@ namespace System.CommandLine
     /// </remarks>
     public class Command : IdentifierSymbol, IEnumerable<Symbol>
     {
-        private List<Argument>? _arguments;
-        private List<Option>? _options;
-        private List<Command>? _subcommands;
+        private ChildList<Argument>? _arguments;
+        private ChildList<Option>? _options;
+        private ChildList<Command>? _subcommands;
         private List<Action<CommandResult>>? _validators;
 
         /// <summary>
@@ -54,19 +55,19 @@ public IEnumerable<Symbol> Children
         /// <summary>
         /// Represents all of the arguments for the command.
         /// </summary>
-        public IReadOnlyList<Argument> Arguments => _arguments is not null ? _arguments : Array.Empty<Argument>();
+        public IList<Argument> Arguments => _arguments ??= new(this);
 
         internal bool HasArguments => _arguments is not null;
 
         /// <summary>
         /// Represents all of the options for the command, including global options that have been applied to any of the command's ancestors.
         /// </summary>
-        public IReadOnlyList<Option> Options => _options is not null ? _options : Array.Empty<Option>();
+        public IList<Option> Options => _options ??= new (this);
 
         /// <summary>
         /// Represents all of the subcommands for the command.
         /// </summary>
-        public IReadOnlyList<Command> Subcommands => _subcommands is not null ? _subcommands : Array.Empty<Command>();
+        public IList<Command> Subcommands => _subcommands ??= new(this);
 
         /// <summary>
         /// Validators to the command. Validators can be used
@@ -76,37 +77,6 @@ public IEnumerable<Symbol> Children
 
         internal bool HasValidators => _validators is not null && _validators.Count > 0;
 
-        /// <summary>
-        /// Adds an <see cref="Argument"/> to the command.
-        /// </summary>
-        /// <param name="argument">The argument to add to the command.</param>
-        public void AddArgument(Argument argument)
-        {
-            argument.AddParent(this);
-            (_arguments ??= new()).Add(argument);
-        }
-
-        /// <summary>
-        /// Adds a subcommand to the command.
-        /// </summary>
-        /// <param name="command">The subcommand to add to the command.</param>
-        /// <remarks>Commands can be nested to an arbitrary depth.</remarks>
-        public void AddCommand(Command command)
-        {
-            command.AddParent(this);
-            (_subcommands ??= new()).Add(command);
-        }
-
-        /// <summary>
-        /// Adds an <see cref="Option"/> to the command.
-        /// </summary>
-        /// <param name="option">The option to add to the command.</param>
-        public void AddOption(Option option)
-        {
-            option.AddParent(this);
-            (_options ??= new()).Add(option);
-        }
-
         /// <summary>
         /// Adds a global <see cref="Option"/> to the command.
         /// </summary>
@@ -116,26 +86,33 @@ public void AddOption(Option option)
         public void AddGlobalOption(Option option)
         {
             option.IsGlobal = true;
-            AddOption(option);
+            Options.Add(option);
         }
-        /// <summary>
-        /// Adds an <see cref="Option"/> to the command.
-        /// </summary>
-        /// <param name="option">The option to add to the command.</param>
-        public void Add(Option option) => AddOption(option);
-
-        /// <summary>
-        /// Adds an <see cref="Argument"/> to the command.
-        /// </summary>
-        /// <param name="argument">The argument to add to the command.</param>
-        public void Add(Argument argument) => AddArgument(argument);
 
         /// <summary>
-        /// Adds a subcommand to the command.
+        /// Adds a <see cref="Symbol"/> to the command.
         /// </summary>
-        /// <param name="command">The subcommand to add to the command.</param>
-        /// <remarks>Commands can be nested to an arbitrary depth.</remarks>
-        public void Add(Command command) => AddCommand(command);
+        /// <param name="symbol">The symbol to add to the command.</param>
+        [EditorBrowsable(EditorBrowsableState.Never)] // hide from intellisense, it's public for C# duck typing
+        public void Add(Symbol symbol)
+        {
+            // this method exists so users can use C# duck typing for adding symbols to the Command:
+            // new Command { option };
+            switch (symbol)
+            {
+                case Option option:
+                    Options.Add(option);
+                    break;
+                case Argument argument:
+                    Arguments.Add(argument);
+                    break;
+                case Command command:
+                    Subcommands.Add(command);
+                    break;
+                default:
+                    throw new NotSupportedException();
+            }
+        }
 
         private protected override string DefaultName => throw new NotImplementedException();
 
diff --git a/src/System.CommandLine/Help/HelpBuilder.cs b/src/System.CommandLine/Help/HelpBuilder.cs
index a1fde17674..55765e71f2 100644
--- a/src/System.CommandLine/Help/HelpBuilder.cs
+++ b/src/System.CommandLine/Help/HelpBuilder.cs
@@ -270,7 +270,7 @@ public void WriteColumns(IReadOnlyList<TwoColumnHelpRow> items, HelpContext cont
             }
         }
 
-        private string FormatArgumentUsage(IReadOnlyList<Argument> arguments)
+        private string FormatArgumentUsage(IList<Argument> arguments)
         {
             var sb = StringBuilderPool.Default.Rent();
 
@@ -463,7 +463,7 @@ TwoColumnHelpRow GetCommandArgumentRow(Argument argument)
 
             string GetSymbolDefaultValue(IdentifierSymbol symbol)
             {
-                IEnumerable<Argument> arguments = symbol.Arguments();
+                IList<Argument> arguments = symbol.Arguments();
                 var defaultArguments = arguments.Where(x => !x.IsHidden && x.HasDefaultValue).ToArray();
 
                 if (defaultArguments.Length == 0) return "";
diff --git a/src/System.CommandLine/Parsing/ParseResultVisitor.cs b/src/System.CommandLine/Parsing/ParseResultVisitor.cs
index 7cb598cbad..3e3c0fa47e 100644
--- a/src/System.CommandLine/Parsing/ParseResultVisitor.cs
+++ b/src/System.CommandLine/Parsing/ParseResultVisitor.cs
@@ -260,7 +260,7 @@ private void Stop()
             }
         }
 
-        private void ValidateAndConvertArgumentResults(IReadOnlyList<Argument> arguments, int commandArgumentResultCount)
+        private void ValidateAndConvertArgumentResults(IList<Argument> arguments, int commandArgumentResultCount)
         {
             for (var i = 0; i < arguments.Count; i++)
             {
@@ -407,7 +407,7 @@ private bool UseValidators(Command command, CommandResult innermostCommandResult
             return false;
         }
 
-        private void ValidateArguments(IReadOnlyList<Argument> arguments, CommandResult innermostCommandResult)
+        private void ValidateArguments(IList<Argument> arguments, CommandResult innermostCommandResult)
         {
             for (var i = 0; i < arguments.Count; i++)
             {
diff --git a/src/System.CommandLine/SymbolExtensions.cs b/src/System.CommandLine/SymbolExtensions.cs
index 036e4e3237..66c73f1157 100644
--- a/src/System.CommandLine/SymbolExtensions.cs
+++ b/src/System.CommandLine/SymbolExtensions.cs
@@ -11,7 +11,7 @@ namespace System.CommandLine
     /// </summary>
     internal static class SymbolExtensions
     {
-        internal static IReadOnlyList<Argument> Arguments(this Symbol symbol)
+        internal static IList<Argument> Arguments(this Symbol symbol)
         {
             switch (symbol)
             {