diff --git a/argh/src/lib.rs b/argh/src/lib.rs
index 53b90ab..173b75e 100644
--- a/argh/src/lib.rs
+++ b/argh/src/lib.rs
@@ -10,6 +10,19 @@
 //! a top-level `FromArgs` type from the current program's commandline
 //! arguments.
 //!
+//! ## Table of Contents
+//!
+//! - [Basic Example](#basic-example)
+//! - [Switches and Options](#switches-and-options)
+//! - [Custom Option Types](#custom-option-types)
+//! - [Positional Arguments](#positional-arguments)
+//! - [Subcommands](#subcommands)
+//!   - [Dynamic Subcommands](#dynamic-subcommands)
+//! - [Custom Help and Examples](#custom-help-and-examples)
+//! - [Hidden Arguments](#hidden-arguments)
+//!   - [Skipped Fields](#skipped-fields)
+//! - [Supported `#[argh(...)]` Attributes](#supported-argh-attributes)
+//!
 //! ## Basic Example
 //!
 //! ```rust,no_run
@@ -53,6 +66,8 @@
 //! - `./some_bin -j --height 5`
 //! - `./some_bin --jump --height 5 --pilot-nickname Wes`
 //!
+//! ## Switches and Options
+//!
 //! Switches, like `jump`, are optional and will be set to true if provided.
 //!
 //! Options, like `height` and `pilot_nickname`, can be either required,
@@ -90,6 +105,8 @@
 //! }
 //! ```
 //!
+//! ## Custom Option Types
+//!
 //! Custom option types can be deserialized so long as they implement the
 //! `FromArgValue` trait (automatically implemented for all `FromStr` types).
 //! If more customized parsing is required, you can supply a custom
@@ -135,6 +152,8 @@
 //! // > Error parsing option '--how' with value 'whatever': expected "soft_core" or "hard_core"
 //! ```
 //!
+//! ## Positional Arguments
+//!
 //! Positional arguments can be declared using `#[argh(positional)]`.
 //! These arguments will be parsed in order of their declaration in
 //! the structure:
@@ -180,6 +199,8 @@
 //! before the rest of the arguments can be interpreted, and shouldn't be used
 //! for regular use as it might be confusing.
 //!
+//! ## Subcommands
+//!
 //! Subcommands are also supported. To use a subcommand, declare a separate
 //! `FromArgs` type for each subcommand as well as an enum that cases
 //! over each command:
@@ -220,6 +241,8 @@
 //! }
 //! ```
 //!
+//! ### Dynamic Subcommands
+//!
 //! You can also discover subcommands dynamically at runtime. To do this,
 //! declare subcommands as usual and add a variant to the enum with the
 //! `dynamic` attribute. Instead of deriving `FromArgs`, the value inside the
@@ -317,6 +340,8 @@
 //! }
 //! ```
 //!
+//! ## Custom Help and Examples
+//!
 //! You can define a complex help output that includes an **Examples** section.
 //! Use a `{command_name}` placeholder.
 //!
@@ -375,6 +400,8 @@
 //!   goup --height 5 --pilot-nickname Wes jump
 //! ```
 //!
+//! ## Hidden Arguments
+//!
 //! Programs that are run from an environment such as cargo may find it
 //! useful to have positional arguments present in the structure but
 //! omitted from the usage output. This can be accomplished by adding
@@ -397,6 +424,82 @@
 //!     real_first_arg: String,
 //! }
 //! ```
+//!
+//! ### Skipped Fields
+//!
+//! The `skip` attribute excludes a field from argument parsing entirely. Fields
+//! marked `skip` do not appear in help or usage text and are never set from the
+//! parsed command line arguments. Skipped fields are initialized using the value
+//! passed by `default` attribute if one is provided, or simply `Default::default()`
+//! otherwise. This is useful for fields that are part of a type but are/should be
+//! populated by other means (for example, computed after parsing).
+//!
+//! ```rust
+//! # use argh::FromArgs;
+//! use std::sync::OnceLock;
+//!
+//! # type InternalState = ();
+//!
+//! #[derive(FromArgs)]
+//! /// Reach new heights.
+//! struct GoUp {
+//!     /// how high to go
+//!     #[argh(option)]
+//!     height: usize,
+//!
+//!     // Never parsed from the command line;
+//!     // initialized with `Default::default()`
+//!     #[argh(skip)]
+//!     state: OnceLock<InternalState>,
+//! }
+//! ```
+//!
+//! ## Supported `#[argh(...)]` Attributes
+//!
+//! ### Field-level attributes
+//!
+//! | Attribute       | Description                                                                                                              | Example                                                  |
+//! | :-------------- | :----------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------- |
+//! | `arg_name`      | override the placeholder name shown for the value in usage/help                                                          | `#[argh(option, arg_name = "path")]` -> `--foo <path>`   |
+//! | `default`       | fallback expression used when an `option`/`positional` is not supplied                                                   | `#[argh(option, default = "5")] foo: u32`                |
+//! | `description`   | explicit help text for the field (usually supplied via a `///` doc comment instead)                                      | `#[argh(description = "how high to go")]`                |
+//! | `from_str_fn`   | custom parser `fn(&str) -> Result<T, String>` for an `option`/`positional`                                               | `#[argh(option, from_str_fn(parse_five))]`               |
+//! | `greedy`        | make the final `positional` consume all remaining arguments, including flags                                             | `#[argh(positional, greedy)]`                            |
+//! | `hidden_help`   | omit the argument from generated usage/help output                                                                       | `#[argh(option, hidden_help)]`                           |
+//! | `long`          | override the `--`-prefixed long name (defaults to the kebab-cased field name)                                            | `#[argh(option, long = "foo")]` -> `--foo`               |
+//! | `option`        | mark the field as a `--key value` option; the field may be required, `Option`, or `Vec` (repeating)                      | `#[argh(option)] foo: u32` -> `--foo 5`                  |
+//! | `positional`    | mark the field as a positional argument, parsed in declaration order                                                     | `#[argh(positional)] foo: String` -> `bar`               |
+//! | `short`         | add a single-character short alias for a `switch`/`option`                                                               | `#[argh(switch, short = 'f')]` -> `-f`                   |
+//! | `skip`          | unconditionally omit the field from parsing and help; initialized from `default` if present, else `Default::default()`   | `#[argh(skip)] foo: MyType`                              |
+//! | `subcommand`    | mark the field as a subcommand enum (at most one per struct)                                                             | `#[argh(subcommand)] cmd: MyCmd`                         |
+//! | `switch`        | mark the field as an optional boolean switch, set to `true` by passing the flag                                          | `#[argh(switch)] foo: bool` -> `--foo`                   |
+//! | `usage`         | opt a field into the explicit usage line (when at least one field is annotated, only annotated fields appear)            | `#[argh(option, usage)]`                                 |
+//!
+//! ### Type-level attributes
+//!
+//! | Attribute         | Description                                                                            | Example                                            |
+//! | :---------------- |:-------------------------------------------------------------------------------------- | :------------------------------------------------- |
+//! | `description`     | explicit help text for the command (usually supplied via a `///` doc comment instead)  | `#[argh(description = "a tool")]`                  |
+//! | `error_code`      | document an exit code in the `Error codes:` help section                               | `#[argh(error_code(2, "file not found"))]`         |
+//! | `example`         | add an entry to the `Examples:` help section (`{command_name}` is substituted)         | `#[argh(example = "{command_name} --foo")]`        |
+//! | `help_triggers`   | override the arguments that trigger help (defaults to `"--help"`, `"help"`)            | `#[argh(help_triggers("-h", "--help", "help"))]`   |
+//! | `name`            | the invoked name of a subcommand (required on subcommand structs)                      | `#[argh(name = "list")]`                           |
+//! | `note`            | add an entry to the `Notes:` help section                                              | `#[argh(note = "some note")]`                      |
+//! | `short`           | single-character alias for a subcommand's name                                         | `#[argh(short = 'l')]`                             |
+//! | `subcommand`      | mark a struct or enum as participating in subcommand dispatch                          | `#[argh(subcommand)]`                              |
+//! | `usage`           | fully override the generated usage line                                                | `#[argh(usage = "--foo <foo>")]`                   |
+//!
+//! ### Subcommand variant attributes
+//!
+//! | Attribute   | Description                                                                                                | Example                       |
+//! | :---------- | :--------------------------------------------------------------------------------------------------------- | :---------------------------- |
+//! | `dynamic`   | mark a subcommand enum variant as providing [dynamic subcommands](DynamicSubCommand) resolved at runtime   | `#[argh(dynamic)] Foo(Foo)`   |
+//!
+//! ### [`FromArgValue`] choice-enum variant attributes
+//!
+//! | Attribute   | Description                                                                                       | Example                                    |
+//! | :---------- | :------------------------------------------------------------------------------------------------ | :----------------------------------------- |
+//! | `name`      | override the string that maps to this choice variant (defaults to the snake-cased variant name)   | `#[argh(name = "read-write")] ReadWrite`   |
 
 #![deny(missing_docs)]
 
