diff --git a/docs/readme-docs.md b/docs/readme-docs.md
index 54e5602d..116d5ab3 100644
--- a/docs/readme-docs.md
+++ b/docs/readme-docs.md
@@ -1,47 +1,38 @@
 # Documenting traitlets
 
-[Documentation for `traitlets`](https://traitlets.readthedocs.io/en/latest/)
-is hosted on ReadTheDocs.
+[Documentation for `traitlets`](https://traitlets.readthedocs.io/en/latest/) is hosted on ReadTheDocs.
 
 ## Build documentation locally
 
-#### Change directory to documentation root:
+With [`hatch`](https://hatch.pypa.io/), one can build environments, docs, and serve it in one command:
 
 ```
-cd docs
+pip install hatch
+hatch run docs:build
 ```
 
-#### Create environment
+#### Build documentation manually
 
-- \[**conda**\] Create conda env (and install relevant dependencies):
+Otherwise to build docs manually,
 
-  ```
-    conda env create -f environment.yml
-  ```
+```
+cd docs
+```
 
-- \[**pip**\] Create virtual environment (and install relevant dependencies):
+Create virtual environment (and install relevant dependencies):
 
-  ```
+```
     virtualenv traitlets_docs -p python3
-    pip install -r requirements.txt
-  ```
-
-#### Activate the newly built environment `traitlets_docs`
-
-- \[**conda**\] Activate conda env:
-
-  ```
-    source activate traitlets_docs
-  ```
+    pip install -r traitlets[docs]
+```
 
-- \[**pip**\] The virtualenv should have been automatically activated. If
-  not:
+The virtualenv should have been automatically activated. If not:
 
-  ```
-    source activate
-  ```
+```
+source activate
+```
 
-#### Build documentation using:
+##### Build documentation using:
 
 - Makefile for Linux and OS X:
 
@@ -55,7 +46,7 @@ cd docs
     make.bat html
   ```
 
-#### Display the documentation locally
+##### Display the documentation locally
 
 - Navigate to `build/html/index.html` in your browser.
 
@@ -77,5 +68,3 @@ cd docs
 - `source/conf.py` - Sphinx build configuration file
 - `source` directory - source for documentation
 - `source/index.rst` - Main landing page of the Sphinx documentation
-- `requirements.txt` - list of packages to install when using pip
-- `environment.yml` - list of packages to install when using conda
diff --git a/docs/source/config.rst b/docs/source/config.rst
index 72dc0089..22468617 100644
--- a/docs/source/config.rst
+++ b/docs/source/config.rst
@@ -24,11 +24,12 @@ Configuration object: :class:`~traitlets.config.Config`
 Application: :class:`~traitlets.config.Application`
     An application is a process that does a specific job. The most obvious
     application is the :command:`ipython` command line program. Each
-    application reads *one or more* configuration files and a single set of
+    application may read configuration files and a single set of
     command line options
     and then produces a master configuration object for the application. This
     configuration object is then passed to the configurable objects that the
-    application creates. These configurable objects implement the actual logic
+    application creates, usually either via the `config` or `parent` constructor
+    arguments. These configurable objects implement the actual logic
     of the application and know how to configure themselves given the
     configuration object.
 
@@ -50,14 +51,16 @@ Configurable: :class:`~traitlets.config.Configurable`
     Developers create :class:`~traitlets.config.Configurable`
     subclasses that implement all of the logic in the application. Each of
     these subclasses has its own configuration information that controls how
-    instances are created.
+    instances are created. When constructing a :class:`~traitlets.config.Configurable`,
+    the `config` or `parent` arguments can be passed to the constructor (respectively
+    a :class:`~traitlets.config.Config` and a Configurable object with a ``.config``).
 
 Singletons: :class:`~traitlets.config.SingletonConfigurable`
     Any object for which there is a single canonical instance. These are
     just like Configurables, except they have a class method
     :meth:`~traitlets.config.SingletonConfigurable.instance`,
     that returns the current active instance (or creates one if it
-    does not exist). :class:`~traitlets.config.Application`s is a singleton.
+    does not exist). :class:`~traitlets.config.Application` is a singleton.
     This lets
     objects easily connect to the current running Application without passing
     objects around everywhere.  For instance, to get the current running
@@ -87,15 +90,20 @@ Configuration objects and files
 
 A configuration object is little more than a wrapper around a dictionary.
 A configuration *file* is simply a mechanism for producing that object.
-The main IPython configuration file is a plain Python script,
-which can perform extensive logic to populate the config object.
-IPython 2.0 introduces a JSON configuration file,
-which is just a direct JSON serialization of the config dictionary,
-which is easily processed by external software.
-
+Configuration files currently can be a plain Python script or a JSON file.
+The former has the benefit that it can perform extensive logic to populate
+the config object, while the latter is just a direct JSON serialization of
+the config dictionary and can be easily processed by external software.
 When both Python and JSON configuration file are present, both will be loaded,
 with JSON configuration having higher priority.
 
+The configuration files can be loaded by calling :meth:`Application.load_config_file()`,
+which takes the relative path to the config file (with or without file extension)
+and the directories in which to search for the config file. All found configuration
+files will be loaded in reverse order, so that configs in earlier directories will
+have higher priority.
+
+
 Python configuration Files
 --------------------------
 
@@ -120,13 +128,13 @@ subclass
     from traitlets import Int, Float, Unicode, Bool
 
     class MyClass(Configurable):
-        name = Unicode('defaultname'
-            help="the name of the object"
-        ).tag(config=True)
+        name = Unicode('defaultname', help="the name of the object").tag(config=True)
         ranking = Integer(0, help="the class's ranking").tag(config=True)
         value = Float(99.0)
         # The rest of the class implementation would go here..
 
+    # Construct from config via MyClass(config=..)
+
 In this example, we see that :class:`MyClass` has three attributes, two
 of which (``name``, ``ranking``) can be configured.  All of the attributes
 are given types and default values.  If a :class:`MyClass` is instantiated,
@@ -180,7 +188,7 @@ but with a .json extension.
 Configuration described in previous section could be written as follows in a
 JSON configuration file:
 
-.. sourcecode:: json
+.. code-block:: json
 
     {
       "MyClass": {
@@ -204,20 +212,25 @@ Let's say you want to have different configuration files for various purposes.
 Our configuration system makes it easy for one configuration file to inherit
 the information in another configuration file. The :func:`load_subconfig`
 command can be used in a configuration file for this purpose. Here is a simple
-example that loads all of the values from the file :file:`base_config.py`::
+example that loads all of the values from the file :file:`base_config.py`:
 
-    # base_config.py
-    c = get_config()
+.. code-block:: python
+    :caption: examples/docs/configs/base_config.py
+
+    c = get_config()  # noqa
     c.MyClass.name = 'coolname'
     c.MyClass.ranking = 100
 
-into the configuration file :file:`main_config.py`::
+into the configuration file :file:`main_config.py`:
+
+.. code-block:: python
+    :caption: examples/docs/configs/main_config.py
+    :emphasize-lines: 4
 
-    # main_config.py
-    c = get_config()
+    c = get_config()  # noqa
 
     # Load everything from base_config.py
-    load_subconfig('base_config.py')
+    load_subconfig('base_config.py')  # noqa
 
     # Now override one of the values
     c.MyClass.name = 'bettername'
@@ -225,17 +238,19 @@ into the configuration file :file:`main_config.py`::
 In a situation like this the :func:`load_subconfig` makes sure that the
 search path for sub-configuration files is inherited from that of the parent.
 Thus, you can typically put the two in the same directory and everything will
-just work.
-
+just work. An example app using these configuration files can be found at
+`examples/docs/load_config_app.py <https://github.com/ipython/traitlets/blob/main/examples/docs/load_config_app.py>`__.
 
 Class based configuration inheritance
 =====================================
 
 There is another aspect of configuration where inheritance comes into play.
 Sometimes, your classes will have an inheritance hierarchy that you want
-to be reflected in the configuration system.  Here is a simple example::
+to be reflected in the configuration system.  Here is a simple example:
 
-    from traitlets.config.configurable import Configurable
+.. code-block:: python
+
+    from traitlets.config import Application, Configurable
     from traitlets import Integer, Float, Unicode, Bool
 
     class Foo(Configurable):
@@ -246,11 +261,15 @@ to be reflected in the configuration system.  Here is a simple example::
         name = Unicode('barname', config=True)
         othervalue = Int(0, config=True)
 
+    # construct Bar(config=..)
+
 Now, we can create a configuration file to configure instances of :class:`Foo`
-and :class:`Bar`::
+and :class:`Bar`:
+
+.. code-block:: python
 
     # config file
-    c = get_config()
+    c = get_config()  # noqa
 
     c.Foo.name = 'bestname'
     c.Bar.othervalue = 10
@@ -258,7 +277,7 @@ and :class:`Bar`::
 This class hierarchy and configuration file accomplishes the following:
 
 * The default value for :attr:`Foo.name` and :attr:`Bar.name` will be
-  'bestname'.  Because :class:`Bar` is a :class:`Foo` subclass it also
+  ``'bestname'``.  Because :class:`Bar` is a :class:`Foo` subclass it also
   picks up the configuration information for :class:`Foo`.
 * The default value for :attr:`Foo.value` and :attr:`Bar.value` will be
   ``100.0``, which is the value specified as the class default.
@@ -273,11 +292,29 @@ Command-line arguments
 ======================
 
 All configurable options can also be supplied at the command line when launching
-the application. Applications use a parser called
-:class:`~traitlets.config.loader.KVArgParseConfigLoader` to load values into a Config
-object.
+the application. Internally, when :meth:`Application.initialize()` is called,
+a :class:`~traitlets.config.loader.KVArgParseConfigLoader` instance is constructed
+to load values into a :class:`~traitlets.config.Config` object. (For advanced users,
+this can be overridden in the helper method :meth:`Application._create_loader()`.)
+
+Most command-line scripts simply need to call :meth:`Application.launch_instance()`,
+which will create the Application singleton, parse the command-line arguments, and
+start the application:
 
-By default, values are assigned in much the same way as in a config file:
+.. code-block:: python
+    :emphasize-lines: 8
+
+    from traitlets.config import Application
+
+    class MyApp(Application):
+        def start(self):
+            pass  # app logic goes here
+
+    if __name__ == "__main__":
+        MyApp.launch_instance()
+
+By default, config values are assigned from command-line arguments in much the
+same way as in a config file:
 
 .. code-block:: bash
 
@@ -285,12 +322,42 @@ By default, values are assigned in much the same way as in a config file:
 
 is the same as adding:
 
-.. sourcecode:: python
+.. code-block:: python
 
     c.InteractiveShell.autoindent = False
     c.BaseIPythonApplication.profile = 'myprofile'
 
-to your configuration file.
+to your configuration file. Command-line arguments take precedence over
+values read from configuration files. (This is done in
+:meth:`Application.load_config_file()` by merging `Application.cli_config`
+over values read from configuration files.)
+
+Note that even though :class:`Application` is a :class:`SingletonConfigurable`, multiple
+applications could still be started and called from each other by constructing
+them as one would with any other :class:`Configurable`:
+
+.. code-block:: python
+    :caption: examples/docs/multiple_apps.py
+    :emphasize-lines: 11,12,13
+
+    from traitlets.config import Application
+
+    class OtherApp(Application):
+        def start(self):
+            print("other")
+
+    class MyApp(Application):
+        classes = [OtherApp]
+        def start(self):
+            # similar to OtherApp.launch_instance(), but without singleton
+            self.other_app = OtherApp(config=self.config)
+            self.other_app.initialize(["--OtherApp.log_level", "INFO"])
+            self.other_app.start()
+
+    if __name__ == "__main__":
+        MyApp.launch_instance()
+
+
 
 .. versionchanged:: 5.0
 
@@ -329,10 +396,9 @@ to your configuration file.
 
 .. note::
 
-    Any error in configuration files which lead to this configuration
-    file will be ignored by default. Application subclasses may specify
-    `raise_config_file_errors = True` to exit on failure to load config files,
-    instead of the default of logging the failures.
+    By default, an error in a configuration file will cause the configuration
+    file to be ignored and a warning logged. Application subclasses may specify
+    `raise_config_file_errors = True` to exit on failure to load config files instead.
 
 .. versionadded:: 4.3
 
@@ -376,6 +442,31 @@ to specify the whole class name:
 
 When specifying ``alias`` dictionary in code, the values might be the strings
 like ``'Class.trait'`` or two-tuples like ``('Class.trait', "Some help message")``.
+For example:
+
+.. code-block:: python
+    :caption: examples/docs/aliases.py
+    :emphasize-lines: 11,12
+
+    from traitlets import Bool
+    from traitlets.config import Application, Configurable
+
+    class Foo(Configurable):
+        enabled = Bool(False, help="whether enabled").tag(config=True)
+
+    class App(Application):
+        classes = [Foo]
+        dry_run = Bool(False, help="dry run test").tag(config=True)
+        aliases = {
+            "dry-run": "App.dry_run",
+            ("f", "foo-enabled"): ("Foo.enabled", "whether foo is enabled"),
+        }
+
+    if __name__ == "__main__":
+        App.launch_instance()
+
+By default, the ``--log-level`` alias will be set up for ``Application.log_level``.
+
 
 Flags
 *****
@@ -400,6 +491,41 @@ For instance:
     # is equivalent to
     $ ipython --TerminalIPythonApp.display_banner=False
 
+And a runnable code example:
+
+.. code-block:: python
+    :caption: examples/docs/flags.py
+    :emphasize-lines: 11,12,13,14,15,16,17
+
+    from traitlets import Bool
+    from traitlets.config import Application, Configurable
+
+    class Foo(Configurable):
+        enabled = Bool(False, help="whether enabled").tag(config=True)
+
+    class App(Application):
+        classes = [Foo]
+        dry_run = Bool(False, help="dry run test").tag(config=True)
+        flags = {
+            "dry-run": ({"App": {"dry_run": True}}, dry_run.help),
+            ("f", "enable-foo"): ({
+               "Foo": {"enabled": True},
+            }, "Enable foo"),
+            ("disable-foo"): ({
+               "Foo": {"enabled": False},
+            }, "Disable foo"),
+        }
+
+    if __name__ == "__main__":
+        App.launch_instance()
+
+Since flags are a bit more complicated to set up, there are a couple of common patterns
+implemented in helper methods. For example, :func:`traitlets.config.boolean_flag()` sets
+up the flags ``--x`` and ``--no-x``. By default, the following few flags are set up:
+``--debug`` (setting ``log_level=DEBUG``), ``--show-config``, and ``--show-config-json``
+(print config to stdout and exit).
+
+
 Subcommands
 -----------
 
@@ -414,8 +540,9 @@ after :command:`git`, and are called with the form :command:`command subcommand
 
 .. currentmodule::  traitlets.config
 
-Subcommands are specified as a dictionary on :class:`~traitlets.config.Application`
-instances, mapping *subcommand names* to two-tuples containing these:
+Subcommands are specified as a dictionary assigned to a ``subcommands`` class member
+of :class:`~traitlets.config.Application` instances. This dictionary maps
+*subcommand names* to two-tuples containing these:
 
 1. A subclass of :class:`Application` to handle the subcommand.
    This can be specified as:
@@ -429,18 +556,86 @@ instances, mapping *subcommand names* to two-tuples containing these:
 
      .. note::
         The return value of the factory above is an *instance*, not a class,
-        son the :meth:`SingletonConfigurable.instance()` is not invoked
+        so the :meth:`SingletonConfigurable.instance()` is not invoked
         in this case.
 
-   In all cases, the instanciated app is stored in :attr:`Application.subapp`
+   In all cases, the instantiated app is stored in :attr:`Application.subapp`
    and its :meth:`Application.initialize()` is invoked.
 
 2. A short description of the subcommand for use in help output.
 
+For example (refer to ``examples/subcommands_app.py`` for a more complete example):
+
+.. code-block:: python
+    :caption: examples/docs/subcommands.py
+    :emphasize-lines: 14,15
+
+    from traitlets.config import Application
+
+    class SubApp1(Application):
+        pass
+
+    class SubApp2(Application):
+        @classmethod
+        def get_subapp_instance(cls, app: Application) -> Application:
+            app.clear_instance()  # since Application is singleton, need to clear main app
+            return cls.instance(parent=app)
+
+    class MainApp(Application):
+        subcommands = {
+            "subapp1": (SubApp1, "First subapp"),
+            "subapp2": (SubApp2.get_subapp_instance, "Second subapp"),
+        }
+
+    if __name__ == "__main__":
+        MainApp.launch_instance()
+
+
 To see a list of the available aliases, flags, and subcommands for a configurable
-application, simply pass ``-h`` or ``--help``. And to see the full list of
+application, simply pass ``-h`` or ``--help``. To see the full list of
 configurable options (*very* long), pass ``--help-all``.
 
+For more complete examples
+of setting up :class:`~traitlets.config.Application`, refer to the
+`application examples <https://github.com/ipython/traitlets/tree/main/examples>`__.
+
+
+Other `Application` members
+---------------------------
+
+The following are typically set as class variables of :class:`~traitlets.config.Application`
+subclasses, but can also be set as instance variables.
+
+* ``.classes``: A list of :class:`~traitlets.config.Configurable` classes. Similar to configs,
+  any class name can be used in ``--Class.trait=value`` arguments, including classes that the
+  :class:`~traitlets.config.Application` might not know about. However, the
+  ``--help-all`` menu will only enumerate ``config`` traits of classes in ``Application.classes``.
+  Similarly, ``.classes`` is used in other places where an application wants to list all
+  configurable traits; examples include :meth:`Application.generate_config_file()`
+  and the :ref:`argcomplete` handling.
+
+* ``.name``, ``.description``, ``.option_description``, ``.keyvalue_description``,
+  ``.subcommand_description``, ``.examples``, ``.version``: Various strings used in the ``--help``
+  menu and other messages
+
+* ``.log_level``, ``.log_datefmt``, ``.log_format``, ``.logging_config``: Configurable options
+  to control application logging, which is emitted via the logger `Application.log`. For more
+  information about these, refer to their respective traits' ``.help``.
+
+* ``.show_config``, ``.show_config_json``: Configurable boolean options, which if set to ``True``,
+  will cause the application to print the config to stdout instead of calling
+  :meth:`Application.start()`
+
+Additionally, the following are set by :class:`~traitlets.config.Application`:
+
+* ``.cli_config``: The :class:`~traitlets.config.Config` created from the command-line arguments.
+  This is saved to override any config values loaded from configuration files called by
+  :meth:`Application.load_config_file()`.
+
+* ``.extra_args``: This is a list holding any positional arguments remaining from
+  the command-line arguments parsed during :meth:`Application.initialize()`.
+  As noted earlier, these must be contiguous in the command-line.
+
 
 .. _cli_strings:
 
@@ -496,26 +691,25 @@ but does not any more with traitlets 5, please `let us know <https://github.com/
 Custom traits
 *************
 
-.. versionadded: 5.0
+.. versionadded:: 5.0
 
 Custom trait types can override :meth:`~.TraitType.from_string`
 to specify how strings should be interpreted.
 This could for example allow specifying hex-encoded bytes on the command-line:
 
-.. sourcecode:: python
+.. code-block:: python
+    :caption: examples/docs/from_string.py
+    :emphasize-lines: 6,7
 
     from binascii import a2b_hex
     from traitlets.config import Application
     from traitlets import Bytes
 
-
     class HexBytes(Bytes):
         def from_string(self, s):
             return a2b_hex(s)
 
-
     class App(Application):
-
         aliases = {"key": "App.key"}
         key = HexBytes(
             help="""
@@ -529,13 +723,12 @@ This could for example allow specifying hex-encoded bytes on the command-line:
         def start(self):
             print(f"key={self.key}")
 
-
     if __name__ == "__main__":
         App.launch_instance()
 
-::
+.. code-block:: bash
 
-    $ myprogram --key=a1b2
+    $ examples/docs/from_string.py --key=a1b2
     key=b'\xa2\xb2'
 
 
@@ -570,14 +763,13 @@ but the new way allows container items to be specified by passing the argument m
 
 This handling is good enough that we can recommend defining aliases for container traits for the first time! For example:
 
-.. sourcecode:: python
+.. code-block:: python
+    :caption: examples/docs/container.py
 
     from traitlets.config import Application
-    from traitlets import List, Dict, Integer, Unicode
-
+    from traitlets import Dict, Integer, List, Unicode
 
     class App(Application):
-
         aliases = {"x": "App.x", "y": "App.y"}
         x = List(Unicode(), config=True)
         y = Dict(Integer(), config=True)
@@ -586,13 +778,14 @@ This handling is good enough that we can recommend defining aliases for containe
             print(f"x={self.x}")
             print(f"y={self.y}")
 
-
     if __name__ == "__main__":
         App.launch_instance()
 
-produces::
+produces:
 
-    $ myprogram -x a -x b -y a=10 -y b=5
+.. code-block:: bash
+
+    $ examples/docs/container.py -x a -x b -y a=10 -y b=5
     x=['a', 'b']
     y={'a': 10, 'b': 5}
 
@@ -616,7 +809,7 @@ If you would prefer, you can also use custom container traits
 which define :meth`~.TraitType.from_string` to expand a single string into a list,
 for example:
 
-.. sourcecode::
+.. code-block:: python
 
     class PathList(List):
         def from_string(self, s):
@@ -629,6 +822,97 @@ which would allow::
 to set a ``PathList`` trait with ``["/bin", "/usr/local/bin", "/opt/bin"]``.
 
 
+.. _argcomplete:
+
+Command-line tab completion with `argcomplete`
+----------------------------------------------
+
+.. versionadded:: 5.8
+
+`traitlets` has limited support for command-line tab completion for scripts
+based on :class:`~traitlets.config.Application` using
+`argcomplete <https://github.com/kislyuk/argcomplete>`__. To use this,
+follow the instructions for setting up argcomplete;
+you will likely want to
+`activate global completion <https://github.com/kislyuk/argcomplete#activating-global-completion>`__
+by doing something alone the lines of:
+
+.. code-block:: bash
+
+    # pip install argcomplete
+    mkdir -p ~/.bash_completion.d/
+    activate-global-python-argcomplete --dest=~/.bash_completion.d/argcomplete
+    # source ~/.bash_completion.d/argcomplete from your ~/.bashrc
+
+(Follow relevant instructions for your shell.) For any script you want tab-completion
+to work on, include the line:
+
+.. code-block:: python
+
+    # PYTHON_ARGCOMPLETE_OK
+
+in the first 1024 bytes of the script.
+
+The following options can be tab-completed:
+
+* Flags and aliases
+
+* The classes in ``Application.classes``, which can be initially completed as ``--Class.``
+
+  * Once a completion is narrows to a single class, the individual ``config`` traits
+    of the class will be tab-completable, as ``--Class.trait``.
+
+* The available values for :class:`traitlets.Bool` and :class:`traitlets.Enum` will be completable,
+  as well as any other custom :class:`traitlets.TraitType` which defines a ``argcompleter()`` method
+  returning a list of available string completions.
+
+* Custom completer methods can be assigned to a trait by tagging an ``argcompleter`` metadata tag.
+  Refer to `argcomplete's documentation <https://github.com/kislyuk/argcomplete#specifying-completers>`__
+  for examples of creating custom completer methods.
+
+Detailed examples of these can be found in the docstring of
+`examples/argcomplete_app.py <https://github.com/ipython/traitlets/blob/main/examples/argcomplete_app.py>`__.
+
+
+Caveats with `argcomplete` handling
+***********************************
+
+The support for `argcomplete` is still relatively new and may not work with all ways in
+which an :class:`~traitlets.config.Application` is used. Some known caveats:
+
+* `argcomplete` is called when any `Application` first constructs and uses a
+  :class:`~traitlets.config.KVArgParseConfigLoader` instance, which constructs
+  a `argparse.ArgumentParser` instance.
+  We assume that this is usually first done in scripts when parsing the command-line arguments,
+  but technically a script can first call ``Application.initialize(["other", "args"])`` for
+  some other reason.
+
+* `traitlets` does not actually add ``"--Class.trait"`` options to the `ArgumentParser`,
+  but instead directly parses them from ``argv``. In order to complete these, a custom
+  :class:`~traitlets.config.argcomplete_config.CompletionFinder` is subclassed from
+  ``argcomplete.CompletionFinder``, which dynamically inserts the ``"--Class.""`` and ``"--Class.trait"``
+  completions when it thinks suitable. However, this handling may be a bit fragile.
+
+* Because `traitlets` initializes configs from `argv` and not from `ArgumentParser`, it may be
+  more difficult to write custom completers which dynamically provide completions based on the
+  state of other parsed arguments.
+
+* Subcommand handling is especially tricky. `argcomplete`'s strategy is to call the python script
+  with no arguments e.g. ``len(sys.argv) == 1``, run until `argcomplete` is called on an `ArgumentParser`
+  and determine what completions are available. On the other hand, `traitlet`'s subcommand-handling
+  strategy is to check ``sys.argv[1]`` and see if it matches a subcommand, and if so then dynamically
+  load the subcommand app and initialize it with ``sys.argv[1:]``. To reconcile these two different
+  approaches, some hacking was done to get `traitlets` to recognize the current command-line as seen
+  by `argcomplete`, and to get `argcomplete` to start parsing command-line arguments after subcommands
+  have been evaluated.
+
+  * Currently, completing subcommands themselves is not yet supported.
+
+  * Some applications like `Jupyter` have custom ways of constructing subcommands or parsing ``argv``
+    which complicates matters even further.
+
+More details about these caveats can be found in the `original pull request <https://github.com/ipython/traitlets/pull/811>`__.
+
 
 Design requirements
 ===================
diff --git a/examples/argcomplete_app.py b/examples/argcomplete_app.py
new file mode 100755
index 00000000..dbb7c662
--- /dev/null
+++ b/examples/argcomplete_app.py
@@ -0,0 +1,152 @@
+#!/usr/bin/env python
+# PYTHON_ARGCOMPLETE_OK
+"""A simple example to test CLI completion with `traitlets.Application`
+
+Follow the installation instructions in
+https://github.com/kislyuk/argcomplete#installation
+to install argcomplete. For example for bash, you can set up global completion
+via something like::
+
+   $ activate-global-python-argcomplete --dest=~/.bash_completion.d
+
+and ``source ~/.bash_completion.d`` in your ``~/.bashrc``. To use the
+`global-python-argcomplete`, your `traitlets.Application`-based script should
+have the string ``PYTHON_ARGCOMPLETE_OK`` in the first few lines of the script.
+
+Afterwards, try tab completing options to this script::
+
+    # Option completion, show flags, aliases and --Class.
+    $ examples/argcomplete_app.py --[TAB]
+    --Application.     --JsonPrinter.     --env-vars         --s
+    --ArgcompleteApp.  --e                --help             --skip-if-missing
+    --EnvironPrinter.  --env-var          --json-indent      --style
+
+    $ examples/argcomplete_app.py --A[TAB]
+    --Application.     --ArgcompleteApp.
+
+    # Complete class config traits
+    $ examples/argcomplete_app.py --EnvironPrinter.[TAB]
+    --EnvironPrinter.no_complete      --EnvironPrinter.style
+    --EnvironPrinter.skip_if_missing  --EnvironPrinter.vars
+
+    # Using argcomplete's provided EnvironCompleter
+    $ examples/argcomplete_app.py --EnvironPrinter.vars=[TAB]
+    APPDATA                       LS_COLORS
+    COMP_LINE                     NAME
+    COMP_POINT                    OLDPWD
+    COMP_TYPE                     PATH
+    ...
+
+    $ examples/argcomplete_app.py --EnvironPrinter.vars USER [TAB]
+    APPDATA                       LS_COLORS
+    COMP_LINE                     NAME
+    COMP_POINT                    OLDPWD
+    COMP_TYPE                     PATH
+    ...
+
+    # Alias for --EnvironPrinter.vars
+    $ examples/argcomplete_app.py --env-vars P[TAB]
+    PATH        PWD         PYTHONPATH
+
+    # Custom completer example
+    $ examples/argcomplete_app.py --env-vars PWD --json-indent [TAB]
+    2  4  8
+
+    # Enum completer example
+    $ examples/argcomplete_app.py --style [TAB]
+    ndjson   posix    verbose
+
+    # Bool completer example
+    $ examples/argcomplete_app.py --Application.show_config_json [TAB]
+    0      1      false  true
+
+If completions are not showing, you can set the environment variable ``_ARC_DEBUG=1``
+to assist in debugging argcomplete. This was last checked with ``argcomplete==1.12.3``.
+"""
+import json
+import os
+
+try:
+    from argcomplete.completers import EnvironCompleter, SuppressCompleter  # type: ignore[import]
+except ImportError:
+    EnvironCompleter = SuppressCompleter = None
+from traitlets import Bool, Enum, Int, List, Unicode
+from traitlets.config.application import Application
+from traitlets.config.configurable import Configurable
+
+
+def _indent_completions(**kwargs):
+    """Example of a custom completer, which could be dynamic"""
+    return ["2", "4", "8"]
+
+
+class JsonPrinter(Configurable):
+    indent = Int(None, allow_none=True).tag(config=True, argcompleter=_indent_completions)
+
+    def print(self, obj):
+        print(json.dumps(obj, indent=self.indent))
+
+
+class EnvironPrinter(Configurable):
+    """A class that has configurable, typed attributes."""
+
+    vars = List(trait=Unicode(), help="Environment variable").tag(
+        # NOTE: currently multiplicity is ignored by the traitlets CLI.
+        # Refer to issue GH#690 for discussion
+        config=True,
+        multiplicity="+",
+        argcompleter=EnvironCompleter,
+    )
+    no_complete = Unicode().tag(config=True, argcompleter=SuppressCompleter)
+    style = Enum(values=["posix", "ndjson", "verbose"], default_value="posix").tag(config=True)
+    skip_if_missing = Bool(False, help="Skip variable if not set").tag(config=True)
+
+    def print(self):
+        for env_var in self.vars:
+            if env_var not in os.environ:
+                if self.skip_if_missing:
+                    continue
+                else:
+                    raise KeyError(f"Environment variable not set: {env_var}")
+
+            value = os.environ[env_var]
+            if self.style == "posix":
+                print(f"{env_var}={value}")
+            elif self.style == "verbose":
+                print(f">> key: {env_var} value:\n{value}\n")
+            elif self.style == "ndjson":
+                JsonPrinter(parent=self).print({"key": env_var, "value": value})
+
+
+def bool_flag(trait, value=True):
+    return ({trait.this_class.__name__: {trait.name: value}}, trait.help)
+
+
+class ArgcompleteApp(Application):
+    name = Unicode("argcomplete-example-app")
+    description = Unicode("prints requested environment variables")
+    classes = [JsonPrinter, EnvironPrinter]
+
+    config_file = Unicode("", help="Load this config file").tag(config=True)
+
+    aliases = {
+        ("e", "env-var", "env-vars"): "EnvironPrinter.vars",
+        ("s", "style"): "EnvironPrinter.style",
+        ("json-indent"): "JsonPrinter.indent",
+    }
+
+    flags = {
+        "skip-if-missing": bool_flag(EnvironPrinter.skip_if_missing),
+    }
+
+    def initialize(self, argv=None):
+        self.parse_command_line(argv)
+        if self.config_file:
+            self.load_config_file(self.config_file)
+
+    def start(self):
+        EnvironPrinter(parent=self).print()
+
+
+if __name__ == "__main__":
+    ArgcompleteApp.launch_instance()
diff --git a/examples/docs/aliases.py b/examples/docs/aliases.py
new file mode 100755
index 00000000..2a6953fb
--- /dev/null
+++ b/examples/docs/aliases.py
@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+# PYTHON_ARGCOMPLETE_OK
+"""A simple example of using Application aliases, for docs"""
+
+from traitlets import Bool
+from traitlets.config import Application, Configurable
+
+
+class Foo(Configurable):
+    enabled = Bool(False, help="whether enabled").tag(config=True)
+
+
+class App(Application):
+    classes = [Foo]
+    dry_run = Bool(False, help="dry run test").tag(config=True)
+    aliases = {
+        "dry-run": "App.dry_run",
+        ("f", "foo-enabled"): ("Foo.enabled", "whether foo is enabled"),
+    }
+
+
+if __name__ == "__main__":
+    App.launch_instance()
diff --git a/examples/docs/configs/base_config.py b/examples/docs/configs/base_config.py
new file mode 100644
index 00000000..ed81f110
--- /dev/null
+++ b/examples/docs/configs/base_config.py
@@ -0,0 +1,5 @@
+# Example config used by load_config_app.py
+
+c = get_config()  # noqa
+c.MyClass.name = 'coolname'
+c.MyClass.ranking = 100
diff --git a/examples/docs/configs/main_config.py b/examples/docs/configs/main_config.py
new file mode 100644
index 00000000..26dfb0ce
--- /dev/null
+++ b/examples/docs/configs/main_config.py
@@ -0,0 +1,9 @@
+# Example config used by load_config_app.py
+
+c = get_config()  # noqa
+
+# Load everything from base_config.py
+load_subconfig('base_config.py')  # noqa
+
+# Now override one of the values
+c.MyClass.name = 'bettername'
diff --git a/examples/docs/container.py b/examples/docs/container.py
new file mode 100755
index 00000000..9d43bd5e
--- /dev/null
+++ b/examples/docs/container.py
@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+# PYTHON_ARGCOMPLETE_OK
+"""A simple example of using container traits in Application command-line"""
+
+from traitlets import Dict, Integer, List, Unicode
+from traitlets.config import Application
+
+
+class App(Application):
+    aliases = {"x": "App.x", "y": "App.y"}
+    x = List(Unicode(), config=True)
+    y = Dict(Integer(), config=True)
+
+    def start(self):
+        print(f"x={self.x}")
+        print(f"y={self.y}")
+
+
+if __name__ == "__main__":
+    App.launch_instance()
diff --git a/examples/docs/flags.py b/examples/docs/flags.py
new file mode 100755
index 00000000..940553ec
--- /dev/null
+++ b/examples/docs/flags.py
@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+# PYTHON_ARGCOMPLETE_OK
+"""A simple example of using Application flags, for docs"""
+
+from traitlets import Bool
+from traitlets.config import Application, Configurable
+
+
+class Foo(Configurable):
+    enabled = Bool(False, help="whether enabled").tag(config=True)
+
+
+class App(Application):
+    classes = [Foo]
+    dry_run = Bool(False, help="dry run test").tag(config=True)
+    flags = {
+        "dry-run": ({"App": {"dry_run": True}}, dry_run.help),
+        ("f", "enable-foo"): (
+            {
+                "Foo": {"enabled": True},
+            },
+            "Enable foo",
+        ),
+        ("disable-foo"): (
+            {
+                "Foo": {"enabled": False},
+            },
+            "Disable foo",
+        ),
+    }
+
+
+if __name__ == "__main__":
+    App.launch_instance()
diff --git a/examples/docs/from_string.py b/examples/docs/from_string.py
new file mode 100755
index 00000000..eb38cb78
--- /dev/null
+++ b/examples/docs/from_string.py
@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+# PYTHON_ARGCOMPLETE_OK
+"""A simple example of using TraitType.from_string, for docs"""
+
+from binascii import a2b_hex
+
+from traitlets import Bytes
+from traitlets.config import Application
+
+
+class HexBytes(Bytes):
+    def from_string(self, s):
+        return a2b_hex(s)
+
+
+class App(Application):
+    aliases = {"key": "App.key"}
+    key = HexBytes(
+        help="""
+        Key to be used.
+
+        Specify as hex on the command-line.
+        """,
+        config=True,
+    )
+
+    def start(self):
+        print(f"key={self.key}")
+
+
+if __name__ == "__main__":
+    App.launch_instance()
diff --git a/examples/docs/load_config_app.py b/examples/docs/load_config_app.py
new file mode 100755
index 00000000..1c73c096
--- /dev/null
+++ b/examples/docs/load_config_app.py
@@ -0,0 +1,55 @@
+#!/usr/bin/env python
+# PYTHON_ARGCOMPLETE_OK
+"""A simple example of loading configs and overriding
+
+Example:
+
+    $ ./examples/docs/load_config_app.py
+    bettername ranking:100
+
+    $ ./examples/docs/load_config_app.py --name cli_name
+    cli_name ranking:100
+
+    $ ./examples/docs/load_config_app.py --name cli_name --MyApp.MyClass.ranking=99
+    cli_name ranking:99
+
+    $ ./examples/docs/load_config_app.py -c ""
+    default ranking:0
+"""
+
+from pathlib import Path
+
+from traitlets import Int, Unicode
+from traitlets.config import Application, Configurable
+
+
+class MyClass(Configurable):
+    name = Unicode(default_value="default").tag(config=True)
+    ranking = Int().tag(config=True)
+
+    def __str__(self):
+        return f"{self.name} ranking:{self.ranking}"
+
+
+class MyApp(Application):
+    classes = [MyClass]
+    config_file = Unicode(default_value="main_config", help="base name of config file").tag(
+        config=True
+    )
+    aliases = {
+        "name": "MyClass.name",
+        "ranking": "MyClass.ranking",
+        ("c", "config-file"): "MyApp.config_file",
+    }
+
+    def initialize(self, argv=None):
+        super().initialize(argv=argv)
+        if self.config_file:
+            self.load_config_file(self.config_file, [Path(__file__).parent / "configs"])
+
+    def start(self):
+        print(MyClass(parent=self))
+
+
+if __name__ == "__main__":
+    MyApp.launch_instance()
diff --git a/examples/docs/multiple_apps.py b/examples/docs/multiple_apps.py
new file mode 100755
index 00000000..71a3ce1f
--- /dev/null
+++ b/examples/docs/multiple_apps.py
@@ -0,0 +1,24 @@
+#!/usr/bin/env python
+# PYTHON_ARGCOMPLETE_OK
+"""A simple example of one application calling another"""
+
+from traitlets.config import Application
+
+
+class OtherApp(Application):
+    def start(self):
+        print("other")
+
+
+class MyApp(Application):
+    classes = [OtherApp]
+
+    def start(self):
+        # similar to OtherApp.launch_instance(), but without singleton
+        self.other_app = OtherApp(config=self.config)
+        self.other_app.initialize(["--OtherApp.log_level", "INFO"])
+        self.other_app.start()
+
+
+if __name__ == "__main__":
+    MyApp.launch_instance()
diff --git a/examples/docs/subcommands.py b/examples/docs/subcommands.py
new file mode 100755
index 00000000..954d8bfe
--- /dev/null
+++ b/examples/docs/subcommands.py
@@ -0,0 +1,27 @@
+#!/usr/bin/env python
+# PYTHON_ARGCOMPLETE_OK
+"""A simple example of using Application subcommands, for docs"""
+
+from traitlets.config import Application
+
+
+class SubApp1(Application):
+    pass
+
+
+class SubApp2(Application):
+    @classmethod
+    def get_subapp_instance(cls, app: Application) -> Application:
+        app.clear_instance()  # since Application is singleton, need to clear main app
+        return cls.instance(parent=app)  # type: ignore[no-any-return]
+
+
+class MainApp(Application):
+    subcommands = {
+        "subapp1": (SubApp1, "First subapp"),
+        "subapp2": (SubApp2.get_subapp_instance, "Second subapp"),
+    }
+
+
+if __name__ == "__main__":
+    MainApp.launch_instance()
diff --git a/examples/myapp.py b/examples/myapp.py
old mode 100644
new mode 100755
index 77135ac6..e54c2bf9
--- a/examples/myapp.py
+++ b/examples/myapp.py
@@ -1,3 +1,5 @@
+#!/usr/bin/env python
+# PYTHON_ARGCOMPLETE_OK
 """A simple example of how to use traitlets.config.application.Application.
 
 This should serve as a simple example that shows how the traitlets config
@@ -29,8 +31,7 @@
 When the config attribute of an Application is updated, it will fire all of
 the trait's events for all of the config=True attributes.
 """
-
-from traitlets import Bool, Dict, Int, List, Unicode
+from traitlets import Bool, Dict, Enum, Int, List, Unicode
 from traitlets.config.application import Application
 from traitlets.config.configurable import Configurable
 
@@ -41,6 +42,7 @@ class Foo(Configurable):
     i = Int(0, help="The integer i.").tag(config=True)
     j = Int(1, help="The integer j.").tag(config=True)
     name = Unicode("Brian", help="First name.").tag(config=True, shortname="B")
+    mode = Enum(values=["on", "off", "other"], default_value="on").tag(config=True)
 
 
 class Bar(Configurable):
@@ -60,6 +62,7 @@ class MyApp(Application):
             i="Foo.i",
             j="Foo.j",
             name="Foo.name",
+            mode="Foo.mode",
             running="MyApp.running",
             enabled="Bar.enabled",
             log_level="MyApp.log_level",
@@ -93,10 +96,10 @@ def start(self):
         print("app.config:")
         print(self.config)
         print("try running with --help-all to see all available flags")
-        self.log.info("Info Mesage")
-        self.log.debug("DebugMessage")
-        self.log.critical("Warning")
-        self.log.critical("Critical mesage")
+        self.log.debug("Debug Message")
+        self.log.info("Info Message")
+        self.log.warning("Warning Message")
+        self.log.critical("Critical Message")
 
 
 def main():
diff --git a/examples/subcommands_app.py b/examples/subcommands_app.py
new file mode 100755
index 00000000..d3a2033c
--- /dev/null
+++ b/examples/subcommands_app.py
@@ -0,0 +1,79 @@
+#!/usr/bin/env python
+# PYTHON_ARGCOMPLETE_OK
+"""A simple example to demonstrate subcommands with traitlets.Application
+
+Example:
+
+    $ examples/subcommands_app.py foo --print-name alice
+    foo
+    hello alice
+
+    $ examples/subcommands_app.py bar --print-name bob
+    bar
+    hello bob
+"""
+
+from traitlets import Enum, Unicode
+from traitlets.config.application import Application
+from traitlets.config.configurable import Configurable
+
+
+class PrintHello(Configurable):
+    greet_name = Unicode("world").tag(config=True)
+    greeting = Enum(values=["hello", "hi", "bye"], default_value="hello").tag(config=True)
+
+    def run(self):
+        print(f"{self.greeting} {self.greet_name}")
+
+
+class FooApp(Application):
+    name = Unicode("foo")
+    classes = [PrintHello]
+    aliases = {
+        "print-name": "PrintHello.greet_name",
+    }
+
+    config_file = Unicode("", help="Load this config file").tag(config=True)
+
+    def start(self):
+        print(self.name)
+        PrintHello(parent=self).run()
+
+
+class BarApp(Application):
+    name = Unicode("bar")
+    classes = [PrintHello]
+    aliases = {
+        "print-name": "PrintHello.greet_name",
+    }
+
+    config_file = Unicode("", help="Load this config file").tag(config=True)
+
+    def start(self):
+        print(self.name)
+        PrintHello(parent=self).run()
+
+    @classmethod
+    def get_subapp(cls, main_app: Application) -> Application:
+        main_app.clear_instance()
+        return cls.instance(parent=main_app)  # type: ignore[no-any-return]
+
+
+class MainApp(Application):
+    name = Unicode("subcommand-example-app")
+    description = Unicode("demonstrates app with subcommands")
+    subcommands = {
+        # Subcommands should be a dictionary mapping from the subcommand name
+        # to one of the following:
+        # 1. The Application class to be instantiated e.g. FooApp
+        # 2. A string e.g. "traitlets.examples.subcommands_app.FooApp"
+        #    which will be lazily evaluated
+        # 3. A callable which takes this Application and returns an instance
+        #    (not class) of the subcommmand Application
+        "foo": (FooApp, "run foo"),
+        "bar": (BarApp.get_subapp, "run bar"),
+    }
+
+
+if __name__ == "__main__":
+    MainApp.launch_instance()
diff --git a/pyproject.toml b/pyproject.toml
index 06230a49..3296418b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -22,7 +22,7 @@ requires-python = ">=3.7"
 dynamic = ["version"]
 
 [project.optional-dependencies]
-test = ["pytest", "pre-commit"]
+test = ["pytest", "pytest-mock", "pre-commit", "argcomplete>=2.0"]
 docs = [
     "myst-parser",
     "pydata-sphinx-theme",
@@ -89,9 +89,10 @@ warn_unused_configs = true
 warn_redundant_casts = true
 warn_return_any = true
 warn_unused_ignores = true
+exclude = ["examples/docs/configs"]
 
 [tool.pytest.ini_options]
-addopts = "--durations=10 -ra --showlocals --doctest-modules --color yes"
+addopts = "--durations=10 -ra --showlocals --doctest-modules --color yes --ignore examples/docs/configs"
 testpaths = [
     "traitlets",
     "examples",
@@ -199,6 +200,8 @@ unfixable = [
 # N802 Function name `assertIn` should be lowercase
 # F841 Local variable `t` is assigned to but never used
 "traitlets/tests/*" = ["B011", "F841", "C408", "E402", "T201", "B007", "N802", "F841"]
+# B003 Assigning to os.environ doesn't clear the environment
+"traitlets/config/tests/*" = ["B003"]
 # F401 `_version.__version__` imported but unused
 # F403 `from .traitlets import *` used; unable to detect undefined names
 "traitlets/*__init__.py" = ["F401", "F403"]
diff --git a/traitlets/config/application.py b/traitlets/config/application.py
index 66f56f72..d1660106 100644
--- a/traitlets/config/application.py
+++ b/traitlets/config/application.py
@@ -400,7 +400,7 @@ def _log_default(self):
     # this must be a dict of two-tuples,
     # the first element being the application class/import string
     # and the second being the help string for the subcommand
-    subcommands: t.Union[t.Dict[str, t.Tuple[str, str]], Dict] = Dict()
+    subcommands: t.Union[t.Dict[str, t.Tuple[t.Any, str]], Dict] = Dict()
     # parse_command_line will initialize a subapp, if requested
     subapp = Instance("traitlets.config.application.Application", allow_none=True)
 
@@ -525,6 +525,7 @@ def emit_alias_help(self):
             for c in cls.mro()[:-3]:
                 classdict[c.__name__] = c
 
+        fhelp: t.Optional[str]
         for alias, longname in self.aliases.items():
             try:
                 if isinstance(longname, tuple):
@@ -786,11 +787,58 @@ def flatten_flags(self):
     def _create_loader(self, argv, aliases, flags, classes):
         return KVArgParseConfigLoader(argv, aliases, flags, classes=classes, log=self.log)
 
+    @classmethod
+    def _get_sys_argv(cls, check_argcomplete: bool = False) -> t.List[str]:
+        """Get `sys.argv` or equivalent from `argcomplete`
+
+        `argcomplete`'s strategy is to call the python script with no arguments,
+        so ``len(sys.argv) == 1``, and run until the `ArgumentParser` is constructed
+        and determine what completions are available.
+
+        On the other hand, `traitlet`'s subcommand-handling strategy is to check
+        ``sys.argv[1]`` and see if it matches a subcommand, and if so then dynamically
+        load the subcommand app and initialize it with ``sys.argv[1:]``.
+
+        This helper method helps to take the current tokens for `argcomplete` and pass
+        them through as `argv`.
+        """
+        if check_argcomplete and "_ARGCOMPLETE" in os.environ:
+            try:
+                from traitlets.config.argcomplete_config import get_argcomplete_cwords
+
+                cwords = get_argcomplete_cwords()
+                assert cwords is not None
+                return cwords
+            except (ImportError, ModuleNotFoundError):
+                pass
+        return sys.argv
+
+    @classmethod
+    def _handle_argcomplete_for_subcommand(cls):
+        """Helper for `argcomplete` to recognize `traitlets` subcommands
+
+        `argcomplete` does not know that `traitlets` has already consumed subcommands,
+        as it only "sees" the final `argparse.ArgumentParser` that is constructed.
+        (Indeed `KVArgParseConfigLoader` does not get passed subcommands at all currently.)
+        We explicitly manipulate the environment variables used internally by `argcomplete`
+        to get it to skip over the subcommand tokens.
+        """
+        if "_ARGCOMPLETE" not in os.environ:
+            return
+
+        try:
+            from traitlets.config.argcomplete_config import increment_argcomplete_index
+
+            increment_argcomplete_index()
+        except (ImportError, ModuleNotFoundError):
+            pass
+
     @catch_config_error
     def parse_command_line(self, argv=None):
         """Parse the command line arguments."""
         assert not isinstance(argv, str)
-        argv = sys.argv[1:] if argv is None else argv
+        if argv is None:
+            argv = self._get_sys_argv(check_argcomplete=bool(self.subcommands))[1:]
         self.argv = [cast_unicode(arg) for arg in argv]
 
         if argv and argv[0] == "help":
@@ -802,6 +850,7 @@ def parse_command_line(self, argv=None):
             subc, subargv = argv[0], argv[1:]
             if re.match(r"^\w(\-?\w)*$", subc) and subc in self.subcommands:
                 # it's a subcommand, and *not* a flag or class parameter
+                self._handle_argcomplete_for_subcommand()
                 return self.initialize_subcommand(subc, subargv)
 
         # Arguments after a '--' argument are for the script IPython may be
diff --git a/traitlets/config/argcomplete_config.py b/traitlets/config/argcomplete_config.py
new file mode 100644
index 00000000..054debda
--- /dev/null
+++ b/traitlets/config/argcomplete_config.py
@@ -0,0 +1,203 @@
+"""Helper utilities for integrating argcomplete with traitlets"""
+import argparse
+import os
+import typing as t
+
+try:
+    import argcomplete  # type: ignore[import]
+    from argcomplete import CompletionFinder
+except ImportError:
+    # This module and its utility methods are written to not crash even
+    # if argcomplete is not installed.
+    class StubModule:
+        def __getattr__(self, attr):
+            if not attr.startswith("__"):
+                raise ModuleNotFoundError("No module named 'argcomplete'")
+            raise AttributeError(f"argcomplete stub module has no attribute '{attr}'")
+
+    argcomplete = StubModule()
+    CompletionFinder = object
+
+
+def get_argcomplete_cwords() -> t.Optional[t.List[str]]:
+    """Get current words prior to completion point
+
+    This is normally done in the `argcomplete.CompletionFinder` constructor,
+    but is exposed here to allow `traitlets` to follow dynamic code-paths such
+    as determining whether to evaluate a subcommand.
+    """
+    if "_ARGCOMPLETE" not in os.environ:
+        return None
+
+    comp_line = os.environ["COMP_LINE"]
+    comp_point = int(os.environ["COMP_POINT"])
+    # argcomplete.debug("splitting COMP_LINE for:", comp_line, comp_point)
+    comp_words: t.List[str]
+    try:
+        (
+            cword_prequote,
+            cword_prefix,
+            cword_suffix,
+            comp_words,
+            last_wordbreak_pos,
+        ) = argcomplete.split_line(comp_line, comp_point)
+    except ModuleNotFoundError:
+        return None
+
+    # _ARGCOMPLETE is set by the shell script to tell us where comp_words
+    # should start, based on what we're completing.
+    # 1: <script> [args]
+    # 2: python <script> [args]
+    # 3: python -m <module> [args]
+    start = int(os.environ["_ARGCOMPLETE"]) - 1
+    comp_words = comp_words[start:]
+
+    # argcomplete.debug("prequote=", cword_prequote, "prefix=", cword_prefix, "suffix=", cword_suffix, "words=", comp_words, "last=", last_wordbreak_pos)
+    return comp_words
+
+
+def increment_argcomplete_index():
+    """Assumes ``$_ARGCOMPLETE`` is set and `argcomplete` is importable
+
+    Increment the index pointed to by ``$_ARGCOMPLETE``, which is used to
+    determine which word `argcomplete` should start evaluating the command-line.
+    This may be useful to "inform" `argcomplete` that we have already evaluated
+    the first word as a subcommand.
+    """
+    try:
+        os.environ["_ARGCOMPLETE"] = str(int(os.environ["_ARGCOMPLETE"]) + 1)
+    except Exception:
+        try:
+            argcomplete.debug("Unable to increment $_ARGCOMPLETE", os.environ["_ARGCOMPLETE"])
+        except (KeyError, ModuleNotFoundError):
+            pass
+
+
+class ExtendedCompletionFinder(CompletionFinder):
+    """An extension of CompletionFinder which dynamically completes class-trait based options
+
+    This finder mainly adds 2 functionalities:
+
+    1. When completing options, it will add --Class. to the list of completions, for each
+    class in Application.classes that could complete the current option.
+    2. If it detects that we are currently trying to complete an option related to --Class.,
+    it will add the corresponding config traits of Class to the ArgumentParser instance,
+    so that the traits' completers can be used.
+
+    Note that we are avoiding adding all config traits of all classes to the ArgumentParser,
+    which would be easier but would add more runtime overhead and would also make completions
+    appear more spammy.
+
+    These changes do require using the internals of argcomplete.CompletionFinder.
+    """
+
+    _parser: argparse.ArgumentParser
+    config_classes: t.List[t.Any]  # Configurables
+
+    def match_class_completions(self, cword_prefix: str) -> t.List[t.Tuple[t.Any, str]]:
+        """Match the word to be completed against our Configurable classes
+
+        Check if cword_prefix could potentially match against --{class}. for any class
+        in Application.classes.
+        """
+        class_completions = [(cls, f"--{cls.__name__}.") for cls in self.config_classes]
+        matched_completions = class_completions
+        if "." in cword_prefix:
+            cword_prefix = cword_prefix[: cword_prefix.index(".") + 1]
+            matched_completions = [(cls, c) for (cls, c) in class_completions if c == cword_prefix]
+        elif len(cword_prefix) > 0:
+            matched_completions = [
+                (cls, c) for (cls, c) in class_completions if c.startswith(cword_prefix)
+            ]
+        return matched_completions
+
+    def inject_class_to_parser(self, cls):
+        """Add dummy arguments to our ArgumentParser for the traits of this class
+
+        The argparse-based loader currently does not actually add any class traits to
+        the constructed ArgumentParser, only the flags & aliaes. In order to work nicely
+        with argcomplete's completers functionality, this method adds dummy arguments
+        of the form --Class.trait to the ArgumentParser instance.
+
+        This method should be called selectively to reduce runtime overhead and to avoid
+        spamming options across all of Application.classes.
+        """
+        try:
+            for traitname, trait in cls.class_traits(config=True).items():
+                completer = trait.metadata.get("argcompleter") or getattr(
+                    trait, "argcompleter", None
+                )
+                multiplicity = trait.metadata.get("multiplicity")
+                self._parser.add_argument(  # type: ignore[attr-defined]
+                    f"--{cls.__name__}.{traitname}",
+                    type=str,
+                    help=trait.help,
+                    nargs=multiplicity,
+                    # metavar=traitname,
+                ).completer = completer
+                # argcomplete.debug(f"added --{cls.__name__}.{traitname}")
+        except AttributeError:
+            pass
+
+    def _get_completions(
+        self, comp_words: t.List[str], cword_prefix: str, *args: t.Any
+    ) -> t.List[str]:
+        """Overriden to dynamically append --Class.trait arguments if appropriate
+
+        Warning:
+            This does not (currently) support completions of the form
+            --Class1.Class2.<...>.trait, although this is valid for traitlets.
+            Part of the reason is that we don't currently have a way to identify
+            which classes may be used with Class1 as a parent.
+
+        Warning:
+            This is an internal method in CompletionFinder and so the API might
+            be subject to drift.
+        """
+        # Try to identify if we are completing something related to --Class. for
+        # a known Class, if we are then add the Class config traits to our ArgumentParser.
+        prefix_chars = self._parser.prefix_chars
+        is_option = len(cword_prefix) > 0 and cword_prefix[0] in prefix_chars
+        if is_option:
+            # If we are currently completing an option, check if it could
+            # match with any of the --Class. completions. If there's exactly
+            # one matched class, then expand out the --Class.trait options.
+            matched_completions = self.match_class_completions(cword_prefix)
+            if len(matched_completions) == 1:
+                matched_cls = matched_completions[0][0]
+                self.inject_class_to_parser(matched_cls)
+        elif len(comp_words) > 0 and "." in comp_words[-1] and not is_option:
+            # If not an option, perform a hacky check to see if we are completing
+            # an argument for an already present --Class.trait option. Search backwards
+            # for last option (based on last word starting with prefix_chars), and see
+            # if it is of the form --Class.trait. Note that if multiplicity="+", these
+            # arguments might conflict with positional arguments.
+            for prev_word in comp_words[::-1]:
+                if len(prev_word) > 0 and prev_word[0] in prefix_chars:
+                    matched_completions = self.match_class_completions(prev_word)
+                    if matched_completions:
+                        matched_cls = matched_completions[0][0]
+                        self.inject_class_to_parser(matched_cls)
+                    break
+
+        completions: t.List[str]
+        completions = super()._get_completions(comp_words, cword_prefix, *args)
+        return completions
+
+    def _get_option_completions(
+        self, parser: argparse.ArgumentParser, cword_prefix: str
+    ) -> t.List[str]:
+        """Overriden to add --Class. completions when appropriate"""
+        completions: t.List[str]
+        completions = super()._get_option_completions(parser, cword_prefix)
+        if cword_prefix.endswith("."):
+            return completions
+
+        matched_completions = self.match_class_completions(cword_prefix)
+        if len(matched_completions) > 1:
+            completions.extend(opt for cls, opt in matched_completions)
+        # If there is exactly one match, we would expect it to have aleady
+        # been handled by the options dynamically added in _get_completions().
+        # However, maybe there's an edge cases missed here, for example if the
+        # matched class has no configurable traits.
+        return completions
diff --git a/traitlets/config/configurable.py b/traitlets/config/configurable.py
index 5f23df9e..effa8e42 100644
--- a/traitlets/config/configurable.py
+++ b/traitlets/config/configurable.py
@@ -558,7 +558,7 @@ def instance(cls, *args, **kwargs):
             return cls._instance
         else:
             raise MultipleInstanceError(
-                "An incompatible sibling of '%s' is already instanciated"
+                "An incompatible sibling of '%s' is already instantiated"
                 " as singleton: %s" % (cls.__name__, type(cls._instance).__name__)
             )
 
diff --git a/traitlets/config/loader.py b/traitlets/config/loader.py
index 0142c030..a496603c 100644
--- a/traitlets/config/loader.py
+++ b/traitlets/config/loader.py
@@ -5,6 +5,7 @@
 
 import argparse
 import copy
+import functools
 import json
 import os
 import re
@@ -995,7 +996,7 @@ def _add_arguments(self, aliases, flags, classes):
                         argparse_kwds["nargs"] = multiplicity
                 argparse_traits[argname] = (trait, argparse_kwds)
 
-        for keys, (value, _) in flags.items():
+        for keys, (value, fhelp) in flags.items():
             if not isinstance(keys, tuple):
                 keys = (keys,)
             for key in keys:
@@ -1003,7 +1004,7 @@ def _add_arguments(self, aliases, flags, classes):
                     alias_flags[aliases[key]] = value
                     continue
                 keys = ("-" + key, "--" + key) if len(key) == 1 else ("--" + key,)
-                paa(*keys, action=_FlagAction, flag=value)
+                paa(*keys, action=_FlagAction, flag=value, help=fhelp)
 
         for keys, traitname in aliases.items():
             if not isinstance(keys, tuple):
@@ -1015,8 +1016,10 @@ def _add_arguments(self, aliases, flags, classes):
                     "dest": traitname.replace(".", _DOT_REPLACEMENT),
                     "metavar": traitname,
                 }
+                argcompleter = None
                 if traitname in argparse_traits:
-                    argparse_kwds.update(argparse_traits[traitname][1])
+                    trait, kwds = argparse_traits[traitname]
+                    argparse_kwds.update(kwds)
                     if "action" in argparse_kwds and traitname in alias_flags:
                         # flag sets 'action', so can't have flag & alias with custom action
                         # on the same name
@@ -1024,6 +1027,13 @@ def _add_arguments(self, aliases, flags, classes):
                             "The alias `%s` for the 'append' sequence "
                             "config-trait `%s` cannot be also a flag!'" % (key, traitname)
                         )
+                    # For argcomplete, check if any either an argcompleter metadata tag or method
+                    # is available. If so, it should be a callable which takes the command-line key
+                    # string as an argument and other kwargs passed by argcomplete,
+                    # and returns the a list of string completions.
+                    argcompleter = trait.metadata.get("argcompleter") or getattr(
+                        trait, "argcompleter", None
+                    )
                 if traitname in alias_flags:
                     # alias and flag.
                     # when called with 0 args: flag
@@ -1033,7 +1043,11 @@ def _add_arguments(self, aliases, flags, classes):
                     argparse_kwds["flag"] = alias_flags[traitname]
                     argparse_kwds["alias"] = traitname
                 keys = ("-" + key, "--" + key) if len(key) == 1 else ("--" + key,)
-                paa(*keys, **argparse_kwds)
+                action = paa(*keys, **argparse_kwds)
+                if argcompleter is not None:
+                    # argcomplete's completers are callables returning list of completion strings
+                    action.completer = functools.partial(argcompleter, key=key)  # type: ignore
+        self.argcomplete(classes)
 
     def _convert_to_config(self):
         """self.parsed_data->self.config, parse unrecognized extra args via KVLoader."""
@@ -1083,6 +1097,19 @@ def _handle_unrecognized_alias(self, arg: str) -> None:
         """
         self.log.warning("Unrecognized alias: '%s', it will have no effect.", arg)
 
+    def argcomplete(self, classes: t.List[t.Any]) -> None:
+        try:
+            import argcomplete  # type: ignore[import]  # noqa
+        except ImportError:
+            return
+
+        from . import argcomplete_config
+
+        finder = argcomplete_config.ExtendedCompletionFinder()
+        finder.config_classes = classes
+        # for ease of testing, pass through self._argcomplete_kwargs if set
+        finder(self.parser, **getattr(self, "_argcomplete_kwargs", {}))
+
 
 class KeyValueConfigLoader(KVArgParseConfigLoader):
     """Deprecated in traitlets 5.0
diff --git a/traitlets/config/tests/test_argcomplete.py b/traitlets/config/tests/test_argcomplete.py
new file mode 100644
index 00000000..61818946
--- /dev/null
+++ b/traitlets/config/tests/test_argcomplete.py
@@ -0,0 +1,195 @@
+"""
+Tests for argcomplete handling by traitlets.config.application.Application
+"""
+
+import io
+import os
+import typing as t
+
+import pytest
+
+argcomplete = pytest.importorskip("argcomplete")
+
+from traitlets import Unicode
+from traitlets.config.application import Application
+from traitlets.config.configurable import Configurable
+from traitlets.config.loader import KVArgParseConfigLoader
+
+
+class ArgcompleteApp(Application):
+    """Override loader to pass through kwargs for argcomplete testing"""
+
+    argcomplete_kwargs: t.Dict[str, t.Any]
+
+    def _create_loader(self, argv, aliases, flags, classes):
+        loader = KVArgParseConfigLoader(argv, aliases, flags, classes=classes, log=self.log)
+        loader._argcomplete_kwargs = self.argcomplete_kwargs  # type: ignore[attr-defined]
+        return loader
+
+
+class SubApp1(ArgcompleteApp):
+    pass
+
+
+class SubApp2(ArgcompleteApp):
+    @classmethod
+    def get_subapp_instance(cls, app: Application) -> Application:
+        app.clear_instance()  # since Application is singleton, need to clear main app
+        return cls.instance(parent=app)  # type: ignore[no-any-return]
+
+
+class MainApp(ArgcompleteApp):
+    subcommands = {
+        "subapp1": (SubApp1, "First subapp"),
+        "subapp2": (SubApp2.get_subapp_instance, "Second subapp"),
+    }
+
+
+class CustomError(Exception):
+    """Helper for exit hook for testing argcomplete"""
+
+    @classmethod
+    def exit(cls, code):
+        raise cls(str(code))
+
+
+class TestArgcomplete:
+    IFS = "\013"
+    COMP_WORDBREAKS = " \t\n\"'><=;|&(:"
+
+    @pytest.fixture
+    def argcomplete_on(self, mocker):
+        """Mostly borrowed from argcomplete's unit test fixtures
+
+        Set up environment variables to mimic those passed by argcomplete
+        """
+        _old_environ = os.environ
+        os.environ = os.environ.copy()  # type: ignore[assignment]
+        os.environ["_ARGCOMPLETE"] = "1"
+        os.environ["_ARC_DEBUG"] = "yes"
+        os.environ["IFS"] = self.IFS
+        os.environ["_ARGCOMPLETE_COMP_WORDBREAKS"] = self.COMP_WORDBREAKS
+
+        # argcomplete==2.0.0 always calls fdopen(9, "w") to open a debug stream,
+        # however this could conflict with file descriptors used by pytest
+        # and lead to obscure errors. Since we are not looking at debug stream
+        # in these tests, just mock this fdopen call out.
+        mocker.patch("os.fdopen")
+        try:
+            yield
+        finally:
+            os.environ = _old_environ
+
+    def run_completer(
+        self,
+        app: ArgcompleteApp,
+        command: str,
+        point: t.Union[str, int, None] = None,
+        **kwargs: t.Any,
+    ) -> t.List[str]:
+        """Mostly borrowed from argcomplete's unit tests
+
+        Modified to take an application instead of an ArgumentParser
+
+        Command is the current command being completed and point is the index
+        into the command where the completion is triggered.
+        """
+        if point is None:
+            point = str(len(command))
+        # Flushing tempfile was leading to CI failures with Bad file descriptor, not sure why.
+        # Fortunately we can just write to a StringIO instead.
+        # print("Writing completions to temp file with mode=", write_mode)
+        # from tempfile import TemporaryFile
+        # with TemporaryFile(mode=write_mode) as t:
+        strio = io.StringIO()
+        os.environ["COMP_LINE"] = command
+        os.environ["COMP_POINT"] = str(point)
+
+        with pytest.raises(CustomError) as cm:
+            app.argcomplete_kwargs = dict(
+                output_stream=strio, exit_method=CustomError.exit, **kwargs
+            )
+            app.initialize()
+
+        if str(cm.value) != "0":
+            raise RuntimeError(f"Unexpected exit code {cm.value}")
+        out = strio.getvalue()
+        return out.split(self.IFS)
+
+    def test_complete_simple_app(self, argcomplete_on):
+        app = ArgcompleteApp()
+        expected = [
+            '--help',
+            '--debug',
+            '--show-config',
+            '--show-config-json',
+            '--log-level',
+            '--Application.',
+            '--ArgcompleteApp.',
+        ]
+        assert set(self.run_completer(app, "app --")) == set(expected)
+
+        # completing class traits
+        assert set(self.run_completer(app, "app --App")) > {
+            '--Application.show_config',
+            '--Application.log_level',
+            '--Application.log_format',
+        }
+
+    def test_complete_custom_completers(self, argcomplete_on):
+        app = ArgcompleteApp()
+        # test pre-defined completers for Bool/Enum
+        assert set(self.run_completer(app, "app --Application.log_level=")) > {"DEBUG", "INFO"}
+        assert set(self.run_completer(app, "app --ArgcompleteApp.show_config ")) == {
+            "0",
+            "1",
+            "true",
+            "false",
+        }
+
+        # test custom completer and mid-command completions
+        class CustomCls(Configurable):
+            val = Unicode().tag(
+                config=True, argcompleter=argcomplete.completers.ChoicesCompleter(["foo", "bar"])
+            )
+
+        class CustomApp(ArgcompleteApp):
+            classes = [CustomCls]
+            aliases = {("v", "val"): "CustomCls.val"}
+
+        app = CustomApp()
+        assert self.run_completer(app, "app --val ") == ["foo", "bar"]
+        assert self.run_completer(app, "app --val=") == ["foo", "bar"]
+        assert self.run_completer(app, "app -v ") == ["foo", "bar"]
+        assert self.run_completer(app, "app -v=") == ["foo", "bar"]
+        assert self.run_completer(app, "app --CustomCls.val  ") == ["foo", "bar"]
+        assert self.run_completer(app, "app --CustomCls.val=") == ["foo", "bar"]
+        completions = self.run_completer(app, "app --val= abc xyz", point=10)
+        # fixed in argcomplete >= 2.0 to return latter below
+        assert completions == ["--val=foo", "--val=bar"] or completions == ["foo", "bar"]
+        assert self.run_completer(app, "app --val  --log-level=", point=10) == ["foo", "bar"]
+
+    # TODO: don't have easy way of testing subcommands yet, since we want
+    # to inject _argcomplete_kwargs to subapp. Could use mocking for this
+    # def test_complete_subcommands_subapp1(self, argcomplete_on):
+    #     # subcommand handling modifies _ARGCOMPLETE env var global state, so
+    #     # only can test one completion per unit test
+    #     app = MainApp()
+    #     assert set(self.run_completer(app, "app subapp1 --Sub")) > {
+    #         '--SubApp1.show_config',
+    #         '--SubApp1.log_level',
+    #         '--SubApp1.log_format',
+    #     }
+    #
+    # def test_complete_subcommands_subapp2(self, argcomplete_on):
+    #     app = MainApp()
+    #     assert set(self.run_completer(app, "app subapp2 --")) > {
+    #         '--Application.',
+    #         '--SubApp2.',
+    #     }
+
+    def test_complete_subcommands_main(self, argcomplete_on):
+        app = MainApp()
+        completions = set(self.run_completer(app, "app --"))
+        assert completions > {'--Application.', '--MainApp.'}
+        assert "--SubApp1." not in completions and "--SubApp2." not in completions
diff --git a/traitlets/traitlets.py b/traitlets/traitlets.py
index 0cefe043..d715b83f 100644
--- a/traitlets/traitlets.py
+++ b/traitlets/traitlets.py
@@ -2628,6 +2628,13 @@ def from_string(self, s):
     def subclass_init(self, cls):
         pass  # fully opt out of instance_init
 
+    def argcompleter(self, **kwargs):
+        """Completion hints for argcomplete"""
+        completions = ["true", "1", "false", "0"]
+        if self.allow_none:
+            completions.append("None")
+        return completions
+
 
 class CBool(Bool):
     """A casting version of the boolean trait."""
@@ -2682,6 +2689,10 @@ def from_string(self, s):
     def subclass_init(self, cls):
         pass  # fully opt out of instance_init
 
+    def argcompleter(self, **kwargs):
+        """Completion hints for argcomplete"""
+        return [str(v) for v in self.values]
+
 
 class CaselessStrEnum(Enum):
     """An enum of strings where the case should be ignored."""
diff --git a/traitlets/utils/__init__.py b/traitlets/utils/__init__.py
index 1bf11b2e..dfec4ee3 100644
--- a/traitlets/utils/__init__.py
+++ b/traitlets/utils/__init__.py
@@ -1,4 +1,5 @@
 import os
+import pathlib
 
 
 # vestigal things from IPython_genutils.
@@ -51,6 +52,8 @@ def filefind(filename, path_dirs=None):
         path_dirs = ("",)
     elif isinstance(path_dirs, str):
         path_dirs = (path_dirs,)
+    elif isinstance(path_dirs, pathlib.Path):
+        path_dirs = (str(path_dirs),)
 
     for path in path_dirs:
         if path == ".":