diff --git a/fastboot/device/commands.cpp b/fastboot/device/commands.cpp
index ac381fb..0e4a68b 100644
--- a/fastboot/device/commands.cpp
+++ b/fastboot/device/commands.cpp
@@ -37,8 +37,7 @@
 using ::android::hardware::boot::V1_0::Slot;
 
 bool GetVarHandler(FastbootDevice* device, const std::vector<std::string>& args) {
-    using VariableHandler =
-            std::function<std::string(FastbootDevice*, const std::vector<std::string>&)>;
+    using VariableHandler = std::function<bool(FastbootDevice*, const std::vector<std::string>&)>;
     const std::unordered_map<std::string, VariableHandler> kVariableMap = {
             {FB_VAR_VERSION, GetVersion},
             {FB_VAR_VERSION_BOOTLOADER, GetBootloaderVersion},
@@ -61,8 +60,7 @@
     }
 
     std::vector<std::string> getvar_args(args.begin() + 2, args.end());
-    auto result = found_variable->second(device, getvar_args);
-    return device->WriteStatus(FastbootResult::OKAY, result);
+    return found_variable->second(device, getvar_args);
 }
 
 bool DownloadHandler(FastbootDevice* device, const std::vector<std::string>& args) {
diff --git a/fastboot/device/fastboot_device.cpp b/fastboot/device/fastboot_device.cpp
index f61e5c2..a225bf8 100644
--- a/fastboot/device/fastboot_device.cpp
+++ b/fastboot/device/fastboot_device.cpp
@@ -122,3 +122,11 @@
         }
     }
 }
+
+bool FastbootDevice::WriteOkay(const std::string& message) {
+    return WriteStatus(FastbootResult::OKAY, message);
+}
+
+bool FastbootDevice::WriteFail(const std::string& message) {
+    return WriteStatus(FastbootResult::FAIL, message);
+}
diff --git a/fastboot/device/fastboot_device.h b/fastboot/device/fastboot_device.h
index 1092499..7517120 100644
--- a/fastboot/device/fastboot_device.h
+++ b/fastboot/device/fastboot_device.h
@@ -39,6 +39,10 @@
     bool HandleData(bool read, std::vector<char>* data);
     std::string GetCurrentSlot();
 
+    // Shortcuts for writing OKAY and FAIL status results.
+    bool WriteOkay(const std::string& message);
+    bool WriteFail(const std::string& message);
+
     std::vector<char>& get_download_data() { return download_data_; }
     void set_upload_data(const std::vector<char>& data) { upload_data_ = data; }
     void set_upload_data(std::vector<char>&& data) { upload_data_ = std::move(data); }
diff --git a/fastboot/device/variables.cpp b/fastboot/device/variables.cpp
index 153ab92..33f7f74 100644
--- a/fastboot/device/variables.cpp
+++ b/fastboot/device/variables.cpp
@@ -32,91 +32,96 @@
 constexpr int kMaxDownloadSizeDefault = 0x20000000;
 constexpr char kFastbootProtocolVersion[] = "0.4";
 