@@ -414,7 +517,6 @@ pub type CommandInfoWithArgs = argh_shared::CommandInfoWithArgs<'static>;
 pub type SubCommandInfo = argh_shared::SubCommandInfo<'static>;
 
 pub use argh_shared::{ErrorCodeInfo, FlagInfo, FlagInfoKind, Optionality, PositionalInfo};
-
 #[cfg(feature = "fuzzy_search")]
 use rust_fuzzy_search::fuzzy_search_best_n;
 
diff --git a/argh/tests/args_info_tests.rs b/argh/tests/args_info_tests.rs
index a1b458d..2d632ba 100644
--- a/argh/tests/args_info_tests.rs
+++ b/argh/tests/args_info_tests.rs
@@ -1071,3 +1071,73 @@ fn ok_hygiene() {
         input: String,
     }
 }
+
+#[test]
+fn args_info_unit_and_struct_variants() {
+    /// hocus pocus
+    #[derive(Debug, PartialEq, FromArgs, ArgsInfo)]
+    #[argh(subcommand, name = "magick")]
+    struct MagicCommand;
+
+    /// top-level command
+    #[derive(Debug, PartialEq, FromArgs, ArgsInfo)]
+    enum SomeCommand {
+        /// report info
+        Info,
+
+        /// do magic
+        Magic(MagicCommand),
+
+        /// create a macguffin
+        #[argh(name = "make")]
+        Create {
+            /// the macguffin name
+            #[argh(positional)]
+            macguffin: Option<String>,
+        },
+    }
+
+    let info = get_info::<SomeCommand>();
+
+    // Top-level enum has empty name and the fixed subcommand description.
+    assert_eq!(info.name, "");
+    assert_eq!(info.description, " enum of subcommands");
+
+    let names = info.commands.iter().map(|subcommand| subcommand.name).collect::<Vec<_>>();
+
+    assert_eq!(names, vec!["info", "magick", "make"]);
+
+    // Unit variant: no args beyond --help, name defaults to kebab-cased ident.
+    let unit = &info.commands[0].command;
+
+    assert_eq!(unit.name, "info");
+    assert_eq!(unit.flags, &[HELP_FLAG]);
+    assert_eq!(unit.description, "report info");
+    assert_eq!(unit.positionals, &[] as &[PositionalInfo<'_>]);
+
+    // Delegated variant defers to the unit struct's own info.
+    let magic = &info.commands[1].command;
+
+    assert_eq!(magic.name, "magick");
+    assert_eq!(magic.flags, &[HELP_FLAG]);
+    assert_eq!(magic.description, "hocus pocus");
+
+    // Struct-style variant exposes its own positional, honoring `name`.
+    let make = &info.commands[2].command;
+
+    assert_eq!(make.name, "make");
+    assert_eq!(make.description, "create a macguffin");
+    assert_eq!(
+        make.positionals,
+        &[PositionalInfo {
+            hidden: false,
+            name: "macguffin",
+            description: "the macguffin name",
+            optionality: Optionality::Optional,
+        }]
+    );
+}
+
+fn get_info<T: ArgsInfo>() -> CommandInfoWithArgs {
+    T::get_args_info()
+}
diff --git a/argh/tests/lib.rs b/argh/tests/lib.rs
index 9ef1774..5999968 100644
--- a/argh/tests/lib.rs
+++ b/argh/tests/lib.rs
@@ -11,10 +11,9 @@
     clippy::unwrap_in_result
 )]
 
