diff --git a/src/error.rs b/src/error.rs
index def711d7..13878721 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -10,10 +10,6 @@ pub enum TopgradeError {
     #[error("`{0}` failed: {1}")]
     ProcessFailedWithOutput(String, ExitStatus, String),
 
-    #[error("Sudo is required for this step")]
-    #[allow(dead_code)]
-    SudoRequired,
-
     #[error("Unknown Linux Distribution")]
     #[cfg(target_os = "linux")]
     UnknownLinuxDistribution,
diff --git a/src/execution_context.rs b/src/execution_context.rs
index b44dbcd2..3389d577 100644
--- a/src/execution_context.rs
+++ b/src/execution_context.rs
@@ -2,7 +2,7 @@
 use crate::executor::RunType;
 use crate::git::Git;
 use crate::sudo::Sudo;
-use crate::utils::require_option;
+use crate::utils::{require_option, REQUIRE_SUDO};
 use crate::{config::Config, executor::Executor};
 use color_eyre::eyre::Result;
 use std::path::Path;
@@ -31,7 +31,7 @@ impl<'a> ExecutionContext<'a> {
     }
 
     pub fn execute_elevated(&self, command: &Path, interactive: bool) -> Result<Executor> {
-        let sudo = require_option(self.sudo.clone(), "Sudo is required for this operation".into())?;
+        let sudo = require_option(self.sudo.as_ref(), REQUIRE_SUDO.to_string())?;
         Ok(sudo.execute_elevated(self, command, interactive))
     }
 
diff --git a/src/steps/generic.rs b/src/steps/generic.rs
index 88024f33..9aae4fb8 100644
--- a/src/steps/generic.rs
+++ b/src/steps/generic.rs
@@ -15,7 +15,7 @@ use crate::command::{CommandExt, Utf8Output};
 use crate::execution_context::ExecutionContext;
 use crate::executor::ExecutorOutput;
 use crate::terminal::{print_separator, shell};
-use crate::utils::{self, require, require_option, which, PathExt};
+use crate::utils::{self, require, require_option, which, PathExt, REQUIRE_SUDO};
 use crate::Step;
 use crate::HOME_DIR;
 use crate::{
@@ -112,7 +112,8 @@ pub fn run_rubygems(ctx: &ExecutionContext) -> Result<()> {
             .execute(gem)
             .args(["update", "--system"])
             .status_checked()?;
-    } else if let Some(sudo) = &ctx.sudo() {
+    } else {
+        let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
         if !Path::new("/usr/lib/ruby/vendor_ruby/rubygems/defaults/operating_system.rb").exists() {
             ctx.run_type()
                 .execute(sudo)
@@ -121,9 +122,8 @@ pub fn run_rubygems(ctx: &ExecutionContext) -> Result<()> {
                 .args(["update", "--system"])
                 .status_checked()?;
         }
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
     }
+
     Ok(())
 }
 
@@ -142,9 +142,8 @@ pub fn run_haxelib_update(ctx: &ExecutionContext) -> Result<()> {
     let mut command = if directory_writable {
         ctx.run_type().execute(&haxelib)
     } else {
-        let mut c = ctx
-            .run_type()
-            .execute(ctx.sudo().as_ref().ok_or(TopgradeError::SudoRequired)?);
+        let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+        let mut c = ctx.run_type().execute(sudo);
         c.arg(&haxelib);
         c
     };
@@ -310,9 +309,8 @@ pub fn run_vcpkg_update(ctx: &ExecutionContext) -> Result<()> {
     let mut command = if is_root_install {
         ctx.run_type().execute(&vcpkg)
     } else {
-        let mut c = ctx
-            .run_type()
-            .execute(ctx.sudo().as_ref().ok_or(TopgradeError::SudoRequired)?);
+        let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+        let mut c = ctx.run_type().execute(sudo);
         c.arg(&vcpkg);
         c
     };
@@ -510,9 +508,8 @@ pub fn run_tlmgr_update(ctx: &ExecutionContext) -> Result<()> {
     let mut command = if directory_writable {
         ctx.run_type().execute(&tlmgr)
     } else {
-        let mut c = ctx
-            .run_type()
-            .execute(ctx.sudo().as_ref().ok_or(TopgradeError::SudoRequired)?);
+        let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+        let mut c = ctx.run_type().execute(sudo);
         c.arg(&tlmgr);
         c
     };
@@ -592,8 +589,9 @@ pub fn run_composer_update(ctx: &ExecutionContext) -> Result<()> {
                 };
 
                 if has_update {
+                    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
                     ctx.run_type()
-                        .execute(ctx.sudo().as_ref().unwrap())
+                        .execute(sudo)
                         .arg(&composer)
                         .arg("self-update")
                         .status_checked()?;
@@ -676,14 +674,15 @@ pub fn run_helix_grammars(ctx: &ExecutionContext) -> Result<()> {
 
     print_separator("Helix");
 
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     ctx.run_type()
-        .execute(ctx.sudo().as_ref().ok_or(TopgradeError::SudoRequired)?)
+        .execute(sudo)
         .args(["helix", "--grammar", "fetch"])
         .status_checked()
         .with_context(|| "Failed to download helix grammars!")?;
 
     ctx.run_type()
-        .execute(ctx.sudo().as_ref().ok_or(TopgradeError::SudoRequired)?)
+        .execute(sudo)
         .args(["helix", "--grammar", "build"])
         .status_checked()
         .with_context(|| "Failed to build helix grammars!")?;
diff --git a/src/steps/node.rs b/src/steps/node.rs
index 7430bf33..e083f0c4 100644
--- a/src/steps/node.rs
+++ b/src/steps/node.rs
@@ -4,7 +4,7 @@ use std::os::unix::fs::MetadataExt;
 use std::path::PathBuf;
 use std::process::Command;
 
-use crate::utils::require_option;
+use crate::utils::{require_option, REQUIRE_SUDO};
 use crate::HOME_DIR;
 use color_eyre::eyre::Result;
 #[cfg(target_os = "linux")]
@@ -92,7 +92,7 @@ impl NPM {
     fn upgrade(&self, ctx: &ExecutionContext, use_sudo: bool) -> Result<()> {
         let args = ["update", self.global_location_arg()];
         if use_sudo {
-            let sudo = require_option(ctx.sudo().clone(), String::from("sudo is not installed"))?;
+            let sudo = require_option(ctx.sudo().clone(), REQUIRE_SUDO.to_string())?;
             ctx.run_type()
                 .execute(sudo)
                 .arg(&self.command)
@@ -156,7 +156,7 @@ impl Yarn {
         let args = ["global", "upgrade"];
 
         if use_sudo {
-            let sudo = require_option(ctx.sudo().clone(), String::from("sudo is not installed"))?;
+            let sudo = require_option(ctx.sudo().clone(), REQUIRE_SUDO.to_string())?;
             ctx.run_type()
                 .execute(sudo)
                 .arg(self.yarn.as_ref().unwrap_or(&self.command))
diff --git a/src/steps/os/dragonfly.rs b/src/steps/os/dragonfly.rs
index 8ab05190..60d64ad0 100644
--- a/src/steps/os/dragonfly.rs
+++ b/src/steps/os/dragonfly.rs
@@ -1,12 +1,12 @@
 use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
 use crate::terminal::print_separator;
-use crate::utils::require_option;
+use crate::utils::{require_option, REQUIRE_SUDO};
 use color_eyre::eyre::Result;
 use std::process::Command;
 
 pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), String::from("No sudo detected"))?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     print_separator("DragonFly BSD Packages");
     ctx.execute(sudo)
         .args(["/usr/local/sbin/pkg", "upgrade"])
@@ -14,11 +14,10 @@ pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn audit_packages(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
-        println!();
-        Command::new(sudo)
-            .args(["/usr/local/sbin/pkg", "audit", "-Fr"])
-            .status_checked()?;
-    }
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    println!();
+    Command::new(sudo)
+        .args(["/usr/local/sbin/pkg", "audit", "-Fr"])
+        .status_checked()?;
     Ok(())
 }
diff --git a/src/steps/os/freebsd.rs b/src/steps/os/freebsd.rs
index 55a50595..3f0b13b2 100644
--- a/src/steps/os/freebsd.rs
+++ b/src/steps/os/freebsd.rs
@@ -1,13 +1,13 @@
 use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
 use crate::terminal::print_separator;
-use crate::utils::require_option;
+use crate::utils::{require_option, REQUIRE_SUDO};
 use crate::Step;
 use color_eyre::eyre::Result;
 use std::process::Command;
 
 pub fn upgrade_freebsd(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), String::from("No sudo detected"))?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     print_separator("FreeBSD Update");
     ctx.run_type()
         .execute(sudo)
@@ -16,7 +16,7 @@ pub fn upgrade_freebsd(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), String::from("No sudo detected"))?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     print_separator("FreeBSD Packages");
 
     let mut command = ctx.run_type().execute(sudo);
@@ -29,11 +29,10 @@ pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn audit_packages(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
-        println!();
-        Command::new(sudo)
-            .args(["/usr/sbin/pkg", "audit", "-Fr"])
-            .status_checked()?;
-    }
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    println!();
+    Command::new(sudo)
+        .args(["/usr/sbin/pkg", "audit", "-Fr"])
+        .status_checked()?;
     Ok(())
 }
diff --git a/src/steps/os/linux.rs b/src/steps/os/linux.rs
index 41679546..13fc6bb6 100644
--- a/src/steps/os/linux.rs
+++ b/src/steps/os/linux.rs
@@ -9,8 +9,8 @@ use crate::command::CommandExt;
 use crate::error::{SkipStep, TopgradeError};
 use crate::execution_context::ExecutionContext;
 use crate::steps::os::archlinux;
-use crate::terminal::{print_separator, print_warning};
-use crate::utils::{require, require_option, which, PathExt};
+use crate::terminal::print_separator;
+use crate::utils::{require, require_option, which, PathExt, REQUIRE_SUDO};
 use crate::{Step, HOME_DIR};
 
 static OS_RELEASE_PATH: &str = "/etc/os-release";
@@ -158,7 +158,7 @@ impl Distribution {
 }
 
 fn update_bedrock(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), String::from("Sudo required"))?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
 
     ctx.run_type().execute(sudo).args(["brl", "update"]);
 
@@ -189,7 +189,7 @@ fn is_wsl() -> Result<bool> {
 
 fn upgrade_alpine_linux(ctx: &ExecutionContext) -> Result<()> {
     let apk = require("apk")?;
-    let sudo = ctx.sudo().as_ref().unwrap();
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
 
     ctx.run_type().execute(sudo).arg(&apk).arg("update").status_checked()?;
     ctx.run_type().execute(sudo).arg(&apk).arg("upgrade").status_checked()
@@ -204,28 +204,25 @@ fn upgrade_redhat(ctx: &ExecutionContext) -> Result<()> {
         }
     };
 
-    if let Some(sudo) = &ctx.sudo() {
-        let mut command = ctx.run_type().execute(sudo);
-        command
-            .arg(which("dnf").unwrap_or_else(|| Path::new("yum").to_path_buf()))
-            .arg(if ctx.config().redhat_distro_sync() {
-                "distro-sync"
-            } else {
-                "upgrade"
-            });
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    let mut command = ctx.run_type().execute(sudo);
+    command
+        .arg(which("dnf").unwrap_or_else(|| Path::new("yum").to_path_buf()))
+        .arg(if ctx.config().redhat_distro_sync() {
+            "distro-sync"
+        } else {
+            "upgrade"
+        });
 
-        if let Some(args) = ctx.config().dnf_arguments() {
-            command.args(args.split_whitespace());
-        }
-
-        if ctx.config().yes(Step::System) {
-            command.arg("-y");
-        }
-
-        command.status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
+    if let Some(args) = ctx.config().dnf_arguments() {
+        command.args(args.split_whitespace());
     }
+
+    if ctx.config().yes(Step::System) {
+        command.arg("-y");
+    }
+
+    command.status_checked()?;
     Ok(())
 }
 
@@ -238,116 +235,98 @@ fn upgrade_fedora_silverblue(ctx: &ExecutionContext) -> Result<()> {
 }
 
 fn upgrade_bedrock_strata(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
-        ctx.run_type().execute(sudo).args(["brl", "update"]).status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    ctx.run_type().execute(sudo).args(["brl", "update"]).status_checked()?;
 
     Ok(())
 }
 
 fn upgrade_suse(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
-        ctx.run_type()
-            .execute(sudo)
-            .args(["zypper", "refresh"])
-            .status_checked()?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    ctx.run_type()
+        .execute(sudo)
+        .args(["zypper", "refresh"])
+        .status_checked()?;
 
-        ctx.run_type()
-            .execute(sudo)
-            .arg("zypper")
-            .arg(if ctx.config().suse_dup() {
-                "dist-upgrade"
-            } else {
-                "update"
-            })
-            .status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
+    ctx.run_type()
+        .execute(sudo)
+        .arg("zypper")
+        .arg(if ctx.config().suse_dup() {
+            "dist-upgrade"
+        } else {
+            "update"
+        })
+        .status_checked()?;
 
     Ok(())
 }
 
 fn upgrade_opensuse_tumbleweed(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
-        ctx.run_type()
-            .execute(sudo)
-            .args(["zypper", "refresh"])
-            .status_checked()?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    ctx.run_type()
+        .execute(sudo)
+        .args(["zypper", "refresh"])
+        .status_checked()?;
 
-        ctx.run_type()
-            .execute(sudo)
-            .arg("zypper")
-            .arg("dist-upgrade")
-            .status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
+    ctx.run_type()
+        .execute(sudo)
+        .arg("zypper")
+        .arg("dist-upgrade")
+        .status_checked()?;
 
     Ok(())
 }
 
 fn upgrade_suse_micro(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
-        ctx.run_type()
-            .execute(sudo)
-            .args(["transactional-update", "dup"])
-            .status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    ctx.run_type()
+        .execute(sudo)
+        .args(["transactional-update", "dup"])
+        .status_checked()?;
 
     Ok(())
 }
 
 fn upgrade_openmandriva(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = &ctx.sudo() {
-        let mut command = ctx.run_type().execute(sudo);
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    let mut command = ctx.run_type().execute(sudo);
 
-        command.arg(&which("dnf").unwrap()).arg("upgrade");
+    command.arg(&which("dnf").unwrap()).arg("upgrade");
 
-        if let Some(args) = ctx.config().dnf_arguments() {
-            command.args(args.split_whitespace());
-        }
-
-        if ctx.config().yes(Step::System) {
-            command.arg("-y");
-        }
-
-        command.status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
+    if let Some(args) = ctx.config().dnf_arguments() {
+        command.args(args.split_whitespace());
     }
 
+    if ctx.config().yes(Step::System) {
+        command.arg("-y");
+    }
+
+    command.status_checked()?;
+
     Ok(())
 }
 fn upgrade_pclinuxos(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = &ctx.sudo() {
-        let mut command_update = ctx.run_type().execute(sudo);
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    let mut command_update = ctx.run_type().execute(sudo);
 
-        command_update.arg(&which("apt-get").unwrap()).arg("update");
+    command_update.arg(&which("apt-get").unwrap()).arg("update");
 
-        if let Some(args) = ctx.config().dnf_arguments() {
-            command_update.args(args.split_whitespace());
-        }
-
-        if ctx.config().yes(Step::System) {
-            command_update.arg("-y");
-        }
-
-        command_update.status_checked()?;
-
-        ctx.run_type()
-            .execute(sudo)
-            .arg(&which("apt-get").unwrap())
-            .arg("dist-upgrade")
-            .status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
+    if let Some(args) = ctx.config().dnf_arguments() {
+        command_update.args(args.split_whitespace());
     }
 
+    if ctx.config().yes(Step::System) {
+        command_update.arg("-y");
+    }
+
+    command_update.status_checked()?;
+
+    ctx.run_type()
+        .execute(sudo)
+        .arg(&which("apt-get").unwrap())
+        .arg("dist-upgrade")
+        .status_checked()?;
+
     Ok(())
 }
 
@@ -372,23 +351,20 @@ fn upgrade_vanilla(ctx: &ExecutionContext) -> Result<()> {
 }
 
 fn upgrade_void(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
-        let mut command = ctx.run_type().execute(sudo);
-        command.args(["xbps-install", "-Su", "xbps"]);
-        if ctx.config().yes(Step::System) {
-            command.arg("-y");
-        }
-        command.status_checked()?;
-
-        let mut command = ctx.run_type().execute(sudo);
-        command.args(["xbps-install", "-u"]);
-        if ctx.config().yes(Step::System) {
-            command.arg("-y");
-        }
-        command.status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    let mut command = ctx.run_type().execute(sudo);
+    command.args(["xbps-install", "-Su", "xbps"]);
+    if ctx.config().yes(Step::System) {
+        command.arg("-y");
     }
+    command.status_checked()?;
+
+    let mut command = ctx.run_type().execute(sudo);
+    command.args(["xbps-install", "-u"]);
+    if ctx.config().yes(Step::System) {
+        command.arg("-y");
+    }
+    command.status_checked()?;
 
     Ok(())
 }
@@ -396,45 +372,42 @@ fn upgrade_void(ctx: &ExecutionContext) -> Result<()> {
 fn upgrade_gentoo(ctx: &ExecutionContext) -> Result<()> {
     let run_type = ctx.run_type();
 
-    if let Some(sudo) = &ctx.sudo() {
-        if let Some(layman) = which("layman") {
-            run_type
-                .execute(sudo)
-                .arg(layman)
-                .args(["-s", "ALL"])
-                .status_checked()?;
-        }
-
-        println!("Syncing portage");
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    if let Some(layman) = which("layman") {
         run_type
             .execute(sudo)
-            .args(["emerge", "--sync"])
-            .args(
-                ctx.config()
-                    .emerge_sync_flags()
-                    .map(|s| s.split_whitespace().collect())
-                    .unwrap_or_else(|| vec!["-q"]),
-            )
+            .arg(layman)
+            .args(["-s", "ALL"])
             .status_checked()?;
-
-        if let Some(eix_update) = which("eix-update") {
-            run_type.execute(sudo).arg(eix_update).status_checked()?;
-        }
-
-        run_type
-            .execute(sudo)
-            .arg("emerge")
-            .args(
-                ctx.config()
-                    .emerge_update_flags()
-                    .map(|s| s.split_whitespace().collect())
-                    .unwrap_or_else(|| vec!["-uDNa", "--with-bdeps=y", "world"]),
-            )
-            .status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
     }
 
+    println!("Syncing portage");
+    run_type
+        .execute(sudo)
+        .args(["emerge", "--sync"])
+        .args(
+            ctx.config()
+                .emerge_sync_flags()
+                .map(|s| s.split_whitespace().collect())
+                .unwrap_or_else(|| vec!["-q"]),
+        )
+        .status_checked()?;
+
+    if let Some(eix_update) = which("eix-update") {
+        run_type.execute(sudo).arg(eix_update).status_checked()?;
+    }
+
+    run_type
+        .execute(sudo)
+        .arg("emerge")
+        .args(
+            ctx.config()
+                .emerge_update_flags()
+                .map(|s| s.split_whitespace().collect())
+                .unwrap_or_else(|| vec!["-uDNa", "--with-bdeps=y", "world"]),
+        )
+        .status_checked()?;
+
     Ok(())
 }
 
@@ -469,42 +442,39 @@ fn upgrade_debian(ctx: &ExecutionContext) -> Result<()> {
         return Ok(());
     }
 
-    if let Some(sudo) = &ctx.sudo() {
-        if !is_nala {
-            ctx.run_type()
-                .execute(sudo)
-                .arg(&apt)
-                .arg("update")
-                .status_checked_with_codes(&[0, 100])?;
-        }
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    if !is_nala {
+        ctx.run_type()
+            .execute(sudo)
+            .arg(&apt)
+            .arg("update")
+            .status_checked_with_codes(&[0, 100])?;
+    }
+
+    let mut command = ctx.run_type().execute(sudo);
+    command.arg(&apt);
+    if is_nala {
+        command.arg("upgrade");
+    } else {
+        command.arg("dist-upgrade");
+    };
+    if ctx.config().yes(Step::System) {
+        command.arg("-y");
+    }
+    if let Some(args) = ctx.config().apt_arguments() {
+        command.args(args.split_whitespace());
+    }
+    command.status_checked()?;
+
+    if ctx.config().cleanup() {
+        ctx.run_type().execute(sudo).arg(&apt).arg("clean").status_checked()?;
 
         let mut command = ctx.run_type().execute(sudo);
-        command.arg(&apt);
-        if is_nala {
-            command.arg("upgrade");
-        } else {
-            command.arg("dist-upgrade");
-        };
+        command.arg(&apt).arg("autoremove");
         if ctx.config().yes(Step::System) {
             command.arg("-y");
         }
-        if let Some(args) = ctx.config().apt_arguments() {
-            command.args(args.split_whitespace());
-        }
         command.status_checked()?;
-
-        if ctx.config().cleanup() {
-            ctx.run_type().execute(sudo).arg(&apt).arg("clean").status_checked()?;
-
-            let mut command = ctx.run_type().execute(sudo);
-            command.arg(&apt).arg("autoremove");
-            if ctx.config().yes(Step::System) {
-                command.arg("-y");
-            }
-            command.status_checked()?;
-        }
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
     }
 
     Ok(())
@@ -526,14 +496,11 @@ pub fn run_deb_get(ctx: &ExecutionContext) -> Result<()> {
 }
 
 fn upgrade_solus(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
-        ctx.run_type()
-            .execute(sudo)
-            .args(["eopkg", "upgrade"])
-            .status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    ctx.run_type()
+        .execute(sudo)
+        .args(["eopkg", "upgrade"])
+        .status_checked()?;
 
     Ok(())
 }
@@ -628,68 +595,59 @@ pub fn run_packer_nu(ctx: &ExecutionContext) -> Result<()> {
 }
 
 fn upgrade_clearlinux(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = &ctx.sudo() {
-        ctx.run_type()
-            .execute(sudo)
-            .args(["swupd", "update"])
-            .status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
-    }
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    ctx.run_type()
+        .execute(sudo)
+        .args(["swupd", "update"])
+        .status_checked()?;
 
     Ok(())
 }
 
 fn upgrade_exherbo(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
-        ctx.run_type().execute(sudo).args(["cave", "sync"]).status_checked()?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    ctx.run_type().execute(sudo).args(["cave", "sync"]).status_checked()?;
 
+    ctx.run_type()
+        .execute(sudo)
+        .args(["cave", "resolve", "world", "-c1", "-Cs", "-km", "-Km", "-x"])
+        .status_checked()?;
+
+    if ctx.config().cleanup() {
         ctx.run_type()
             .execute(sudo)
-            .args(["cave", "resolve", "world", "-c1", "-Cs", "-km", "-Km", "-x"])
+            .args(["cave", "purge", "-x"])
             .status_checked()?;
-
-        if ctx.config().cleanup() {
-            ctx.run_type()
-                .execute(sudo)
-                .args(["cave", "purge", "-x"])
-                .status_checked()?;
-        }
-
-        ctx.run_type()
-            .execute(sudo)
-            .args(["cave", "fix-linkage", "-x", "--", "-Cs"])
-            .status_checked()?;
-
-        ctx.run_type()
-            .execute(sudo)
-            .args(["eclectic", "config", "interactive"])
-            .status_checked()?;
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
     }
 
+    ctx.run_type()
+        .execute(sudo)
+        .args(["cave", "fix-linkage", "-x", "--", "-Cs"])
+        .status_checked()?;
+
+    ctx.run_type()
+        .execute(sudo)
+        .args(["eclectic", "config", "interactive"])
+        .status_checked()?;
+
     Ok(())
 }
 
 fn upgrade_nixos(ctx: &ExecutionContext) -> Result<()> {
-    if let Some(sudo) = ctx.sudo() {
-        let mut command = ctx.run_type().execute(sudo);
-        command.args(["/run/current-system/sw/bin/nixos-rebuild", "switch", "--upgrade"]);
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    let mut command = ctx.run_type().execute(sudo);
+    command.args(["/run/current-system/sw/bin/nixos-rebuild", "switch", "--upgrade"]);
 
-        if let Some(args) = ctx.config().nix_arguments() {
-            command.args(args.split_whitespace());
-        }
-        command.status_checked()?;
+    if let Some(args) = ctx.config().nix_arguments() {
+        command.args(args.split_whitespace());
+    }
+    command.status_checked()?;
 
-        if ctx.config().cleanup() {
-            ctx.run_type()
-                .execute(sudo)
-                .args(["/run/current-system/sw/bin/nix-collect-garbage", "-d"])
-                .status_checked()?;
-        }
-    } else {
-        print_warning("No sudo detected. Skipping system upgrade");
+    if ctx.config().cleanup() {
+        ctx.run_type()
+            .execute(sudo)
+            .args(["/run/current-system/sw/bin/nix-collect-garbage", "-d"])
+            .status_checked()?;
     }
 
     Ok(())
@@ -701,31 +659,31 @@ fn upgrade_neon(ctx: &ExecutionContext) -> Result<()> {
     // in theory rpm based distributions use pkcon as well, though that
     // seems rare
     // if that comes up we need to create a Distribution::PackageKit or some such
-    if let Some(sudo) = &ctx.sudo() {
-        let pkcon = which("pkcon").unwrap();
-        // pkcon ignores update with update and refresh provided together
-        ctx.run_type()
-            .execute(sudo)
-            .arg(&pkcon)
-            .arg("refresh")
-            .status_checked()?;
-        let mut exe = ctx.run_type().execute(sudo);
-        let cmd = exe.arg(&pkcon).arg("update");
-        if ctx.config().yes(Step::System) {
-            cmd.arg("-y");
-        }
-        if ctx.config().cleanup() {
-            cmd.arg("--autoremove");
-        }
-        // from pkcon man, exit code 5 is 'Nothing useful was done.'
-        cmd.status_checked_with_codes(&[5])?;
+
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+    let pkcon = which("pkcon").unwrap();
+    // pkcon ignores update with update and refresh provided together
+    ctx.run_type()
+        .execute(sudo)
+        .arg(&pkcon)
+        .arg("refresh")
+        .status_checked()?;
+    let mut exe = ctx.run_type().execute(sudo);
+    let cmd = exe.arg(&pkcon).arg("update");
+    if ctx.config().yes(Step::System) {
+        cmd.arg("-y");
     }
+    if ctx.config().cleanup() {
+        cmd.arg("--autoremove");
+    }
+    // from pkcon man, exit code 5 is 'Nothing useful was done.'
+    cmd.status_checked_with_codes(&[5])?;
 
     Ok(())
 }
 
 pub fn run_needrestart(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), String::from("sudo is not installed"))?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     let needrestart = require("needrestart")?;
     let distribution = Distribution::detect()?;
 
@@ -769,7 +727,7 @@ pub fn run_fwupdmgr(ctx: &ExecutionContext) -> Result<()> {
 
 pub fn run_flatpak(ctx: &ExecutionContext) -> Result<()> {
     let flatpak = require("flatpak")?;
-    let sudo = require_option(ctx.sudo().as_ref(), String::from("sudo is not installed"))?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     let cleanup = ctx.config().cleanup();
     let yes = ctx.config().yes(Step::Flatpak);
     let run_type = ctx.run_type();
@@ -830,7 +788,7 @@ pub fn run_flatpak(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_snap(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), String::from("sudo is not installed"))?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     let snap = require("snap")?;
 
     if !PathBuf::from("/var/snapd.socket").exists() && !PathBuf::from("/run/snapd.socket").exists() {
@@ -842,7 +800,7 @@ pub fn run_snap(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_pihole_update(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), String::from("sudo is not installed"))?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     let pihole = require("pihole")?;
     Path::new("/opt/pihole/update.sh").require()?;
 
@@ -886,7 +844,7 @@ pub fn run_distrobox_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_dkp_pacman_update(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), String::from("sudo is not installed"))?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     let dkp_pacman = require("dkp-pacman")?;
 
     print_separator("Devkitpro pacman");
@@ -909,7 +867,7 @@ pub fn run_dkp_pacman_update(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn run_config_update(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), String::from("sudo is not installed"))?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     if ctx.config().yes(Step::ConfigUpdate) {
         return Err(SkipStep("Skipped in --yes".to_string()).into());
     }
diff --git a/src/steps/os/macos.rs b/src/steps/os/macos.rs
index d5d9b132..b835d5b8 100644
--- a/src/steps/os/macos.rs
+++ b/src/steps/os/macos.rs
@@ -1,6 +1,7 @@
 use crate::command::CommandExt;
 use crate::execution_context::ExecutionContext;
 use crate::terminal::{print_separator, prompt_yesno};
+use crate::utils::{require_option, REQUIRE_SUDO};
 use crate::{utils::require, Step};
 use color_eyre::eyre::Result;
 use std::fs;
@@ -9,7 +10,8 @@ use tracing::debug;
 
 pub fn run_macports(ctx: &ExecutionContext) -> Result<()> {
     require("port")?;
-    let sudo = ctx.sudo().as_ref().unwrap();
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
+
     print_separator("MacPorts");
     ctx.run_type()
         .execute(sudo)
diff --git a/src/steps/os/openbsd.rs b/src/steps/os/openbsd.rs
index cd5b4732..8869f8db 100644
--- a/src/steps/os/openbsd.rs
+++ b/src/steps/os/openbsd.rs
@@ -1,11 +1,11 @@
 use crate::execution_context::ExecutionContext;
 use crate::terminal::print_separator;
-use crate::utils::require_option;
+use crate::utils::{require_option, REQUIRE_SUDO};
 use color_eyre::eyre::Result;
 use std::path::PathBuf;
 
 pub fn upgrade_openbsd(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), String::from("No sudo detected"))?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     print_separator("OpenBSD Update");
     ctx.run_type()
         .execute(sudo)
@@ -14,7 +14,7 @@ pub fn upgrade_openbsd(ctx: &ExecutionContext) -> Result<()> {
 }
 
 pub fn upgrade_packages(ctx: &ExecutionContext) -> Result<()> {
-    let sudo = require_option(ctx.sudo().as_ref(), String::from("No sudo detected"))?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
     print_separator("OpenBSD Packages");
     ctx.run_type()
         .execute(sudo)
diff --git a/src/steps/os/unix.rs b/src/steps/os/unix.rs
index 08cc6036..a7f13bc1 100644
--- a/src/steps/os/unix.rs
+++ b/src/steps/os/unix.rs
@@ -18,9 +18,7 @@ use crate::executor::Executor;
 #[cfg(any(target_os = "linux", target_os = "macos"))]
 use crate::executor::RunType;
 use crate::terminal::print_separator;
-#[cfg(not(any(target_os = "android", target_os = "macos")))]
-use crate::utils::require_option;
-use crate::utils::{require, PathExt};
+use crate::utils::{require, require_option, PathExt, REQUIRE_SUDO};
 
 #[cfg(any(target_os = "linux", target_os = "macos"))]
 const INTEL_BREW: &str = "/usr/local/bin/brew";
@@ -173,17 +171,18 @@ pub fn run_oh_my_fish(ctx: &ExecutionContext) -> Result<()> {
 
 pub fn run_pkgin(ctx: &ExecutionContext) -> Result<()> {
     let pkgin = require("pkgin")?;
+    let sudo = require_option(ctx.sudo().as_ref(), REQUIRE_SUDO.to_string())?;
 
     print_separator("Pkgin");
 
-    let mut command = ctx.run_type().execute(ctx.sudo().as_ref().unwrap());
+    let mut command = ctx.run_type().execute(sudo);
     command.arg(&pkgin).arg("update");
     if ctx.config().yes(Step::Pkgin) {
         command.arg("-y");
     }
     command.status_checked()?;
 
-    let mut command = ctx.run_type().execute(ctx.sudo().as_ref().unwrap());
+    let mut command = ctx.run_type().execute(sudo);
     command.arg(&pkgin).arg("upgrade");
     if ctx.config().yes(Step::Pkgin) {
         command.arg("-y");
diff --git a/src/utils.rs b/src/utils.rs
index 472e26a0..b88be69d 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -213,3 +213,7 @@ pub mod merge_strategies {
         }
     }
 }
+
+// Skip causes
+// TODO: Put them in a better place when we have more of them
+pub const REQUIRE_SUDO: &str = "Require sudo or counterpart but not found, skip";