-std::string GetVersion(FastbootDevice* /* device */, const std::vector<std::string>& /* args */) {
-    return kFastbootProtocolVersion;
+bool GetVersion(FastbootDevice* device, const std::vector<std::string>& /* args */) {
+    return device->WriteOkay(kFastbootProtocolVersion);
 }
 
-std::string GetBootloaderVersion(FastbootDevice* /* device */,
-                                 const std::vector<std::string>& /* args */) {
-    return android::base::GetProperty("ro.bootloader", "");
+bool GetBootloaderVersion(FastbootDevice* device, const std::vector<std::string>& /* args */) {
+    return device->WriteOkay(android::base::GetProperty("ro.bootloader", ""));
 }
 
-std::string GetBasebandVersion(FastbootDevice* /* device */,
-                               const std::vector<std::string>& /* args */) {
-    return android::base::GetProperty("ro.build.expect.baseband", "");
+bool GetBasebandVersion(FastbootDevice* device, const std::vector<std::string>& /* args */) {
+    return device->WriteOkay(android::base::GetProperty("ro.build.expect.baseband", ""));
 }
 
-std::string GetProduct(FastbootDevice* /* device */, const std::vector<std::string>& /* args */) {
-    return android::base::GetProperty("ro.product.device", "");
+bool GetProduct(FastbootDevice* device, const std::vector<std::string>& /* args */) {
+    return device->WriteOkay(android::base::GetProperty("ro.product.device", ""));
 }
 
-std::string GetSerial(FastbootDevice* /* device */, const std::vector<std::string>& /* args */) {
-    return android::base::GetProperty("ro.serialno", "");
+bool GetSerial(FastbootDevice* device, const std::vector<std::string>& /* args */) {
+    return device->WriteOkay(android::base::GetProperty("ro.serialno", ""));
 }
 
-std::string GetSecure(FastbootDevice* /* device */, const std::vector<std::string>& /* args */) {
-    return android::base::GetBoolProperty("ro.secure", "") ? "yes" : "no";
+bool GetSecure(FastbootDevice* device, const std::vector<std::string>& /* args */) {
+    return device->WriteOkay(android::base::GetBoolProperty("ro.secure", "") ? "yes" : "no");
 }
 
-std::string GetCurrentSlot(FastbootDevice* device, const std::vector<std::string>& /* args */) {
+bool GetCurrentSlot(FastbootDevice* device, const std::vector<std::string>& /* args */) {
     std::string suffix = device->GetCurrentSlot();
-    return suffix.size() == 2 ? suffix.substr(1) : suffix;
+    std::string slot = suffix.size() == 2 ? suffix.substr(1) : suffix;
+    return device->WriteOkay(slot);
 }
 
-std::string GetSlotCount(FastbootDevice* device, const std::vector<std::string>& /* args */) {
+bool GetSlotCount(FastbootDevice* device, const std::vector<std::string>& /* args */) {
     auto boot_control_hal = device->boot_control_hal();
     if (!boot_control_hal) {
         return "0";
     }
-    return std::to_string(boot_control_hal->getNumberSlots());
+    return device->WriteOkay(std::to_string(boot_control_hal->getNumberSlots()));
 }
 
-std::string GetSlotSuccessful(FastbootDevice* device, const std::vector<std::string>& args) {
+bool GetSlotSuccessful(FastbootDevice* device, const std::vector<std::string>& args) {
     if (args.empty()) {
-        return "no";
+        return device->WriteFail("Missing argument");
     }
     Slot slot;
     if (!GetSlotNumber(args[0], &slot)) {
-        return "no";
+        return device->WriteFail("Invalid slot");
     }
     auto boot_control_hal = device->boot_control_hal();
     if (!boot_control_hal) {
-        return "no";
+        return device->WriteFail("Device has no slots");
     }
-    return boot_control_hal->isSlotMarkedSuccessful(slot) == BoolResult::TRUE ? "yes" : "no";
+    if (boot_control_hal->isSlotMarkedSuccessful(slot) != BoolResult::TRUE) {
+        return device->WriteOkay("no");
+    }
+    return device->WriteOkay("yes");
 }
 
-std::string GetSlotUnbootable(FastbootDevice* device, const std::vector<std::string>& args) {
+bool GetSlotUnbootable(FastbootDevice* device, const std::vector<std::string>& args) {
     if (args.empty()) {
-        return "no";
+        return device->WriteFail("Missing argument");
     }
     Slot slot;
     if (!GetSlotNumber(args[0], &slot)) {
-        return "no";
+        return device->WriteFail("Invalid slot");
     }
     auto boot_control_hal = device->boot_control_hal();
     if (!boot_control_hal) {
-        return "no";
+        return device->WriteFail("Device has no slots");
     }
-    return boot_control_hal->isSlotBootable(slot) == BoolResult::TRUE ? "no" : "yes";
+    if (boot_control_hal->isSlotBootable(slot) != BoolResult::TRUE) {
+        return device->WriteOkay("yes");
+    }
+    return device->WriteOkay("no");
 }
 
-std::string GetMaxDownloadSize(FastbootDevice* /* device */,
-                               const std::vector<std::string>& /* args */) {
-    return std::to_string(kMaxDownloadSizeDefault);
+bool GetMaxDownloadSize(FastbootDevice* device, const std::vector<std::string>& /* args */) {
+    return device->WriteOkay(std::to_string(kMaxDownloadSizeDefault));
 }
 
-std::string GetUnlocked(FastbootDevice* /* device */, const std::vector<std::string>& /* args */) {
-    return "yes";
+bool GetUnlocked(FastbootDevice* device, const std::vector<std::string>& /* args */) {
+    return device->WriteOkay("yes");
 }
 
-std::string GetHasSlot(FastbootDevice* device, const std::vector<std::string>& args) {
+bool GetHasSlot(FastbootDevice* device, const std::vector<std::string>& args) {
     if (args.empty()) {
-        return "no";
+        return device->WriteFail("Missing argument");
     }
     std::string slot_suffix = device->GetCurrentSlot();
     if (slot_suffix.empty()) {
-        return "no";
+        return device->WriteFail("Invalid slot");
     }
-    return args[0] == "userdata" ? "no" : "yes";
+    std::string result = (args[0] == "userdata" ? "no" : "yes");
+    return device->WriteOkay(result);
 }
diff --git a/fastboot/device/variables.h b/fastboot/device/variables.h
index 09ef8ec..45c6dc9 100644
--- a/fastboot/device/variables.h
+++ b/fastboot/device/variables.h
@@ -21,16 +21,16 @@
 
 class FastbootDevice;
 
-std::string GetVersion(FastbootDevice* device, const std::vector<std::string>& args);
-std::string GetBootloaderVersion(FastbootDevice* device, const std::vector<std::string>& args);
-std::string GetBasebandVersion(FastbootDevice* device, const std::vector<std::string>& args);
-std::string GetProduct(FastbootDevice* device, const std::vector<std::string>& args);
-std::string GetSerial(FastbootDevice* device, const std::vector<std::string>& args);
-std::string GetSecure(FastbootDevice* device, const std::vector<std::string>& args);
-std::string GetCurrentSlot(FastbootDevice* device, const std::vector<std::string>& args);
-std::string GetSlotCount(FastbootDevice* device, const std::vector<std::string>& args);
-std::string GetSlotSuccessful(FastbootDevice* device, const std::vector<std::string>& args);
-std::string GetSlotUnbootable(FastbootDevice* device, const std::vector<std::string>& args);
-std::string GetMaxDownloadSize(FastbootDevice* device, const std::vector<std::string>& args);
-std::string GetUnlocked(FastbootDevice* device, const std::vector<std::string>& args);
-std::string GetHasSlot(FastbootDevice* device, const std::vector<std::string>& args);
+bool GetVersion(FastbootDevice* device, const std::vector<std::string>& args);
+bool GetBootloaderVersion(FastbootDevice* device, const std::vector<std::string>& args);
+bool GetBasebandVersion(FastbootDevice* device, const std::vector<std::string>& args);
+bool GetProduct(FastbootDevice* device, const std::vector<std::string>& args);
+bool GetSerial(FastbootDevice* device, const std::vector<std::string>& args);
+bool GetSecure(FastbootDevice* device, const std::vector<std::string>& args);
+bool GetCurrentSlot(FastbootDevice* device, const std::vector<std::string>& args);
+bool GetSlotCount(FastbootDevice* device, const std::vector<std::string>& args);
+bool GetSlotSuccessful(FastbootDevice* device, const std::vector<std::string>& args);
+bool GetSlotUnbootable(FastbootDevice* device, const std::vector<std::string>& args);
+bool GetMaxDownloadSize(FastbootDevice* device, const std::vector<std::string>& args);
+bool GetUnlocked(FastbootDevice* device, const std::vector<std::string>& args);
+bool GetHasSlot(FastbootDevice* device, const std::vector<std::string>& args);