diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5d5639c..99436b7 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -64,12 +64,6 @@ jobs:
         command: test
         args: --all --features unstable
 
-    - name: tests with verbose errors
-      uses: actions-rs/cargo@v1
-      with:
-        command: test
-        args: --all --features 'unstable verbose-errors'
-
   check_fmt_and_docs:
     name: Checking fmt and docs
     runs-on: ubuntu-latest
diff --git a/Cargo.toml b/Cargo.toml
index 7886bcf..7ffaae3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -48,7 +48,6 @@ std = [
   "pin-utils",
   "slab",
 ]
-verbose-errors = []
 
 [dependencies]
 async-attributes = { version = "1.1.1", optional = true }
diff --git a/src/fs/file.rs b/src/fs/file.rs
index 5186e96..f824281 100644
--- a/src/fs/file.rs
+++ b/src/fs/file.rs
@@ -9,7 +9,7 @@ use std::sync::{Arc, Mutex};
 
 use crate::fs::{Metadata, Permissions};
 use crate::future;
-use crate::utils::VerboseErrorExt;
+use crate::utils::Context as _;
 use crate::io::{self, Read, Seek, SeekFrom, Write};
 use crate::path::Path;
 use crate::prelude::*;
@@ -115,7 +115,7 @@ impl File {
         let path = path.as_ref().to_owned();
         let file = spawn_blocking(move || {
             std::fs::File::open(&path)
-                .verbose_context(|| format!("Could not open {}", path.display()))
+                .context(|| format!("Could not open {}", path.display()))
         })
         .await?;
         Ok(File::new(file, true))
@@ -154,7 +154,7 @@ impl File {
         let path = path.as_ref().to_owned();
         let file = spawn_blocking(move || {
             std::fs::File::create(&path)
-                .verbose_context(|| format!("Could not create {}", path.display()))
+                .context(|| format!("Could not create {}", path.display()))
         })
         .await?;
         Ok(File::new(file, true))
diff --git a/src/io/utils.rs b/src/io/utils.rs
index ebd2214..1b73064 100644
--- a/src/io/utils.rs
+++ b/src/io/utils.rs
@@ -1,52 +1,46 @@
-use crate::utils::VerboseErrorExt;
+use crate::utils::Context;
 
 /// Wrap `std::io::Error` with additional message
 ///
-/// *Note* Only active when `verbose-errors` feature is enabled for this crate!
-///
 /// Keeps the original error kind and stores the original I/O error as `source`.
-impl<T> VerboseErrorExt for Result<T, std::io::Error> {
-    #[cfg(feature = "verbose-errors")]
-    fn verbose_context(self, message: impl Fn() -> String) -> Self {
-        self.map_err(|e| verbose::Error::wrap(e, message()))
+impl<T> Context for Result<T, std::io::Error> {
+    fn context(self, message: impl Fn() -> String) -> Self {
+        self.map_err(|e| VerboseError::wrap(e, message()))
     }
 }
 
-#[cfg(feature = "verbose-errors")]
-mod verbose {
-    use std::{error::Error as StdError, fmt, io};
+use std::{error::Error as StdError, fmt, io};
 
-    #[derive(Debug)]
-    pub(crate) struct Error {
-        source: io::Error,
-        message: String,
-    }
+#[derive(Debug)]
+pub(crate) struct VerboseError {
+    source: io::Error,
+    message: String,
+}
 
-    impl Error {
-        pub(crate) fn wrap(source: io::Error, message: impl Into<String>) -> io::Error {
-            io::Error::new(
-                source.kind(),
-                Error {
-                    source,
-                    message: message.into(),
-                },
-            )
-        }
+impl VerboseError {
+    pub(crate) fn wrap(source: io::Error, message: impl Into<String>) -> io::Error {
+        io::Error::new(
+            source.kind(),
+            VerboseError {
+                source,
+                message: message.into(),
+            },
+        )
     }
+}
 
-    impl fmt::Display for Error {
-        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            write!(f, "{}", self.message)
-        }
+impl fmt::Display for VerboseError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.message)
     }
+}
 
-    impl StdError for Error {
-        fn description(&self) -> &str {
-            self.source.description()
-        }
+impl StdError for VerboseError {
+    fn description(&self) -> &str {
+        self.source.description()
+    }
 
-        fn source(&self) -> Option<&(dyn StdError + 'static)> {
-            Some(&self.source)
-        }
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        Some(&self.source)
     }
 }
diff --git a/src/utils.rs b/src/utils.rs
index ce4a85c..645dc84 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -53,17 +53,8 @@ pub fn random(n: u32) -> u32 {
 }
 
 /// Add additional context to errors
-///
-/// *Note for implementors:* The given closure must only be executed when
-/// `verbose-errors` feature is enabled for this crate!
-pub(crate) trait VerboseErrorExt: Sized {
-    #[cfg(feature = "verbose-errors")]
-    fn verbose_context(self, message: impl Fn() -> String) -> Self;
-
-    #[cfg(not(feature = "verbose-errors"))]
-    fn verbose_context(self, _: impl Fn() -> String) -> Self {
-        self
-    }
+pub(crate) trait Context {
+    fn context(self, message: impl Fn() -> String) -> Self;
 }
 
 /// Defers evaluation of a block of code until the end of the scope.
diff --git a/tests/verbose_errors.rs b/tests/verbose_errors.rs
index 3d99ede..54d04f8 100644
--- a/tests/verbose_errors.rs
+++ b/tests/verbose_errors.rs
@@ -1,20 +1,16 @@
-#[cfg(feature = "verbose-errors")]
-mod verbose_tests {
-    use async_std::{fs, task};
+use async_std::{fs, task};
 
-    #[test]
-    fn open_file() {
-        task::block_on(async {
-            let non_existing_file =
-                "/ashjudlkahasdasdsikdhajik/asdasdasdasdasdasd/fjuiklashdbflasas";
-            let res = fs::File::open(non_existing_file).await;
-            match res {
-                Ok(_) => panic!("Found file with random name: We live in a simulation"),
-                Err(e) => assert_eq!(
-                    "Could not open /ashjudlkahasdasdsikdhajik/asdasdasdasdasdasd/fjuiklashdbflasas",
-                    &format!("{}", e)
-                ),
-            }
-        })
-    }
+#[test]
+fn open_file() {
+    task::block_on(async {
+        let non_existing_file = "/ashjudlkahasdasdsikdhajik/asdasdasdasdasdasd/fjuiklashdbflasas";
+        let res = fs::File::open(non_existing_file).await;
+        match res {
+            Ok(_) => panic!("Found file with random name: We live in a simulation"),
+            Err(e) => assert_eq!(
+                "Could not open /ashjudlkahasdasdsikdhajik/asdasdasdasdasdasd/fjuiklashdbflasas",
+                &format!("{}", e)
+            ),
+        }
+    })
 }