-use {
-    argh::{FromArgValue, FromArgs},
-    std::fmt::Debug,
-};
+use std::fmt::Debug;
+
+use argh::{FromArgValue, FromArgs};
 
 #[test]
 fn basic_example() {
@@ -40,8 +39,7 @@ fn basic_example() {
 
 #[test]
 fn generic_example() {
-    use std::fmt::Display;
-    use std::str::FromStr;
+    use std::{fmt::Display, str::FromStr};
 
     #[derive(FromArgs, PartialEq, Debug)]
     /// Reach new heights.
@@ -468,6 +466,82 @@ fn assert_error<T: FromArgs + Debug>(args: &[&str], err_msg: &str) {
     e.status.expect_err("error had a positive status");
 }
 
+mod skip {
+    use super::*;
+
+    #[derive(Debug, Default, PartialEq)]
+    struct DefaultableValue {
+        inner: bool,
+    }
+
+    #[derive(Debug, PartialEq, argh::FromArgs)]
+    /// SkipTest
+    struct WithSkipDefaultImpl {
+        #[argh(switch)]
+        /// foo bar baz
+        flag: bool,
+        /// skipped, falls back to `Default::default()`
+        #[argh(skip)]
+        skipped: DefaultableValue,
+    }
+
+    #[derive(Debug, PartialEq, argh::FromArgs)]
+    /// SkipTest
+    struct WithSkipExplicitDefault {
+        #[argh(option)]
+        /// foo bar baz
+        option: usize,
+        /// skipped, uses the provided `default`
+        #[argh(skip, default = "DefaultableValue { inner: true }")]
+        skipped: DefaultableValue,
+    }
+
+    #[test]
+    fn skip_uses_default_impl() {
+        assert_output(
+            &["--flag"],
+            WithSkipDefaultImpl { flag: true, skipped: DefaultableValue { inner: false } },
+        );
+    }
+
+    #[test]
+    fn skip_honors_explicit_default() {
+        assert_output(
+            &["--option", "5"],
+            WithSkipExplicitDefault { option: 5, skipped: DefaultableValue { inner: true } },
+        );
+    }
+
+    #[test]
+    fn skip_is_not_parsed_as_an_option() {
+        #[cfg(not(feature = "fuzzy_search"))]
+        let expected = "Unrecognized argument: --skipped\n";
+
+        #[cfg(feature = "fuzzy_search")]
+        let expected = "Unrecognized argument: \"--skipped\". Did you mean \"--option\"?\n";
+
+        assert_error::<WithSkipExplicitDefault>(
+            &["--option", "5", "--skipped", "whatever"],
+            expected,
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "help")]
+    fn skip_is_omitted_from_help() {
+        assert_help_string::<WithSkipExplicitDefault>(
+            r#"Usage: test_arg_0 --option <option>
+
+SkipTest
+
+Options:
+  --option          foo bar baz
+  --help, help      display usage information
+"#,
+        );
+    }
+}
+
 mod options {
     use super::*;
 
@@ -1973,3 +2047,196 @@ Options:
 "#,
     );
 }
+
+#[test]
+fn unit_struct_subcommand_parses_with_no_args() {
+    /// top-level command
+    #[derive(FromArgs, PartialEq, Debug)]
+    struct TopLevel {
+        #[argh(subcommand)]
+        sub: Sub,
+    }
+
+    #[derive(FromArgs, PartialEq, Debug)]
+    #[argh(subcommand)]
+    enum Sub {
+        Magic(MagicCommand),
+    }
+
+    /// do magic
+    #[derive(FromArgs, PartialEq, Debug)]
+    #[argh(subcommand, name = "magick")]
+    struct MagicCommand;
+
+    let parsed = TopLevel::from_args(&["cmd"], &["magick"]).expect("parse");
+
+    assert_eq!(parsed, TopLevel { sub: Sub::Magic(MagicCommand) });
+
+    let parsed = TopLevel::from_args(&["cmd"], &["magick", "extra"]);
+
+    assert!(
+        parsed.is_err(),
+        "expected unit-struct subcommand to reject extra positional arguments, but got: {:?}",
+        parsed,
+    );
+}
+
+#[test]
+fn top_level_enum_dispatch_mixed_variants() {
+    /// a top-level command enum
+    #[derive(FromArgs, PartialEq, Debug)]
+    enum SomeCommand {
+        /// report info
+        Info,
+
+        /// do magic
+        Magic(MagicCommand),
+
+        /// create a macguffin
+        #[argh(name = "make")]
+        Create {
+            /// the macguffin name
+            #[argh(positional)]
+            macguffin: Option<String>,
+        },
+
+        /// set up
+        Setup {
+            /// recipe to be prepared for
+            #[argh(positional)]
+            recipe: String,
+        },
+    }
+
+    /// do magic
+    #[derive(Debug, PartialEq, FromArgs)]
+    #[argh(subcommand, name = "magick")]
+    struct MagicCommand;
+
+    // Unit variant, default kebab-cased name.
+    assert_eq!(SomeCommand::from_args(&["cmd"], &["info"]).unwrap(), SomeCommand::Info);
+
+    // Delegated variant.
+    assert_eq!(
+        SomeCommand::from_args(&["cmd"], &["magick"]).unwrap(),
+        SomeCommand::Magic(MagicCommand)
+    );
+
+    // Struct-style variant, honoring `name` override and its own positional.
+    assert_eq!(
+        SomeCommand::from_args(&["cmd"], &["make"]).unwrap(),
+        SomeCommand::Create { macguffin: None }
+    );
+    assert_eq!(
+        SomeCommand::from_args(&["cmd"], &["make", "puffin"]).unwrap(),
+        SomeCommand::Create { macguffin: Some("puffin".into()) }
+    );
+
+    // Struct-style variant with required positional.
+    assert!(SomeCommand::from_args(&["cmd"], &["setup"]).is_err());
+    assert_eq!(
+        SomeCommand::from_args(&["cmd"], &["setup", "enchanted-puffin"]).unwrap(),
+        SomeCommand::Setup { recipe: "enchanted-puffin".into() }
+    );
+
+    // No subcommand name at all.
+    assert_eq!(
+        SomeCommand::from_args(&["cmd"], &[]).unwrap_err(),
+        argh::EarlyExit { output: "no subcommand name".into(), status: Err(()) },
+    );
+
+    // Unknown subcommand.
+    assert_eq!(
+        SomeCommand::from_args(&["cmd"], &["nope"]).unwrap_err(),
+        argh::EarlyExit { output: "no subcommand matched".into(), status: Err(()) },
+    );
+}
+
+#[test]
+fn top_level_enum_default_kebab_name() {
+    /// dispatcher
+    #[derive(Debug, PartialEq, FromArgs)]
+    enum Cmd {
+        /// a two-word variant
+        DoThing,
+    }
+
+    // `DoThing` -> `do-thing`
+    assert!(Cmd::from_args(&["cmd"], &["DoThing"]).is_err());
+    assert_eq!(Cmd::from_args(&["cmd"], &["do-thing"]).unwrap(), Cmd::DoThing);
+}
+
+#[test]
+fn enum_variant_short_alias() {
+    /// dispatcher
+    #[derive(Debug, PartialEq, FromArgs)]
+    enum Cmd {
+        /// info
+        #[argh(short = 'i')]
+        Info,
+    }
+
+    assert_eq!(Cmd::from_args(&["cmd"], &["i"]).unwrap(), Cmd::Info);
+    assert_eq!(Cmd::from_args(&["cmd"], &["info"]).unwrap(), Cmd::Info);
+}
+
+#[test]
+fn top_level_enum_redaction() {
+    /// dispatcher
+    #[derive(Debug, PartialEq, FromArgs)]
+    enum Cmd {
+        /// report info
+        Info,
+
+        /// set up
+        Setup {
+            /// value
+            #[argh(positional)]
+            value: String,
+        },
+    }
+
+    // Unit variant redacts to just the command path.
+    assert_eq!(Cmd::redact_arg_values(&["cmd"], &["info"]).unwrap(), vec!["info".to_owned()],);
+
+    // Struct-style variant redacts its positional's arg name, not its value.
+    assert_eq!(
+        Cmd::redact_arg_values(&["cmd"], &["setup", "some-value"]).unwrap(),
+        vec!["setup".to_owned(), "value".to_owned()],
+    );
+
+    assert_eq!(
+        Cmd::redact_arg_values(&["cmd"], &[]).unwrap_err(),
+        argh::EarlyExit { output: "no subcommand name".into(), status: Err(()) },
+    );
+}
+
+#[test]
+fn nested_enum_with_unit_and_struct_variants() {
+    /// top-level command
+    #[derive(Debug, PartialEq, FromArgs)]
+    struct TopLevel {
+        #[argh(subcommand)]
+        sub: Sub,
+    }
+
+    #[derive(Debug, PartialEq, FromArgs)]
+    #[argh(subcommand)]
+    enum Sub {
+        /// a no-arg subcommand
+        Ping,
+
+        /// an inline subcommand
+        Echo {
+            /// the message
+            #[argh(positional)]
+            message: String,
+        },
+    }
+
+    assert_eq!(TopLevel::from_args(&["cmd"], &["ping"]).unwrap(), TopLevel { sub: Sub::Ping });
+    assert_eq!(
+        TopLevel::from_args(&["cmd"], &["echo", "hi"]).unwrap(),
+        TopLevel { sub: Sub::Echo { message: "hi".to_owned() } }
+    );
+}
diff --git a/argh/tests/ui/enum-variants/dynamic-on-struct-variant.rs b/argh/tests/ui/enum-variants/dynamic-on-struct-variant.rs
new file mode 100644
index 0000000..dbc78ca
--- /dev/null
+++ b/argh/tests/ui/enum-variants/dynamic-on-struct-variant.rs
@@ -0,0 +1,15 @@
+/// A `dynamic` attribute is only valid on a variant with a single unnamed
+/// field; applying it to a struct-style variant is an error.
+#[derive(argh::FromArgs)]
+#[argh(subcommand)]
+enum Cmd {
+    /// a thing
+    #[argh(dynamic)]
+    Thing {
+        /// a value
+        #[argh(positional)]
+        value: String,
+    },
+}
+
+fn main() {}
diff --git a/argh/tests/ui/enum-variants/dynamic-on-struct-variant.stderr b/argh/tests/ui/enum-variants/dynamic-on-struct-variant.stderr
new file mode 100644
index 0000000..bfcaef1
--- /dev/null
+++ b/argh/tests/ui/enum-variants/dynamic-on-struct-variant.stderr
@@ -0,0 +1,5 @@
+error: The `dynamic` attribute may only be applied to a variant with a single unnamed field.
+ --> tests/ui/enum-variants/dynamic-on-struct-variant.rs:6:5
+  |
+6 |     /// a thing
+  |     ^^^^^^^^^^^
diff --git a/argh/tests/ui/enum-variants/multi-field-tuple-variant.rs b/argh/tests/ui/enum-variants/multi-field-tuple-variant.rs
new file mode 100644
index 0000000..8b37185
--- /dev/null
+++ b/argh/tests/ui/enum-variants/multi-field-tuple-variant.rs
@@ -0,0 +1,9 @@
+/// Tuple variants must contain exactly one field; a multi-field tuple variant
+/// is an error.
+#[derive(argh::FromArgs)]
+#[argh(subcommand)]
+enum Cmd {
+    Pair(u32, u32),
+}
+
+fn main() {}
diff --git a/argh/tests/ui/enum-variants/multi-field-tuple-variant.stderr b/argh/tests/ui/enum-variants/multi-field-tuple-variant.stderr
new file mode 100644
index 0000000..5341b57
--- /dev/null
+++ b/argh/tests/ui/enum-variants/multi-field-tuple-variant.stderr
@@ -0,0 +1,5 @@
+error: `#![derive(FromArgs)]` tuple variants must contain exactly one field.
+ --> tests/ui/enum-variants/multi-field-tuple-variant.rs:6:9
+  |
+6 |     Pair(u32, u32),
+  |         ^^^^^^^^^^
diff --git a/argh/tests/ui/unit-struct/missing-subcommand.rs b/argh/tests/ui/unit-struct/missing-subcommand.rs
new file mode 100644
index 0000000..cd0f449
--- /dev/null
+++ b/argh/tests/ui/unit-struct/missing-subcommand.rs
@@ -0,0 +1,6 @@
+/// A unit struct used as a top-level command is not allowed; unit structs are
+/// only supported as subcommands (requiring `#[argh(subcommand)]`).
+#[derive(argh::FromArgs)]
+struct Cmd;
+
+fn main() {}
diff --git a/argh/tests/ui/unit-struct/missing-subcommand.stderr b/argh/tests/ui/unit-struct/missing-subcommand.stderr
new file mode 100644
index 0000000..988b3fb
--- /dev/null
+++ b/argh/tests/ui/unit-struct/missing-subcommand.stderr
@@ -0,0 +1,6 @@
+error: `#[derive(FromArgs)]` on unit structs is only supported for subcommands.
+       Add `#[argh(subcommand, name = "...")]` to the struct declaration.
+ --> tests/ui/unit-struct/missing-subcommand.rs:4:1
+  |
+4 | struct Cmd;
+  | ^^^^^^
diff --git a/argh_derive/src/args_info.rs b/argh_derive/src/args_info.rs
index 7e5a0dd..12533e9 100644
--- a/argh_derive/src/args_info.rs
+++ b/argh_derive/src/args_info.rs
@@ -2,16 +2,16 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+use proc_macro2::{Span, TokenStream};
+use quote::{quote, quote_spanned, ToTokens};
+use syn::LitStr;
+
 use crate::{
-    enum_only_single_field_unnamed_variants,
     errors::Errors,
     help::require_description,
     parse_attrs::{check_enum_type_attrs, FieldAttrs, FieldKind, TypeAttrs, VariantAttrs},
     Optionality, StructField,
 };
-use proc_macro2::{Span, TokenStream};
-use quote::{quote, quote_spanned, ToTokens};
-use syn::LitStr;
 
 /// Implement the derive macro for ArgsInfo.
 pub(crate) fn impl_args_info(input: &syn::DeriveInput) -> TokenStream {
@@ -47,30 +47,44 @@ fn impl_arg_info_struct(
 ) -> TokenStream {
     // Collect the fields, skipping fields that are not supported.
     let fields = match &ds.fields {
-        syn::Fields::Named(fields) => fields,
         syn::Fields::Unnamed(_) => {
             errors.err(
                 &ds.struct_token,
                 "`#![derive(ArgsInfo)]` is not currently supported on tuple structs",
             );
+
             return TokenStream::new();
         }
+        syn::Fields::Named(fields) => fields
+            .named
+            .iter()
+            .filter_map(|field| {
+                let attrs = FieldAttrs::parse(errors, field);
+
+                if attrs.skip {
+                    return None;
+                }
+
+                StructField::new(errors, field, attrs)
+            })
+            .collect::<Vec<_>>(),
         syn::Fields::Unit => {
-            errors.err(&ds.struct_token, "#![derive(ArgsInfo)]` cannot be applied to unit structs");
-            return TokenStream::new();
+            // Unit structs with an explicit `#[argh(subcommand)]` attribute
+            // at the type level are supported as no-argument subcommands.
+            if type_attrs.is_subcommand.is_none() {
+                errors.err(
+                    &ds.struct_token,
+                    concat!(
+                        "`#[derive(ArgsInfo)]` on unit structs is only supported for subcommands.\n",
+                        "Add `#[argh(subcommand, name = \"...\")]` to the struct declaration.",
+                    ),
+                );
+            }
+
+            Vec::new()
         }
     };
 
-    // Map the fields into StructField objects.
-    let fields: Vec<_> = fields
-        .named
-        .iter()
-        .filter_map(|field| {
-            let attrs = FieldAttrs::parse(errors, field);
-            StructField::new(errors, field, attrs)
-        })
-        .collect();
-
     let impl_span = Span::call_site();
 
     // Generate the implementation of `get_args_info()` for this struct.
@@ -97,59 +111,88 @@ fn impl_arg_info_enum(
     generic_args: &syn::Generics,
     de: &syn::DataEnum,
 ) -> TokenStream {
-    // Validate the enum is OK for argh.
+    // Validate the enum is OK for argh. (Both top-level and nested subcommand
+    // enums are supported; the absence of an explicit `#[argh(subcommand)]` is
+    // interpreted to mean "this is a top-level command".)
     check_enum_type_attrs(errors, type_attrs, &de.enum_token.span);
 
-    // Ensure that `#[argh(subcommand)]` is present.
-    if type_attrs.is_subcommand.is_none() {
-        errors.err_span(
-            de.enum_token.span,
-            concat!(
-                "`#![derive(ArgsInfo)]` on `enum`s can only be used to enumerate subcommands.\n",
-                "Consider adding `#[argh(subcommand)]` to the `enum` declaration.",
-            ),
-        );
-    }
-
     // One of the variants can be annotated as providing dynamic subcommands.
     // We treat this differently since we need to call a function at runtime
     // to determine the subcommands provided.
     let mut dynamic_type_and_variant = None;
 
-    // An enum variant like `<name>(<ty>)`. This is used to collect
-    // the type of the variant for each subcommand.
+    enum VariantKind<'a> {
+        /// `Foo` — a no-argument subcommand.
+        Unit,
+        /// `Foo(Bar)` — delegate to `Bar`'s `ArgsInfo`.
+        Delegated(&'a syn::Type),
+        /// `Foo { ... }` — an inline subcommand with its own arguments.
+        Struct(&'a syn::FieldsNamed),
+    }
+
     struct ArgInfoVariant<'a> {
-        ty: &'a syn::Type,
+        ident: &'a syn::Ident,
+        kind: VariantKind<'a>,
+        attrs: crate::parse_attrs::VariantAttrs,
     }
 
     let variants: Vec<ArgInfoVariant<'_>> = de
         .variants
         .iter()
         .filter_map(|variant| {
-            let name = &variant.ident;
-            let ty = enum_only_single_field_unnamed_variants(errors, &variant.fields)?;
-            if VariantAttrs::parse(errors, variant).is_dynamic.is_some() {
-                if dynamic_type_and_variant.is_some() {
-                    errors.err(variant, "Only one variant can have the `dynamic` attribute");
+            let attrs = VariantAttrs::parse(errors, variant);
+            let kind = match &variant.fields {
+                syn::Fields::Unit => VariantKind::Unit,
+                syn::Fields::Named(fields) => VariantKind::Struct(fields),
+                syn::Fields::Unnamed(fields) => {
+                    match (fields.unnamed.len(), fields.unnamed.first()) {
+                        (1, Some(syn::Field { ty, .. })) => VariantKind::Delegated(ty),
+                        _ => {
+                            errors.err(
+                                fields,
+                                "`#![derive(ArgsInfo)]` tuple variants must contain exactly one field.",
+                            );
+
+                            return None;
+                        }
+                    }
+                }
+            };
+
+            if attrs.is_dynamic.is_some() {
+                match &kind {
+                    VariantKind::Delegated(ty) => {
+                        if dynamic_type_and_variant.is_some() {
+                            errors.err(variant, "Only one variant can have the `dynamic` attribute");
+                        }
+
+                        dynamic_type_and_variant = Some((*ty, &variant.ident));
+
+                        return None;
+                    }
+                    _ => {
+                        errors.err(
+                            variant,
+                            "The `dynamic` attribute may only be applied to a variant with a single unnamed field.",
+                        );
+                    }
                 }
-                dynamic_type_and_variant = Some((ty, name));
-                None
-            } else {
-                Some(ArgInfoVariant { ty })
             }
+
+            Some(ArgInfoVariant { attrs, kind, ident: &variant.ident })
         })
         .collect();
 
     let dynamic_subcommands = if let Some((dynamic_type, _)) = dynamic_type_and_variant {
         quote! {
             <#dynamic_type as argh::DynamicSubCommand>::commands().iter()
-            .map(|s|
-         SubCommandInfo {
-                name: s.name,
-                command: CommandInfoWithArgs {
-                    name: s.name,
-                    short: s.short,
-                    description: s.description,
+            .map(|subcommand|
+         argh::SubCommandInfo {
+                name: subcommand.name,
+                command: argh::CommandInfoWithArgs {
+                    name: subcommand.name,
+                    short: subcommand.short,
+                    description: subcommand.description,
                     ..Default::default()
                 }
             }).collect()
@@ -158,14 +201,56 @@ fn impl_arg_info_enum(
         quote! { vec![]}
     };
 
-    let variant_ty_info = variants.iter().map(|t| {
-        let ty = t.ty;
-        quote!(
+    let variant_ty_info = variants.iter().map(|variant| match &variant.kind {
+        VariantKind::Delegated(ty) => quote! {
             argh::SubCommandInfo {
                 name: #ty::get_args_info().name,
-                command: #ty::get_args_info()
+                command: #ty::get_args_info(),
+            }
+        },
+        VariantKind::Unit => {
+            let name_lit = variant.attrs.name.clone().unwrap_or_else(|| {
+                syn::LitStr::new(&crate::default_variant_name(variant.ident), variant.ident.span())
+            });
+
+            let variant_attrs = crate::variant_type_attrs(
+                type_attrs,
+                &variant.attrs,
+                name_lit.clone(),
+                variant.ident.span(),
+            );
+
+            let command = impl_args_info_data(variant.ident, errors, &variant_attrs, &[]);
+
+            quote! {
+                argh::SubCommandInfo {
+                    name: #name_lit,
+                    command: #command,
+                }
             }
-        )
+        }
+        VariantKind::Struct(fields) => {
+            let name_lit = variant.attrs.name.clone().unwrap_or_else(|| {
+                syn::LitStr::new(&crate::default_variant_name(variant.ident), variant.ident.span())
+            });
+
+            let variant_attrs = crate::variant_type_attrs(
+                type_attrs,
+                &variant.attrs,
+                name_lit.clone(),
+                variant.ident.span(),
+            );
+
+            let (parsed, _skipped) = crate::collect_named_fields(errors, fields);
+            let command = impl_args_info_data(variant.ident, errors, &variant_attrs, &parsed);
+
+            quote! {
+                argh::SubCommandInfo {
+                    name: #name_lit,
+                    command: #command,
+                }
+            }
+        }
     });
 
     let cmd_name = if let Some(id) = &type_attrs.name {
diff --git a/argh_derive/src/lib.rs b/argh_derive/src/lib.rs
index ff439d0..989ab46 100644
--- a/argh_derive/src/lib.rs
+++ b/argh_derive/src/lib.rs
@@ -11,15 +11,15 @@ use syn::ext::IdentExt as _;
 /// For more thorough documentation, see the `argh` crate itself.
 extern crate proc_macro;
 
-use {
-    crate::{
-        errors::Errors,
-        parse_attrs::{check_long_name, FieldAttrs, FieldKind, TypeAttrs},
-    },
-    proc_macro2::{Span, TokenStream},
-    quote::{quote, quote_spanned, ToTokens},
-    std::{collections::HashMap, str::FromStr},
-    syn::{spanned::Spanned, GenericArgument, LitStr, PathArguments, Type},
+use std::{collections::HashMap, str::FromStr};
+
+use proc_macro2::{Span, TokenStream};
+use quote::{quote, quote_spanned, ToTokens};
+use syn::{spanned::Spanned, GenericArgument, LitStr, PathArguments, Type};
+
+use crate::{
+    errors::Errors,
+    parse_attrs::{check_long_name, FieldAttrs, FieldKind, TypeAttrs},
 };
 
 mod args_info;
@@ -286,36 +286,53 @@ fn impl_from_args_struct(
     generic_args: &syn::Generics,
     ds: &syn::DataStruct,
 ) -> TokenStream {
-    let fields = match &ds.fields {
-        syn::Fields::Named(fields) => fields,
+    let named_fields = match &ds.fields {
         syn::Fields::Unnamed(_) => {
             errors.err(
                 &ds.struct_token,
                 "`#![derive(FromArgs)]` is not currently supported on tuple structs",
             );
+
             return TokenStream::new();
         }
+        syn::Fields::Named(fields) => Some(fields),
         syn::Fields::Unit => {
-            errors.err(&ds.struct_token, "#![derive(FromArgs)]` cannot be applied to unit structs");
-            return TokenStream::new();
+            if type_attrs.is_subcommand.is_none() {
+                errors.err(
+                    &ds.struct_token,
+                    concat!(
+                        "`#[derive(FromArgs)]` on unit structs is only supported for subcommands.\n",
+                        "Add `#[argh(subcommand, name = \"...\")]` to the struct declaration.",
+                    ),
+                );
+            }
+
+            None
         }
     };
 
-    let fields: Vec<_> = fields
-        .named
-        .iter()
+    let fields: Vec<_> = named_fields
+        .into_iter()
+        .flat_map(|fields| fields.named.iter())
         .filter_map(|field| {
             let attrs = FieldAttrs::parse(errors, field);
+            if attrs.skip {
+                return None;
+            }
             StructField::new(errors, field, attrs)
         })
         .collect();
 
+    let skipped = skipped_field_initializers(errors, &ds.fields);
+
     ensure_unique_names(errors, &fields);
     ensure_only_last_positional_is_optional(errors, &fields);
 
     let impl_span = Span::call_site();
 
-    let from_args_method = impl_from_args_struct_from_args(errors, type_attrs, &fields);
+    let ctor = quote! { Self };
+    let from_args_method =
+        impl_from_args_struct_from_args(errors, type_attrs, &fields, &skipped, &ctor);
 
     let redact_arg_values_method =
         impl_from_args_struct_redact_arg_values(errors, type_attrs, &fields);
@@ -341,6 +358,34 @@ fn impl_from_args_struct_from_args<'a>(
     errors: &Errors,
     type_attrs: &TypeAttrs,
     fields: &'a [StructField<'a>],
+    skipped: &[TokenStream],
+    ctor: &TokenStream,
+) -> TokenStream {
+    let (impl_span, parse_block) =
+        (Span::call_site(), from_args_parse_block(errors, type_attrs, fields, skipped, ctor));
+
+    quote_spanned! { impl_span =>
+        fn from_args(__cmd_name: &[&str], __args: &[&str])
+            -> ::core::result::Result<Self, argh::EarlyExit>
+        {
+            #![allow(clippy::unwrap_in_result)]
+            #parse_block
+        }
+    }
+}
+
+/// Generates the body of a `from_args`-style parse: declares slots, calls
+/// `argh::parse_struct_args`, checks missing requirements, and evaluates to
+/// `Result<Self, argh::EarlyExit>` by constructing `#ctor { .. }`.
+///
+/// The generated code references the local bindings `__cmd_name: &[&str]` and
+/// `__args: &[&str]`, which the caller must have in scope.
+fn from_args_parse_block<'a>(
+    errors: &Errors,
+    type_attrs: &TypeAttrs,
+    fields: &'a [StructField<'a>],
+    skipped: &[TokenStream],
+    ctor: &TokenStream,
 ) -> TokenStream {
     let init_fields = declare_local_storage_for_from_args_fields(fields);
     let unwrap_fields = unwrap_from_args_fields(fields);
@@ -411,11 +456,7 @@ fn impl_from_args_struct_from_args<'a>(
     };
 
     let method_impl = quote_spanned! { impl_span =>
-        fn from_args(__cmd_name: &[&str], __args: &[&str])
-            -> ::core::result::Result<Self, argh::EarlyExit>
         {
-            #![allow(clippy::unwrap_in_result)]
-
             #( #init_fields )*
 
             argh::parse_struct_args(
@@ -448,8 +489,9 @@ fn impl_from_args_struct_from_args<'a>(
             )*
             #missing_requirements_ident.err_on_any()?;
 
-            ::core::result::Result::Ok(Self {
+            ::core::result::Result::Ok(#ctor {
                 #( #unwrap_fields, )*
+                #( #skipped, )*
             })
         }
     };
@@ -484,6 +526,24 @@ fn impl_from_args_struct_redact_arg_values<'a>(
     errors: &Errors,
     type_attrs: &TypeAttrs,
     fields: &'a [StructField<'a>],
+) -> TokenStream {
+    let (impl_span, parse_block) =
+        (Span::call_site(), redact_arg_values_parse_block(errors, type_attrs, fields));
+
+    quote_spanned! { impl_span =>
+        fn redact_arg_values(__cmd_name: &[&str], __args: &[&str]) -> std::result::Result<Vec<String>, argh::EarlyExit> {
+            #parse_block
+        }
+    }
+}
+
+/// Generates the body of a `redact_arg_values`-style parse. The generated code
+/// references the local bindings `__cmd_name: &[&str]` and `__args: &[&str]`,
+/// and evaluates to `Result<Vec<String>, argh::EarlyExit>`.
+fn redact_arg_values_parse_block<'a>(
+    errors: &Errors,
+    type_attrs: &TypeAttrs,
+    fields: &'a [StructField<'a>],
 ) -> TokenStream {
     let init_fields = declare_local_storage_for_redacted_fields(fields);
     let unwrap_fields = unwrap_redacted_fields(fields);
@@ -561,7 +621,7 @@ fn impl_from_args_struct_redact_arg_values<'a>(
     };
 
     let method_impl = quote_spanned! { impl_span =>
-        fn redact_arg_values(__cmd_name: &[&str], __args: &[&str]) -> std::result::Result<Vec<String>, argh::EarlyExit> {
+        {
             #( #init_fields )*
 
             argh::parse_struct_args(
@@ -611,6 +671,46 @@ fn impl_from_args_struct_redact_arg_values<'a>(
     method_impl
 }
 
+/// Generate `field_name: <value>` initializers for fields marked `#[argh(skip)]`.
+///
+/// Skipped fields are omitted entirely from parsing and help output; they are populated
+/// from the `default` expression if one is supplied, or `Default::default()` otherwise.
+fn skipped_field_initializers(errors: &Errors, fields: &syn::Fields) -> Vec<TokenStream> {
+    let mut initializers = vec![];
+
+    for field in fields.iter() {
+        let FieldAttrs { skip, default, .. } = FieldAttrs::parse(errors, field);
+
+        if !skip {
+            continue;
+        }
+
+        let name = field.ident.as_ref().expect("missing ident for named field");
+
+        let value = if let Some(default) = default {
+            match TokenStream::from_str(&default.value()) {
+                Err(_) => {
+                    errors.err(&default, "Invalid tokens: unable to lex `default` value");
+                    quote! { std::default::Default::default() }
+                }
+                Ok(tokens) => tokens
+                    .into_iter()
+                    .map(|mut tree| {
+                        tree.set_span(default.span());
+                        tree
+                    })
+                    .collect::<TokenStream>(),
+            }
+        } else {
+            quote! { std::default::Default::default() }
+        };
+
+        initializers.push(quote! { #name: #value });
+    }
+
+    initializers
+}
+
 /// Ensures that only the last positional arg is non-required.
 fn ensure_only_last_positional_is_optional(errors: &Errors, fields: &[StructField<'_>]) {
     let mut first_non_required_span = None;
@@ -1037,6 +1137,62 @@ fn ty_inner<'a>(wrapper_names: &[&str], ty: &'a syn::Type) -> Option<&'a syn::Ty
 }
 
 /// Implements `FromArgs` and `SubCommands` for a `#![derive(FromArgs)]` enum.
+/// Collect the parseable fields of a named-field group (a struct body or a
+/// struct-style enum variant body), running the same validation as the struct
+/// path. Returns the parsed fields along with the initializers for any
+/// `#[argh(skip)]` fields.
+pub(crate) fn collect_named_fields<'a>(
+    errors: &Errors,
+    fields: &'a syn::FieldsNamed,
+) -> (Vec<StructField<'a>>, Vec<TokenStream>) {
+    let parsed = fields
+        .named
+        .iter()
+        .filter_map(|field| {
+            let attrs = FieldAttrs::parse(errors, field);
+
+            if attrs.skip {
+                return None;
+            }
+
+            StructField::new(errors, field, attrs)
+        })
+        .collect::<Vec<_>>();
+
+    ensure_unique_names(errors, &parsed);
+    ensure_only_last_positional_is_optional(errors, &parsed);
+
+    let skipped = skipped_field_initializers(errors, &syn::Fields::Named(fields.clone()));
+
+    (parsed, skipped)
+}
+
+/// Build a synthetic [`TypeAttrs`] describing an inline enum-variant subcommand
+/// (a unit or struct-style variant), so the shared struct-parsing machinery can
+/// generate its help output and error messages.
+pub(crate) fn variant_type_attrs(
+    TypeAttrs { help_triggers, .. }: &TypeAttrs,
+    parse_attrs::VariantAttrs { short, description, .. }: &parse_attrs::VariantAttrs,
+    name: syn::LitStr,
+    span: Span,
+) -> TypeAttrs {
+    let (name, short, description, help_triggers, is_subcommand) = (
+        Some(name),
+        short.clone(),
+        description.clone(),
+        help_triggers.clone(),
+        Some(syn::Ident::new("subcommand", span)),
+    );
+
+    TypeAttrs { name, short, description, help_triggers, is_subcommand, ..Default::default() }
+}
+
+/// The default subcommand name for an inline enum variant lacking an explicit
+/// `#[argh(name = "...")]`: the variant identifier in kebab-case.
+pub(crate) fn default_variant_name(ident: &syn::Ident) -> String {
+    to_kebab_case(&pascal_to_snake_case(&ident.unraw().to_string()))
+}
+
 fn impl_from_args_enum(
     errors: &Errors,
     name: &syn::Ident,
@@ -1046,52 +1202,261 @@ fn impl_from_args_enum(
 ) -> TokenStream {
     parse_attrs::check_enum_type_attrs(errors, type_attrs, &de.enum_token.span);
 
-    // An enum variant like `<name>(<ty>)`
-    struct SubCommandVariant<'a> {
-        name: &'a syn::Ident,
-        ty: &'a syn::Type,
+    // Whether this enum is a top-level command (usable with `from_env`) or a
+    // nested subcommand dispatcher (referenced from a struct's `#[argh(subcommand)]`
+    // field). Nested enums carry the `#[argh(subcommand)]` marker; top-level enums
+    // do not.
+    let is_top_level = type_attrs.is_subcommand.is_none();
+
+    enum VariantKind<'a> {
+        /// `Foo` — a no-argument subcommand.
+        Unit,
+        /// `Foo(Bar)` — delegate parsing to `Bar`.
+        Delegated(&'a syn::Type),
+        /// `Foo { .. }` — an inline subcommand with its own arguments.
+        Struct(&'a syn::FieldsNamed),
+    }
+
+    struct Variant<'a> {
+        ident: &'a syn::Ident,
+        attrs: parse_attrs::VariantAttrs,
+        kind: VariantKind<'a>,
     }
 
     let mut dynamic_type_and_variant = None;
 
-    let variants: Vec<SubCommandVariant<'_>> = de
+    let variants = de
         .variants
         .iter()
         .filter_map(|variant| {
-            let name = &variant.ident;
-            let ty = enum_only_single_field_unnamed_variants(errors, &variant.fields)?;
-            if parse_attrs::VariantAttrs::parse(errors, variant).is_dynamic.is_some() {
-                if dynamic_type_and_variant.is_some() {
-                    errors.err(variant, "Only one variant can have the `dynamic` attribute");
+            let attrs = parse_attrs::VariantAttrs::parse(errors, variant);
+
+            let kind = match &variant.fields {
+                syn::Fields::Unit => VariantKind::Unit,
+                syn::Fields::Named(fields) => VariantKind::Struct(fields),
+                syn::Fields::Unnamed(fields @ syn::FieldsUnnamed { unnamed, .. }) => {
+                    match (unnamed.len(), unnamed.first()) {
+                        (1, Some(syn::Field { ty, .. })) => VariantKind::Delegated(ty),
+                        _ => {
+                            errors.err(
+                                fields,
+                                "`#![derive(FromArgs)]` tuple variants must contain exactly one field.",
+                            );
+
+                            return None;
+                        }
+                    }
+                }
+            };
+
+            if attrs.is_dynamic.is_some() {
+                match &kind {
+                    VariantKind::Delegated(ty) => {
+                        if dynamic_type_and_variant.is_some() {
+                            errors.err(variant, "Only one variant can have the `dynamic` attribute");
+                        }
+
+                        dynamic_type_and_variant = Some((*ty, &variant.ident));
+
+                        return None;
+                    }
+                    _ => {
+                        errors.err(
+                            variant,
+                            "The `dynamic` attribute may only be applied to a variant with a single unnamed field.",
+                        );
+                    }
                 }
-                dynamic_type_and_variant = Some((ty, name));
-                None
-            } else {
-                Some(SubCommandVariant { name, ty })
             }
+
+            Some(Variant { ident: &variant.ident, attrs, kind })
         })
-        .collect();
+        .collect::<Vec<_>>();
+
+    // Per-variant `&'static argh::CommandInfo` expressions, used both for the
+    // `SubCommands::COMMANDS` list and for matching an incoming subcommand name.
+    let info_expr = |variant: &Variant<'_>| -> TokenStream {
+        match &variant.kind {
+            VariantKind::Delegated(ty) => quote! { <#ty as argh::SubCommand>::COMMAND },
+            VariantKind::Unit | VariantKind::Struct(_) => {
+                let name_lit = variant.attrs.name.clone().unwrap_or_else(|| {
+                    syn::LitStr::new(&default_variant_name(variant.ident), variant.ident.span())
+                });
+
+                let short = variant
+                    .attrs
+                    .short
+                    .as_ref()
+                    .map(|character| quote! { &#character })
+                    .unwrap_or_else(|| quote! { &'\0' });
+
+                let desc = if cfg!(feature = "help") {
+                    variant
+                        .attrs
+                        .description
+                        .as_ref()
+                        .map(|description| description.content.value().trim().to_owned())
+                        .unwrap_or_default()
+                } else {
+                    String::new()
+                };
+
+                quote! {
+                    &argh::CommandInfo { name: #name_lit, short: #short, description: #desc }
+                }
+            }
+        }
+    };
+
+    // The body that constructs the matched variant, evaluating to
+    // `Result<Self, argh::EarlyExit>`. References the `__dispatch_cmd` and
+    // `__dispatch_args` locals.
+    let from_args_body = |variant: &Variant<'_>| -> TokenStream {
+        match &variant.kind {
+            VariantKind::Delegated(ty) => {
+                let ident = variant.ident;
+
+                quote! {
+                    ::core::result::Result::Ok(#name::#ident(
+                        <#ty as argh::FromArgs>::from_args(__dispatch_cmd, __dispatch_args)?
+                    ))
+                }
+            }
+            VariantKind::Unit => {
+                let ident = variant.ident;
+                let name_lit = variant.attrs.name.clone().unwrap_or_else(|| {
+                    syn::LitStr::new(&default_variant_name(variant.ident), variant.ident.span())
+                });
+                let vattrs =
+                    variant_type_attrs(type_attrs, &variant.attrs, name_lit, variant.ident.span());
+                let ctor = quote! { #name::#ident };
+                let block = from_args_parse_block(errors, &vattrs, &[], &[], &ctor);
+                quote! {{
+                    let __cmd_name: &[&str] = __dispatch_cmd;
+                    let __args: &[&str] = __dispatch_args;
+                    #block
+                }}
+            }
+            VariantKind::Struct(fields) => {
+                let ident = variant.ident;
+
+                let name_lit = variant.attrs.name.clone().unwrap_or_else(|| {
+                    syn::LitStr::new(&default_variant_name(variant.ident), variant.ident.span())
+                });
+
+                let variant_attrs =
+                    variant_type_attrs(type_attrs, &variant.attrs, name_lit, variant.ident.span());
+                let (parsed, skipped) = collect_named_fields(errors, fields);
+                let ctor = quote! { #name::#ident };
+                let block = from_args_parse_block(errors, &variant_attrs, &parsed, &skipped, &ctor);
+
+                quote! {{
+                    let __cmd_name: &[&str] = __dispatch_cmd;
+                    let __args: &[&str] = __dispatch_args;
+                    #block
+                }}
+            }
+        }
+    };
+
+    // The body that redacts the matched variant, evaluating to
+    // `Result<Vec<String>, argh::EarlyExit>`.
+    let redact_body = |variant: &Variant<'_>| -> TokenStream {
+        match &variant.kind {
+            VariantKind::Delegated(ty) => quote! {
+                <#ty as argh::FromArgs>::redact_arg_values(__dispatch_cmd, __dispatch_args)
+            },
+            VariantKind::Unit => {
+                let name_lit = variant.attrs.name.clone().unwrap_or_else(|| {
+                    syn::LitStr::new(&default_variant_name(variant.ident), variant.ident.span())
+                });
+
+                let variant_attrs =
+                    variant_type_attrs(type_attrs, &variant.attrs, name_lit, variant.ident.span());
+                let block = redact_arg_values_parse_block(errors, &variant_attrs, &[]);
+
+                quote! {{
+                    let __cmd_name: &[&str] = __dispatch_cmd;
+                    let __args: &[&str] = __dispatch_args;
+                    #block
+                }}
+            }
+            VariantKind::Struct(fields) => {
+                let name_lit = variant.attrs.name.clone().unwrap_or_else(|| {
+                    syn::LitStr::new(&default_variant_name(variant.ident), variant.ident.span())
+                });
+
+                let variant_attrs =
+                    variant_type_attrs(type_attrs, &variant.attrs, name_lit, variant.ident.span());
+                let (parsed, _skipped) = collect_named_fields(errors, fields);
+                let block = redact_arg_values_parse_block(errors, &variant_attrs, &parsed);
+
+                quote! {{
+                    let __cmd_name: &[&str] = __dispatch_cmd;
+                    let __args: &[&str] = __dispatch_args;
+                    #block
+                }}
+            }
+        }
+    };
+
+    let from_args_arms = variants.iter().map(|variant| {
+        let info = info_expr(variant);
+        let body = from_args_body(variant);
+
+        quote! {
+            {
+                let __info: &argh::CommandInfo = #info;
+                if subcommand_name == __info.name
+                    || (*__info.short != '\0'
+                        && subcommand_name.len() == 1
+                        && subcommand_name.starts_with(*__info.short))
+                {
+                    return #body;
+                }
+            }
+        }
+    });
+
+    let redact_arms = variants.iter().map(|variant| {
+        let info = info_expr(variant);
+        let body = redact_body(variant);
+
+        quote! {
+            {
+                let __info: &argh::CommandInfo = #info;
+                if subcommand_name == __info.name
+                    || (*__info.short != '\0'
+                        && subcommand_name.len() == 1
+                        && subcommand_name.starts_with(*__info.short))
+                {
+                    return #body;
+                }
+            }
+        }
+    });
+
+    let commands_list = variants.iter().map(info_expr);
 
-    let name_repeating = std::iter::repeat(name.clone());
-    let variant_ty = variants.iter().map(|x| x.ty).collect::<Vec<_>>();
-    let variant_names = variants.iter().map(|x| x.name).collect::<Vec<_>>();
     let dynamic_from_args =
         dynamic_type_and_variant.as_ref().map(|(dynamic_type, dynamic_variant)| {
             quote! {
                 if let Some(result) = <#dynamic_type as argh::DynamicSubCommand>::try_from_args(
-                    command_name, args) {
+                    __dispatch_cmd, __dispatch_args) {
                     return result.map(#name::#dynamic_variant);
                 }
             }
         });
+
     let dynamic_redact_arg_values = dynamic_type_and_variant.as_ref().map(|(dynamic_type, _)| {
         quote! {
             if let Some(result) = <#dynamic_type as argh::DynamicSubCommand>::try_redact_arg_values(
-                command_name, args) {
+                __dispatch_cmd, __dispatch_args) {
                 return result;
             }
         }
     });
+
     let dynamic_commands = dynamic_type_and_variant.as_ref().map(|(dynamic_type, _)| {
         quote! {
             fn dynamic_commands() -> &'static [&'static argh::CommandInfo] {
@@ -1100,29 +1465,56 @@ fn impl_from_args_enum(
         }
     });
 
+    // Compute `subcommand_name`, `__dispatch_cmd`, and `__dispatch_args` from the
+    // entrypoint arguments. Nested enums receive the subcommand name already
+    // appended to `command_name`; top-level enums must read it from `args`.
+    let dispatch_prelude = if is_top_level {
+        quote! {
+            let subcommand_name = if let Some(subcommand_name) = args.first() {
+                *subcommand_name
+            } else {
+                return ::core::result::Result::Err(argh::EarlyExit::from("no subcommand name".to_owned()));
+            };
+            let mut __dispatch_cmd_buf = command_name.to_owned();
+            __dispatch_cmd_buf.push(subcommand_name);
+            let __dispatch_cmd: &[&str] = &__dispatch_cmd_buf;
+            let __dispatch_args: &[&str] = &args[1..];
+        }
+    } else {
+        quote! {
+            let subcommand_name = if let Some(subcommand_name) = command_name.last() {
+                *subcommand_name
+            } else {
+                return ::core::result::Result::Err(argh::EarlyExit::from("no subcommand name".to_owned()));
+            };
+            let __dispatch_cmd: &[&str] = command_name;
+            let __dispatch_args: &[&str] = args;
+        }
+    };
+
+    let (redact_arms, from_args_arms) =
+        (redact_arms.collect::<Vec<_>>(), from_args_arms.collect::<Vec<_>>());
+
+    let top_level_impl = if is_top_level {
+        let (impl_generics, ty_generics, where_clause) = generic_args.split_for_impl();
+        quote! {
+            #[automatically_derived]
+            impl #impl_generics argh::TopLevelCommand for #name #ty_generics #where_clause {}
+        }
+    } else {
+        TokenStream::new()
+    };
+
     let (impl_generics, ty_generics, where_clause) = generic_args.split_for_impl();
     quote! {
         impl #impl_generics argh::FromArgs for #name #ty_generics #where_clause {
             fn from_args(command_name: &[&str], args: &[&str])
                 -> std::result::Result<Self, argh::EarlyExit>
             {
-                let subcommand_name = if let Some(subcommand_name) = command_name.last() {
-                    *subcommand_name
-                } else {
-                    return ::core::result::Result::Err(argh::EarlyExit::from("no subcommand name".to_owned()));
-                };
+                #![allow(clippy::unwrap_in_result)]
+                #dispatch_prelude
 
-                #(
-                    if subcommand_name == <#variant_ty as argh::SubCommand>::COMMAND.name
-                        || (*<#variant_ty as argh::SubCommand>::COMMAND.short != '\0'
-                            && subcommand_name.len() == 1
-                            && subcommand_name.starts_with(*<#variant_ty as argh::SubCommand>::COMMAND.short))
-                    {
-                        return ::core::result::Result::Ok(#name_repeating::#variant_names(
-                            <#variant_ty as argh::FromArgs>::from_args(command_name, args)?
-                        ));
-                    }
-                )*
+                #( #from_args_arms )*
 
                 #dynamic_from_args
 
@@ -1130,21 +1522,9 @@ fn impl_from_args_enum(
             }
 
             fn redact_arg_values(command_name: &[&str], args: &[&str]) -> std::result::Result<Vec<String>, argh::EarlyExit> {
-                let subcommand_name = if let Some(subcommand_name) = command_name.last() {
-                    *subcommand_name
-                } else {
-                    return ::core::result::Result::Err(argh::EarlyExit::from("no subcommand name".to_owned()));
-                };
+                #dispatch_prelude
 
-                #(
-                    if subcommand_name == <#variant_ty as argh::SubCommand>::COMMAND.name
-                        || (*<#variant_ty as argh::SubCommand>::COMMAND.short != '\0'
-                            && subcommand_name.len() == 1
-                            && subcommand_name.starts_with(*<#variant_ty as argh::SubCommand>::COMMAND.short))
-                    {
-                        return <#variant_ty as argh::FromArgs>::redact_arg_values(command_name, args);
-                    }
-                )*
+                #( #redact_arms )*
 
                 #dynamic_redact_arg_values
 
@@ -1154,67 +1534,13 @@ fn impl_from_args_enum(
 
         impl #impl_generics argh::SubCommands for #name #ty_generics #where_clause {
             const COMMANDS: &'static [&'static argh::CommandInfo] = &[#(
-                <#variant_ty as argh::SubCommand>::COMMAND,
+                #commands_list,
             )*];
 
             #dynamic_commands
         }
-    }
-}
 
-/// Returns `Some(Bar)` if the field is a single-field unnamed variant like `Foo(Bar)`.
-/// Otherwise, generates an error.
-fn enum_only_single_field_unnamed_variants<'a>(
-    errors: &Errors,
-    variant_fields: &'a syn::Fields,
-) -> Option<&'a syn::Type> {
-    macro_rules! with_enum_suggestion {
-        ($help_text:literal) => {
-            concat!(
-                $help_text,
-                "\nInstead, use a variant with a single unnamed field for each subcommand:\n",
-                "    enum MyCommandEnum {\n",
-                "        SubCommandOne(SubCommandOne),\n",
-                "        SubCommandTwo(SubCommandTwo),\n",
-                "    }",
-            )
-        };
-    }
-
-    match variant_fields {
-        syn::Fields::Named(fields) => {
-            errors.err(
-                fields,
-                with_enum_suggestion!(
-                    "`#![derive(FromArgs)]` `enum`s do not support variants with named fields."
-                ),
-            );
-            None
-        }
-        syn::Fields::Unit => {
-            errors.err(
-                variant_fields,
-                with_enum_suggestion!(
-                    "`#![derive(FromArgs)]` does not support `enum`s with no variants."
-                ),
-            );
-            None
-        }
-        syn::Fields::Unnamed(fields) => {
-            if fields.unnamed.len() != 1 {
-                errors.err(
-                    fields,
-                    with_enum_suggestion!(
-                        "`#![derive(FromArgs)]` `enum` variants must only contain one field."
-                    ),
-                );
-                None
-            } else {
-                // `unwrap` is okay because of the length check above.
-                let first_field = fields.unnamed.first().unwrap();
-                Some(&first_field.ty)
-            }
-        }
+        #top_level_impl
     }
 }
 
diff --git a/argh_derive/src/parse_attrs.rs b/argh_derive/src/parse_attrs.rs
index ca7c1c0..9180d2b 100644
--- a/argh_derive/src/parse_attrs.rs
+++ b/argh_derive/src/parse_attrs.rs
@@ -2,13 +2,12 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+use std::collections::hash_map::{Entry, HashMap};
+
+use proc_macro2::Span;
 use syn::{parse::Parser, punctuated::Punctuated};
 
-use {
-    crate::errors::Errors,
-    proc_macro2::Span,
-    std::collections::hash_map::{Entry, HashMap},
-};
+use crate::errors::Errors;
 
 /// Attributes applied to a field of a `#![derive(FromArgs)]` struct.
 #[derive(Default)]
@@ -23,6 +22,7 @@ pub struct FieldAttrs {
     pub greedy: Option<syn::Path>,
     pub hidden_help: bool,
     pub usage: bool,
+    pub skip: bool,
 }
 
 /// The purpose of a particular field on a `#![derive(FromArgs)]` struct.
@@ -57,6 +57,7 @@ pub struct FieldType {
 ///
 /// Defaults to the docstring if one is present, or `#[argh(description = "...")]`
 /// if one is provided.
+#[derive(Clone)]
 pub struct Description {
     /// Whether the description was an explicit annotation or whether it was a doc string.
     pub explicit: bool,
@@ -129,13 +130,15 @@ impl FieldAttrs {
                     this.hidden_help = true;
                 } else if name.is_ident("usage") {
                     this.usage = true;
+                } else if name.is_ident("skip") {
+                    this.skip = true;
                 } else {
                     errors.err(
                         &meta,
                         concat!(
                             "Invalid field-level `argh` attribute\n",
                             "Expected one of: `arg_name`, `default`, `description`, `from_str_fn`, `greedy`, ",
-                            "`long`, `option`, `short`, `subcommand`, `switch`, `hidden_help`, `usage`",
+                            "`long`, `option`, `short`, `skip`, `subcommand`, `switch`, `hidden_help`, `usage`",
                         ),
                     );
                 }
@@ -469,7 +472,10 @@ impl TypeAttrs {
 /// Represents a `FromArgs` enum variant's attributes.
 #[derive(Default)]
 pub struct VariantAttrs {
+    pub name: Option<syn::LitStr>,
+    pub short: Option<syn::LitChar>,
     pub is_dynamic: Option<syn::Path>,
+    pub description: Option<Description>,
 }
 
 impl VariantAttrs {
@@ -477,13 +483,17 @@ impl VariantAttrs {
     pub fn parse(errors: &Errors, variant: &syn::Variant) -> Self {
         let mut this = VariantAttrs::default();
 
-        let fields = match &variant.fields {
-            syn::Fields::Named(fields) => Some(&fields.named),
+        // For delegated (single unnamed field) variants and unit variants,
+        // any`#[argh(...)]` attribute on the inner field is meaningless.
+        // For struct-style (named field) variants, field-level attributes
+        // describe the subcommand's arguments and are handled elsewhere,
+        // so they must not be flagged here.
+        let inner_fields = match &variant.fields {
+            syn::Fields::Unit | syn::Fields::Named(_) => None,
             syn::Fields::Unnamed(fields) => Some(&fields.unnamed),
-            syn::Fields::Unit => None,
         };
 
-        for field in fields.into_iter().flatten() {
+        for field in inner_fields.into_iter().flatten() {
             for attr in &field.attrs {
                 if is_argh_attr(attr) {
                     err_unused_enum_attr(errors, attr);
@@ -492,6 +502,11 @@ impl VariantAttrs {
         }
 
         for attr in &variant.attrs {
+            if is_doc_attr(attr) {
+                parse_attr_doc(errors, attr, &mut this.description);
+                continue;
+            }
+
             let ml = if let Some(ml) = argh_attr_to_meta_list(errors, attr) {
                 ml
             } else {
@@ -506,11 +521,36 @@ impl VariantAttrs {
                     } else {
                         this.is_dynamic = errors.expect_meta_word(&meta).cloned();
                     }
+                } else if name.is_ident("subcommand") {
+                    // Accepted (and ignored): each variant is implicitly a
+                    // subcommand, so `#[argh(subcommand)]` on a variant is a no-op.
+                    let _ = errors.expect_meta_word(&meta);
+                } else if name.is_ident("name") {
+                    if let Some(m) = errors.expect_meta_name_value(&meta) {
+                        parse_attr_single_string(errors, m, "name", &mut this.name);
+                    }
+                } else if name.is_ident("short") {
+                    if let Some(m) = errors.expect_meta_name_value(&meta) {
+                        if let Some(first) = &this.short {
+                            errors.duplicate_attrs("short", first, m);
+                        } else if let Some(lit_char) = errors.expect_lit_char(&m.value) {
+                            this.short = Some(lit_char.clone());
+
+                            if !lit_char.value().is_ascii() {
+                                errors.err(lit_char, "Short names must be ASCII");
+                            }
+                        }
+                    }
+                } else if name.is_ident("description") {
+                    if let Some(m) = errors.expect_meta_name_value(&meta) {
+                        parse_attr_description(errors, m, &mut this.description);
+                    }
                 } else {
                     errors.err(
                         &meta,
                         "Invalid variant-level `argh` attribute\n\
-                         Subcommand variants can only have the #[argh(dynamic)] attribute.",
+                         Subcommand variants can only have the `dynamic`, \
+                         `name`, `short`, and `subcommand` attributes.",
                     );
                 }
             }
@@ -573,9 +613,10 @@ fn check_option_description(errors: &Errors, desc: &str, span: Span) {
 
 #[test]
 fn test_initialisms() {
+    use std::panic::Location;
+
     use proc_macro2::TokenStream;
     use quote::ToTokens;
-    use std::panic::Location;
 
     #[track_caller]
     fn check(s: &str, should_succeed: bool) {
@@ -701,34 +742,19 @@ fn parse_attr_description(errors: &Errors, m: &syn::MetaNameValue, slot: &mut Op
     *slot = Some(Description { explicit: true, content: lit_str.clone() });
 }
 
-/// Checks that a `#![derive(FromArgs)]` enum has an `#[argh(subcommand)]`
-/// attribute and that it does not have any other type-level `#[argh(...)]` attributes.
-pub fn check_enum_type_attrs(errors: &Errors, type_attrs: &TypeAttrs, type_span: &Span) {
-    let TypeAttrs {
-        is_subcommand,
-        name,
-        short,
-        description,
-        examples,
-        notes,
-        error_codes,
-        help_triggers,
-        usage,
-    } = type_attrs;
-
-    // Ensure that `#[argh(subcommand)]` is present.
-    if is_subcommand.is_none() {
-        errors.err_span(
-            *type_span,
-            concat!(
-                "`#![derive(FromArgs)]` on `enum`s can only be used to enumerate subcommands.\n",
-                "To enumerate subcommands, add `#[argh(subcommand)]` to the `enum` declaration.\n",
-                "To declare a choice `enum` instead, use `#![derive(FromArgValue)]`."
-            ),
-        );
-    }
-
-    // Error on all other type-level attributes.
+/// Checks that a `#![derive(FromArgs)]` enum does not carry type-level
+/// `#[argh(...)]` attributes that are meaningless for a subcommand-dispatching
+/// enum.
+///
+/// An enum may optionally be marked `#[argh(subcommand)]` (making it a nested
+/// subcommand dispatcher). Without that marker it is treated as a top-level
+/// command. In either case, `help_triggers` and a description (from a doc
+/// comment) are permitted; all other attributes are rejected.
+pub fn check_enum_type_attrs(errors: &Errors, type_attrs: &TypeAttrs, _span: &Span) {
+    let TypeAttrs { name, short, description, examples, notes, error_codes, usage, .. } =
+        type_attrs;
+
+    // Error on unsupported type-level attributes.
     if let Some(name) = name {
         err_unused_enum_attr(errors, name);
     }
@@ -749,11 +775,6 @@ pub fn check_enum_type_attrs(errors: &Errors, type_attrs: &TypeAttrs, type_span:
     if let Some(err_code) = error_codes.first() {
         err_unused_enum_attr(errors, &err_code.0);
     }
-    if let Some(triggers) = help_triggers {
-        if let Some(trigger) = triggers.first() {
-            err_unused_enum_attr(errors, trigger);
-        }
-    }
     if let Some(usage) = usage {
         err_unused_enum_attr(errors, usage);
     }