diff --git a/src/executor.rs b/src/executor.rs
index b3e16e44..5353f60d 100644
--- a/src/executor.rs
+++ b/src/executor.rs
@@ -3,7 +3,6 @@ use std::ffi::{OsStr, OsString};
 use std::path::Path;
 use std::process::{Child, Command, ExitStatus, Output};
 
-use color_eyre::eyre;
 use color_eyre::eyre::Result;
 use tracing::debug;
 
@@ -238,7 +237,7 @@ impl CommandExt for Executor {
     // TODO: It might be nice to make `output_checked_with` return something that has a
     // variant for wet/dry runs.
 
-    fn output_checked_with(&mut self, succeeded: impl Fn(&Output) -> Result<(), ()>) -> eyre::Result<Output> {
+    fn output_checked_with(&mut self, succeeded: impl Fn(&Output) -> Result<(), ()>) -> Result<Output> {
         match self {
             Executor::Wet(c) => c.output_checked_with(succeeded),
             Executor::Dry(c) => {
@@ -248,7 +247,7 @@ impl CommandExt for Executor {
         }
     }
 
-    fn status_checked_with(&mut self, succeeded: impl Fn(ExitStatus) -> Result<(), ()>) -> eyre::Result<()> {
+    fn status_checked_with(&mut self, succeeded: impl Fn(ExitStatus) -> Result<(), ()>) -> Result<()> {
         match self {
             Executor::Wet(c) => c.status_checked_with(succeeded),
             Executor::Dry(c) => {
@@ -258,7 +257,7 @@ impl CommandExt for Executor {
         }
     }
 
-    fn spawn_checked(&mut self) -> eyre::Result<Self::Child> {
+    fn spawn_checked(&mut self) -> Result<Self::Child> {
         self.spawn()
     }
 }
diff --git a/src/main.rs b/src/main.rs
index 1463fa37..5ef1a599 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -54,13 +54,13 @@ fn run() -> Result<()> {
 
     if let Some(shell) = opt.gen_completion {
         let cmd = &mut CommandLineArgs::command();
-        clap_complete::generate(shell, cmd, clap::crate_name!(), &mut std::io::stdout());
+        clap_complete::generate(shell, cmd, clap::crate_name!(), &mut io::stdout());
         return Ok(());
     }
 
     if opt.gen_manpage {
         let man = clap_mangen::Man::new(CommandLineArgs::command());
-        man.render(&mut std::io::stdout())?;
+        man.render(&mut io::stdout())?;
         return Ok(());
     }
 
@@ -79,14 +79,14 @@ fn run() -> Result<()> {
     };
 
     if opt.show_config_reference() {
-        print!("{}", crate::config::EXAMPLE_CONFIG);
+        print!("{}", config::EXAMPLE_CONFIG);
         return Ok(());
     }
 
     let config = Config::load(opt)?;
-    terminal::set_title(config.set_title());
-    terminal::display_time(config.display_time());
-    terminal::set_desktop_notifications(config.notify_each_step());
+    set_title(config.set_title());
+    display_time(config.display_time());
+    set_desktop_notifications(config.notify_each_step());
 
     debug!("Version: {}", crate_version!());
     debug!("OS: {}", env!("TARGET"));
@@ -166,7 +166,7 @@ fn run() -> Result<()> {
     if let Some(topgrades) = config.remote_topgrades() {
         for remote_topgrade in topgrades.iter().filter(|t| config.should_execute_remote(t)) {
             runner.execute(Step::Remotes, format!("Remote ({remote_topgrade})"), || {
-                remote::ssh::ssh_step(&ctx, remote_topgrade)
+                ssh::ssh_step(&ctx, remote_topgrade)
             })?;
         }
     }
@@ -513,7 +513,7 @@ fn run() -> Result<()> {
     let failed = post_command_failed || runner.report().data().iter().any(|(_, result)| result.failed());
 
     if !config.skip_notify() {
-        terminal::notify_desktop(
+        notify_desktop(
             format!(
                 "Topgrade finished {}",
                 if failed { "with errors" } else { "successfully" }
diff --git a/src/steps/generic.rs b/src/steps/generic.rs
index 6c89f59c..386d057d 100644
--- a/src/steps/generic.rs
+++ b/src/steps/generic.rs
@@ -28,7 +28,7 @@ pub fn run_cargo_update(ctx: &ExecutionContext) -> Result<()> {
         .map(PathBuf::from)
         .unwrap_or_else(|| HOME_DIR.join(".cargo"))
         .require()?;
-    utils::require("cargo").or_else(|_| {
+    require("cargo").or_else(|_| {
         require_option(
             cargo_dir.join("bin/cargo").if_exists(),
             String::from("No cargo detected"),
@@ -42,7 +42,7 @@ pub fn run_cargo_update(ctx: &ExecutionContext) -> Result<()> {
     }
 
     print_separator("Cargo");
-    let cargo_update = utils::require("cargo-install-update")
+    let cargo_update = require("cargo-install-update")
         .ok()
         .or_else(|| cargo_dir.join("bin/cargo-install-update").if_exists());
     let cargo_update = match cargo_update {
@@ -60,7 +60,7 @@ pub fn run_cargo_update(ctx: &ExecutionContext) -> Result<()> {
         .status_checked()?;
 
     if ctx.config().cleanup() {
-        let cargo_cache = utils::require("cargo-cache")
+        let cargo_cache = require("cargo-cache")
             .ok()
             .or_else(|| cargo_dir.join("bin/cargo-cache").if_exists());
         match cargo_cache {
@@ -78,14 +78,14 @@ pub fn run_cargo_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_flutter_upgrade(ctx: &ExecutionContext) -> Result<()> {
-    let flutter = utils::require("flutter")?;
+    let flutter = require("flutter")?;
 
     print_separator("Flutter");
     ctx.run_type().execute(flutter).arg("upgrade").status_checked()
 }
 
 pub fn run_gem(ctx: &ExecutionContext) -> Result<()> {
-    let gem = utils::require("gem")?;
+    let gem = require("gem")?;
     HOME_DIR.join(".gem").require()?;
 
     print_separator("Gems");
@@ -113,7 +113,7 @@ pub fn run_rubygems(ctx: &ExecutionContext) -> Result<()> {
             .args(["update", "--system"])
             .status_checked()?;
     } else if let Some(sudo) = &ctx.sudo() {
-        if !std::path::Path::new("/usr/lib/ruby/vendor_ruby/rubygems/defaults/operating_system.rb").exists() {
+        if !Path::new("/usr/lib/ruby/vendor_ruby/rubygems/defaults/operating_system.rb").exists() {
             ctx.run_type()
                 .execute(sudo)
                 .arg("-EH")
@@ -128,7 +128,7 @@ pub fn run_rubygems(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_haxelib_update(ctx: &ExecutionContext) -> Result<()> {
-    let haxelib = utils::require("haxelib")?;
+    let haxelib = require("haxelib")?;
 
     let haxelib_dir =
         PathBuf::from(std::str::from_utf8(&Command::new(&haxelib).arg("config").output_checked()?.stdout)?.trim())
@@ -153,7 +153,7 @@ pub fn run_haxelib_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_sheldon(ctx: &ExecutionContext) -> Result<()> {
-    let sheldon = utils::require("sheldon")?;
+    let sheldon = require("sheldon")?;
 
     print_separator("Sheldon");
 
@@ -164,7 +164,7 @@ pub fn run_sheldon(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_fossil(ctx: &ExecutionContext) -> Result<()> {
-    let fossil = utils::require("fossil")?;
+    let fossil = require("fossil")?;
 
     print_separator("Fossil");
 
@@ -172,7 +172,7 @@ pub fn run_fossil(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_micro(ctx: &ExecutionContext) -> Result<()> {
-    let micro = utils::require("micro")?;
+    let micro = require("micro")?;
 
     print_separator("micro");
 
@@ -198,7 +198,7 @@ pub fn run_micro(ctx: &ExecutionContext) -> Result<()> {
     target_os = "dragonfly"
 )))]
 pub fn run_apm(ctx: &ExecutionContext) -> Result<()> {
-    let apm = utils::require("apm")?;
+    let apm = require("apm")?;
 
     print_separator("Atom Package Manager");
 
@@ -209,14 +209,14 @@ pub fn run_apm(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_rustup(ctx: &ExecutionContext) -> Result<()> {
-    let rustup = utils::require("rustup")?;
+    let rustup = require("rustup")?;
 
     print_separator("rustup");
     ctx.run_type().execute(rustup).arg("update").status_checked()
 }
 
 pub fn run_juliaup(ctx: &ExecutionContext) -> Result<()> {
-    let juliaup = utils::require("juliaup")?;
+    let juliaup = require("juliaup")?;
 
     print_separator("juliaup");
 
@@ -231,7 +231,7 @@ pub fn run_juliaup(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_choosenim(ctx: &ExecutionContext) -> Result<()> {
-    let choosenim = utils::require("choosenim")?;
+    let choosenim = require("choosenim")?;
 
     print_separator("choosenim");
     let run_type = ctx.run_type();
@@ -241,7 +241,7 @@ pub fn run_choosenim(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_krew_upgrade(ctx: &ExecutionContext) -> Result<()> {
-    let krew = utils::require("kubectl-krew")?;
+    let krew = require("kubectl-krew")?;
 
     print_separator("Krew");
 
@@ -249,7 +249,7 @@ pub fn run_krew_upgrade(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_gcloud_components_update(ctx: &ExecutionContext) -> Result<()> {
-    let gcloud = utils::require("gcloud")?;
+    let gcloud = require("gcloud")?;
 
     if gcloud.starts_with("/snap") {
         Ok(())
@@ -264,7 +264,7 @@ pub fn run_gcloud_components_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_jetpack(ctx: &ExecutionContext) -> Result<()> {
-    let jetpack = utils::require("jetpack")?;
+    let jetpack = require("jetpack")?;
 
     print_separator("Jetpack");
 
@@ -275,7 +275,7 @@ pub fn run_jetpack(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_rtcl(ctx: &ExecutionContext) -> Result<()> {
-    let rupdate = utils::require("rupdate")?;
+    let rupdate = require("rupdate")?;
 
     print_separator("rtcl");
 
@@ -283,7 +283,7 @@ pub fn run_rtcl(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_opam_update(ctx: &ExecutionContext) -> Result<()> {
-    let opam = utils::require("opam")?;
+    let opam = require("opam")?;
 
     print_separator("OCaml Package Manager");
 
@@ -298,7 +298,7 @@ pub fn run_opam_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_vcpkg_update(ctx: &ExecutionContext) -> Result<()> {
-    let vcpkg = utils::require("vcpkg")?;
+    let vcpkg = require("vcpkg")?;
     print_separator("vcpkg");
 
     #[cfg(unix)]
@@ -321,14 +321,14 @@ pub fn run_vcpkg_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_pipx_update(ctx: &ExecutionContext) -> Result<()> {
-    let pipx = utils::require("pipx")?;
+    let pipx = require("pipx")?;
     print_separator("pipx");
 
     ctx.run_type().execute(pipx).arg("upgrade-all").status_checked()
 }
 
 pub fn run_conda_update(ctx: &ExecutionContext) -> Result<()> {
-    let conda = utils::require("conda")?;
+    let conda = require("conda")?;
 
     let output = Command::new("conda")
         .args(["config", "--show", "auto_activate_base"])
@@ -349,7 +349,7 @@ pub fn run_conda_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_mamba_update(ctx: &ExecutionContext) -> Result<()> {
-    let mamba = utils::require("mamba")?;
+    let mamba = require("mamba")?;
 
     let output = Command::new("mamba")
         .args(["config", "--show", "auto_activate_base"])
@@ -370,7 +370,7 @@ pub fn run_mamba_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_pip3_update(ctx: &ExecutionContext) -> Result<()> {
-    let python3 = utils::require("python3")?;
+    let python3 = require("python3")?;
     Command::new(&python3)
         .args(["-m", "pip"])
         .output_checked_utf8()
@@ -392,7 +392,7 @@ pub fn run_pip3_update(ctx: &ExecutionContext) -> Result<()> {
         })?;
 
     print_separator("pip3");
-    if std::env::var("VIRTUAL_ENV").is_ok() {
+    if env::var("VIRTUAL_ENV").is_ok() {
         print_warning("This step is will be skipped when running inside a virtual environment");
         return Err(SkipStep("Does not run inside a virtual environment".to_string()).into());
     }
@@ -456,21 +456,21 @@ pub fn run_pipupgrade_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_stack_update(ctx: &ExecutionContext) -> Result<()> {
-    if utils::require("ghcup").is_ok() {
+    if require("ghcup").is_ok() {
         // `ghcup` is present and probably(?) being used to install `stack`.
         // Don't upgrade `stack`, let `ghcup` handle it. Per `ghcup install stack`:
         // !!! Additionally, you should upgrade stack only through ghcup and not use 'stack upgrade' !!!
         return Ok(());
     }
 
-    let stack = utils::require("stack")?;
+    let stack = require("stack")?;
     print_separator("stack");
 
     ctx.run_type().execute(stack).arg("upgrade").status_checked()
 }
 
 pub fn run_ghcup_update(ctx: &ExecutionContext) -> Result<()> {
-    let ghcup = utils::require("ghcup")?;
+    let ghcup = require("ghcup")?;
     print_separator("ghcup");
 
     ctx.run_type().execute(ghcup).arg("upgrade").status_checked()
@@ -485,8 +485,8 @@ pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
         }
     }
 
-    let tlmgr = utils::require("tlmgr")?;
-    let kpsewhich = utils::require("kpsewhich")?;
+    let tlmgr = require("tlmgr")?;
+    let kpsewhich = require("kpsewhich")?;
     let tlmgr_directory = {
         let mut d = PathBuf::from(
             &Command::new(kpsewhich)
@@ -520,7 +520,7 @@ pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_chezmoi_update(ctx: &ExecutionContext) -> Result<()> {
-    let chezmoi = utils::require("chezmoi")?;
+    let chezmoi = require("chezmoi")?;
     HOME_DIR.join(".local/share/chezmoi").require()?;
 
     print_separator("chezmoi");
@@ -529,7 +529,7 @@ pub fn run_chezmoi_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_myrepos_update(ctx: &ExecutionContext) -> Result<()> {
-    let myrepos = utils::require("mr")?;
+    let myrepos = require("mr")?;
     HOME_DIR.join(".mrconfig").require()?;
 
     print_separator("myrepos");
@@ -562,7 +562,7 @@ pub fn run_custom_command(name: &str, command: &str, ctx: &ExecutionContext) ->
 }
 
 pub fn run_composer_update(ctx: &ExecutionContext) -> Result<()> {
-    let composer = utils::require("composer")?;
+    let composer = require("composer")?;
     let composer_home = Command::new(&composer)
         .args(["global", "config", "--absolute", "--quiet", "home"])
         .output_checked_utf8()
@@ -607,7 +607,7 @@ pub fn run_composer_update(ctx: &ExecutionContext) -> Result<()> {
         let output: Utf8Output = output.try_into()?;
         print!("{}\n{}", output.stdout, output.stderr);
         if output.stdout.contains("valet") || output.stderr.contains("valet") {
-            if let Some(valet) = utils::which("valet") {
+            if let Some(valet) = which("valet") {
                 ctx.run_type().execute(valet).arg("install").status_checked()?;
             }
         }
@@ -617,7 +617,7 @@ pub fn run_composer_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_dotnet_upgrade(ctx: &ExecutionContext) -> Result<()> {
-    let dotnet = utils::require("dotnet")?;
+    let dotnet = require("dotnet")?;
 
     // Skip when the `dotnet tool list` subcommand fails.
     // (This is expected when a dotnet runtime is installed but no SDK.)
@@ -670,7 +670,7 @@ pub fn run_dotnet_upgrade(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_helix_grammars(ctx: &ExecutionContext) -> Result<()> {
-    utils::require("helix")?;
+    require("helix")?;
 
     print_separator("Helix");
 
@@ -690,7 +690,7 @@ pub fn run_helix_grammars(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_raco_update(ctx: &ExecutionContext) -> Result<()> {
-    let raco = utils::require("raco")?;
+    let raco = require("raco")?;
 
     print_separator("Racket Package Manager");
 
@@ -701,21 +701,21 @@ pub fn run_raco_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn bin_update(ctx: &ExecutionContext) -> Result<()> {
-    let bin = utils::require("bin")?;
+    let bin = require("bin")?;
 
     print_separator("Bin");
     ctx.run_type().execute(bin).arg("update").status_checked()
 }
 
 pub fn spicetify_upgrade(ctx: &ExecutionContext) -> Result<()> {
-    let spicetify = utils::require("spicetify")?;
+    let spicetify = require("spicetify")?;
 
     print_separator("Spicetify");
     ctx.run_type().execute(spicetify).arg("upgrade").status_checked()
 }
 
 pub fn run_ghcli_extensions_upgrade(ctx: &ExecutionContext) -> Result<()> {
-    let gh = utils::require("gh")?;
+    let gh = require("gh")?;
     let result = Command::new(&gh).args(["extensions", "list"]).output_checked_utf8();
     if result.is_err() {
         debug!("GH result {:?}", result);
@@ -730,7 +730,7 @@ pub fn run_ghcli_extensions_upgrade(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn update_julia_packages(ctx: &ExecutionContext) -> Result<()> {
-    let julia = utils::require("julia")?;
+    let julia = require("julia")?;
 
     print_separator("Julia Packages");
 
@@ -741,7 +741,7 @@ pub fn update_julia_packages(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_helm_repo_update(ctx: &ExecutionContext) -> Result<()> {
-    let helm = utils::require("helm")?;
+    let helm = require("helm")?;
 
     print_separator("Helm");
 
diff --git a/src/steps/os/linux.rs b/src/steps/os/linux.rs
index 14018ca4..53ed1d9b 100644
--- a/src/steps/os/linux.rs
+++ b/src/steps/os/linux.rs
@@ -40,7 +40,7 @@ pub enum Distribution {
 }
 
 impl Distribution {
-    fn parse_os_release(os_release: &ini::Ini) -> Result<Self> {
+    fn parse_os_release(os_release: &Ini) -> Result<Self> {
         let section = os_release.general_section();
         let id = section.get("ID");
         let variant: Option<Vec<&str>> = section.get("VARIANT").map(|s| s.split_whitespace().collect());
@@ -51,14 +51,14 @@ impl Distribution {
             Some("centos") | Some("rhel") | Some("ol") => Distribution::CentOS,
             Some("clear-linux-os") => Distribution::ClearLinux,
             Some("fedora") | Some("nobara") => {
-                if let Some(variant) = variant {
+                return if let Some(variant) = variant {
                     if variant.contains(&"Silverblue") {
-                        return Ok(Distribution::FedoraSilverblue);
+                        Ok(Distribution::FedoraSilverblue)
                     } else {
-                        return Ok(Distribution::Fedora);
-                    };
+                        Ok(Distribution::Fedora)
+                    }
                 } else {
-                    return Ok(Distribution::Fedora);
+                    Ok(Distribution::Fedora)
                 }
             }
 
@@ -81,11 +81,11 @@ impl Distribution {
                         return Ok(Distribution::CentOS);
                     } else if id_like.contains(&"suse") {
                         let id_variant = id.unwrap_or_default();
-                        if id_variant.contains("tumbleweed") {
-                            return Ok(Distribution::OpenSuseTumbleweed);
+                        return if id_variant.contains("tumbleweed") {
+                            Ok(Distribution::OpenSuseTumbleweed)
                         } else {
-                            return Ok(Distribution::Suse);
-                        }
+                            Ok(Distribution::Suse)
+                        };
                     } else if id_like.contains(&"arch") || id_like.contains(&"archlinux") {
                         return Ok(Distribution::Arch);
                     } else if id_like.contains(&"alpine") {
diff --git a/src/steps/os/unix.rs b/src/steps/os/unix.rs
index d8914005..746b10b0 100644
--- a/src/steps/os/unix.rs
+++ b/src/steps/os/unix.rs
@@ -2,10 +2,7 @@ use std::fs;
 use std::os::unix::fs::MetadataExt;
 use std::path::PathBuf;
 use std::process::Command;
-use std::{
-    env::{self, var},
-    path::Path,
-};
+use std::{env::var, path::Path};
 
 use crate::command::CommandExt;
 use crate::{Step, HOME_DIR};
@@ -229,7 +226,7 @@ pub fn run_fundle(ctx: &ExecutionContext) -> Result<()> {
 pub fn upgrade_gnome_extensions(ctx: &ExecutionContext) -> Result<()> {
     let gdbus = require("gdbus")?;
     require_option(
-        env::var("XDG_CURRENT_DESKTOP").ok().filter(|p| p.contains("GNOME")),
+        var("XDG_CURRENT_DESKTOP").ok().filter(|p| p.contains("GNOME")),
         "Desktop doest not appear to be gnome".to_string(),
     )?;
     let output = Command::new("gdbus")
@@ -407,7 +404,7 @@ pub fn run_nix(ctx: &ExecutionContext) -> Result<()> {
 
     run_type.execute(nix_channel).arg("--update").status_checked()?;
 
-    if std::path::Path::new(&manifest_json_path).exists() {
+    if Path::new(&manifest_json_path).exists() {
         run_type
             .execute(&nix)
             .arg("profile")
@@ -466,7 +463,7 @@ pub fn run_pearl(ctx: &ExecutionContext) -> Result<()> {
 pub fn run_sdkman(cleanup: bool, ctx: &ExecutionContext) -> Result<()> {
     let bash = require("bash")?;
 
-    let sdkman_init_path = env::var("SDKMAN_DIR")
+    let sdkman_init_path = var("SDKMAN_DIR")
         .map(PathBuf::from)
         .unwrap_or_else(|_| HOME_DIR.join(".sdkman"))
         .join("bin")
@@ -476,7 +473,7 @@ pub fn run_sdkman(cleanup: bool, ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("SDKMAN!");
 
-    let sdkman_config_path = env::var("SDKMAN_DIR")
+    let sdkman_config_path = var("SDKMAN_DIR")
         .map(PathBuf::from)
         .unwrap_or_else(|_| HOME_DIR.join(".sdkman"))
         .join("etc")