diff --git a/blog/content/second-edition/posts/05-cpu-exceptions/index.md b/blog/content/second-edition/posts/05-cpu-exceptions/index.md
index e4e4ea25..dc308ed6 100644
--- a/blog/content/second-edition/posts/05-cpu-exceptions/index.md
+++ b/blog/content/second-edition/posts/05-cpu-exceptions/index.md
@@ -438,23 +438,20 @@ Now we can create a `test_breakpoint_exception` test:
 ```rust
 // in src/interrupts.rs
 
-#[cfg(test)]
-use crate::{serial_print, serial_println};
-
 #[test_case]
 fn test_breakpoint_exception() {
-    serial_print!("test_breakpoint_exception...");
     // invoke a breakpoint exception
     x86_64::instructions::interrupts::int3();
-    serial_println!("[ok]");
 }
 ```
 
-Apart from printing status messages through the [serial port], the test invokes the `int3` function to trigger a breakpoint exception. By checking that the execution continues afterwards, we verify that our breakpoint handler is working correctly.
+The test invokes the `int3` function to trigger a breakpoint exception. By checking that the execution continues afterwards, we verify that our breakpoint handler is working correctly.
 
-[serial port]: @/second-edition/posts/04-testing/index.md#serial-port
+You can try this new test by running `cargo xtest` (all tests) or `cargo xtest --lib` (only tests of `lib.rs` and its modules). You should see the following in the output:
 
-You can try this new test by running `cargo xtest` (all tests) or `cargo xtest --lib` (only tests of `lib.rs` and its modules). You should see `test_breakpoint_exception...[ok]` in the output.
+```
+blog_os::interrupts::test_breakpoint_exception...	[ok]
+```
 
 ## Too much Magic?
 The `x86-interrupt` calling convention and the [`InterruptDescriptorTable`] type made the exception handling process relatively straightforward and painless. If this was too much magic for you and you like to learn all the gory details of exception handling, we got you covered: Our [“Handling Exceptions with Naked Functions”] series shows how to handle exceptions without the `x86-interrupt` calling convention and also creates its own IDT type. Historically, these posts were the main exception handling posts before the `x86-interrupt` calling convention and the `x86_64` crate existed. Note that these posts are based on the [first edition] of this blog and might be out of date.
diff --git a/blog/content/second-edition/posts/07-hardware-interrupts/index.md b/blog/content/second-edition/posts/07-hardware-interrupts/index.md
index 64969678..61c72388 100644
--- a/blog/content/second-edition/posts/07-hardware-interrupts/index.md
+++ b/blog/content/second-edition/posts/07-hardware-interrupts/index.md
@@ -382,16 +382,12 @@ The reason is a _race condition_ between the test and our timer handler. Remembe
 
 #[test_case]
 fn test_println_output() {
-    serial_print!("test_println_output... ");
-
     let s = "Some test string that fits on a single line";
     println!("{}", s);
     for (i, c) in s.chars().enumerate() {
         let screen_char = WRITER.lock().buffer.chars[BUFFER_HEIGHT - 2][i].read();
         assert_eq!(char::from(screen_char.ascii_character), c);
     }
-
-    serial_println!("[ok]");
 }
 ```
 
@@ -409,8 +405,6 @@ fn test_println_output() {
     use core::fmt::Write;
     use x86_64::instructions::interrupts;
 
-    serial_print!("test_println_output... ");
-
     let s = "Some test string that fits on a single line";
     interrupts::without_interrupts(|| {
         let mut writer = WRITER.lock();
@@ -420,8 +414,6 @@ fn test_println_output() {
             assert_eq!(char::from(screen_char.ascii_character), c);
         }
     });
-
-    serial_println!("[ok]");
 }
 ```
 
diff --git a/blog/content/second-edition/posts/10-heap-allocation/index.md b/blog/content/second-edition/posts/10-heap-allocation/index.md
index a0f10964..88c3ef7b 100644
--- a/blog/content/second-edition/posts/10-heap-allocation/index.md
+++ b/blog/content/second-edition/posts/10-heap-allocation/index.md
@@ -710,12 +710,10 @@ use alloc::boxed::Box;
 
 #[test_case]
 fn simple_allocation() {
-    serial_print!("simple_allocation... ");
     let heap_value_1 = Box::new(41);
     let heap_value_2 = Box::new(13);
     assert_eq!(*heap_value_1, 41);
     assert_eq!(*heap_value_2, 13);
-    serial_println!("[ok]");
 }
 ```
 
@@ -730,14 +728,12 @@ use alloc::vec::Vec;
 
 #[test_case]
 fn large_vec() {
-    serial_print!("large_vec... ");
     let n = 1000;
     let mut vec = Vec::new();
     for i in 0..n {
         vec.push(i);
     }
     assert_eq!(vec.iter().sum::<u64>(), (n - 1) * n / 2);
-    serial_println!("[ok]");
 }
 ```
 
@@ -754,12 +750,10 @@ use blog_os::allocator::HEAP_SIZE;
 
 #[test_case]
 fn many_boxes() {
-    serial_print!("many_boxes... ");
     for i in 0..HEAP_SIZE {
         let x = Box::new(i);
         assert_eq!(*x, i);
     }
-    serial_println!("[ok]");
 }
 ```
 
diff --git a/blog/content/second-edition/posts/11-allocator-designs/index.md b/blog/content/second-edition/posts/11-allocator-designs/index.md
index 5ba6d000..18bded5b 100644
--- a/blog/content/second-edition/posts/11-allocator-designs/index.md
+++ b/blog/content/second-edition/posts/11-allocator-designs/index.md
@@ -402,14 +402,12 @@ The main limitation of a bump allocator is that it can only reuse deallocated me
 
 #[test_case]
 fn many_boxes_long_lived() {
-    serial_print!("many_boxes_long_lived... ");
     let long_lived = Box::new(1); // new
     for i in 0..HEAP_SIZE {
         let x = Box::new(i);
         assert_eq!(*x, i);
     }
     assert_eq!(*long_lived, 1); // new
-    serial_println!("[ok]");
 }
 ```