diff --git a/pw_allocator/block_test.cc b/pw_allocator/block_test.cc
index 2c06caa..06772bd 100644
--- a/pw_allocator/block_test.cc
+++ b/pw_allocator/block_test.cc
@@ -136,12 +136,10 @@
   EXPECT_EQ(Block::Init(span(bytes, kN), &block), OkStatus());
 
   Block* block2 = nullptr;
-  block->Split(kSplit1, &block2)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), block->Split(kSplit1, &block2));
 
   Block* block3 = nullptr;
-  block->Split(kSplit2, &block3)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), block->Split(kSplit2, &block3));
 
   EXPECT_EQ(block->Next(), block3);
   EXPECT_EQ(block3->Next(), block2);
@@ -284,12 +282,10 @@
   EXPECT_EQ(Block::Init(span(bytes, kN), &block), OkStatus());
 
   Block* block2 = nullptr;
-  block->Split(kSplit1, &block2)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), block->Split(kSplit1, &block2));
 
   Block* block3 = nullptr;
-  block->Split(kSplit2, &block3)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), block->Split(kSplit2, &block3));
 
   EXPECT_EQ(block3->MergeNext(), OkStatus());
 
@@ -314,8 +310,7 @@
   EXPECT_EQ(Block::Init(span(bytes, kN), &block), OkStatus());
 
   Block* next_block = nullptr;
-  block->Split(512, &next_block)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), block->Split(512, &next_block));
 
   EXPECT_EQ(next_block->MergeNext(), Status::OutOfRange());
   EXPECT_EQ(block->MergePrev(), Status::OutOfRange());
@@ -331,8 +326,7 @@
   EXPECT_EQ(Block::Init(span(bytes, kN), &block), OkStatus());
 
   Block* next_block = nullptr;
-  block->Split(512, &next_block)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), block->Split(512, &next_block));
 
   block->MarkUsed();
   EXPECT_EQ(block->MergeNext(), Status::FailedPrecondition());
@@ -347,12 +341,10 @@
   EXPECT_EQ(Block::Init(span(bytes, kN), &first_block), OkStatus());
 
   Block* second_block = nullptr;
-  first_block->Split(512, &second_block)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), first_block->Split(512, &second_block));
 
   Block* third_block = nullptr;
-  second_block->Split(256, &third_block)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), second_block->Split(256, &third_block));
 
   EXPECT_EQ(first_block->IsValid(), true);
   EXPECT_EQ(second_block->IsValid(), true);
@@ -367,16 +359,13 @@
   EXPECT_EQ(Block::Init(span(bytes, kN), &first_block), OkStatus());
 
   Block* second_block = nullptr;
-  first_block->Split(512, &second_block)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), first_block->Split(512, &second_block));
 
   Block* third_block = nullptr;
-  second_block->Split(256, &third_block)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), second_block->Split(256, &third_block));
 
   Block* fourth_block = nullptr;
-  third_block->Split(128, &fourth_block)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), third_block->Split(128, &fourth_block));
 
   std::byte* next_ptr = reinterpret_cast<std::byte*>(first_block);
   memcpy(next_ptr, second_block, sizeof(void*));
@@ -408,12 +397,10 @@
   EXPECT_EQ(Block::Init(span(bytes, kN), &first_block), OkStatus());
 
   Block* second_block = nullptr;
-  first_block->Split(512, &second_block)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), first_block->Split(512, &second_block));
 
   Block* third_block = nullptr;
-  second_block->Split(256, &third_block)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), second_block->Split(256, &third_block));
 
   EXPECT_EQ(first_block->IsValid(), true);
   EXPECT_EQ(second_block->IsValid(), true);
diff --git a/pw_allocator/freelist_heap.cc b/pw_allocator/freelist_heap.cc
index 133e06f..30bdc2e 100644
--- a/pw_allocator/freelist_heap.cc
+++ b/pw_allocator/freelist_heap.cc
@@ -29,7 +29,7 @@
       "Failed to initialize FreeListHeap region; misaligned or too small");
 
   freelist_.AddChunk(BlockToSpan(block))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
 
   region_ = region;
   heap_stats_.total_bytes = region.size();
@@ -44,7 +44,7 @@
     return nullptr;
   }
   freelist_.RemoveChunk(chunk)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
 
   Block* chunk_block = Block::FromUsableSpace(chunk.data());
 
@@ -55,7 +55,7 @@
   auto status = chunk_block->Split(size, &leftover);
   if (status == PW_STATUS_OK) {
     freelist_.AddChunk(BlockToSpan(leftover))
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   }
 
   chunk_block->MarkUsed();
@@ -96,9 +96,9 @@
   if (prev != nullptr && !prev->Used()) {
     // Remove from freelist and merge
     freelist_.RemoveChunk(BlockToSpan(prev))
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     chunk_block->MergePrev()
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
 
     // chunk_block is now invalid; prev now encompasses it.
     chunk_block = prev;
@@ -106,13 +106,13 @@
 
   if (next != nullptr && !next->Used()) {
     freelist_.RemoveChunk(BlockToSpan(next))
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     chunk_block->MergeNext()
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   }
   // Add back to the freelist
   freelist_.AddChunk(BlockToSpan(chunk_block))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
 
   heap_stats_.bytes_allocated -= size_freed;
   heap_stats_.cumulative_freed += size_freed;
diff --git a/pw_allocator/freelist_test.cc b/pw_allocator/freelist_test.cc
index 5bb1e21..eea832a 100644
--- a/pw_allocator/freelist_test.cc
+++ b/pw_allocator/freelist_test.cc
@@ -55,8 +55,7 @@
 
   byte data[kN] = {std::byte(0)};
 
-  list.AddChunk(span(data, kN))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), list.AddChunk(span(data, kN)));
   auto item = list.FindChunk(kN / 2);
   EXPECT_EQ(item.size(), kN);
   EXPECT_EQ(item.data(), data);
@@ -68,8 +67,7 @@
 
   byte data[kN] = {std::byte(0)};
 
-  list.AddChunk(span(data, kN))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), list.AddChunk(span(data, kN)));
   auto status = list.RemoveChunk(span(data, kN));
   EXPECT_EQ(status, OkStatus());
 
@@ -85,10 +83,8 @@
   byte data1[kN1] = {std::byte(0)};
   byte data2[kN2] = {std::byte(0)};
 
-  list.AddChunk(span(data1, kN1))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-  list.AddChunk(span(data2, kN2))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), list.AddChunk(span(data1, kN1)));
+  ASSERT_EQ(OkStatus(), list.AddChunk(span(data2, kN2)));
 
   auto chunk = list.FindChunk(kN1 / 2);
   EXPECT_EQ(chunk.size(), kN1);
@@ -114,10 +110,8 @@
   byte data2[kN2] = {std::byte(0)};
 
   // List should now be 257 -> 512 -> NULL
-  list.AddChunk(span(data1, kN1))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-  list.AddChunk(span(data2, kN2))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), list.AddChunk(span(data1, kN1)));
+  ASSERT_EQ(OkStatus(), list.AddChunk(span(data2, kN2)));
 
   auto chunk = list.FindChunk(kN2 + 1);
   EXPECT_EQ(chunk.size(), kN1);
@@ -136,10 +130,8 @@
   // List should now be:
   // bkt[3] (257 bytes up to 512 bytes) -> 257 -> NULL
   // bkt[4] (513 bytes up to 1024 bytes) -> 513 -> NULL
-  list.AddChunk(span(data1, kN1))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-  list.AddChunk(span(data2, kN2))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), list.AddChunk(span(data1, kN1)));
+  ASSERT_EQ(OkStatus(), list.AddChunk(span(data2, kN2)));
 
   // Request a 300 byte chunk. This should return the 513 byte one
   auto chunk = list.FindChunk(kN1 + 1);
@@ -153,8 +145,7 @@
   byte data[kN] = {std::byte(0)};
   byte data2[kN] = {std::byte(0)};
 
-  list.AddChunk(span(data, kN))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), list.AddChunk(span(data, kN)));
   auto status = list.RemoveChunk(span(data2, kN));
   EXPECT_EQ(status, Status::NotFound());
 }
@@ -166,17 +157,13 @@
   byte data1[kN] = {std::byte(0)};
   byte data2[kN] = {std::byte(0)};
 
-  list.AddChunk(span(data1, kN))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-  list.AddChunk(span(data2, kN))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), list.AddChunk(span(data1, kN)));
+  ASSERT_EQ(OkStatus(), list.AddChunk(span(data2, kN)));
 
   auto chunk1 = list.FindChunk(kN);
-  list.RemoveChunk(chunk1)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), list.RemoveChunk(chunk1));
   auto chunk2 = list.FindChunk(kN);
-  list.RemoveChunk(chunk2)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), list.RemoveChunk(chunk2));
 
   // Ordering of the chunks doesn't matter
   EXPECT_TRUE(chunk1.data() != chunk2.data());
diff --git a/pw_assert_basic/basic_handler.cc b/pw_assert_basic/basic_handler.cc
index 6a6e734..d658c2b 100644
--- a/pw_assert_basic/basic_handler.cc
+++ b/pw_assert_basic/basic_handler.cc
@@ -81,7 +81,7 @@
 
 static void WriteLine(const std::string_view& s) {
   pw::sys_io::WriteLine(s)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
 }
 
 typedef pw::StringBuffer<150> Buffer;
diff --git a/pw_blob_store/blob_store.cc b/pw_blob_store/blob_store.cc
index 9cec204..01fdccd 100644
--- a/pw_blob_store/blob_store.cc
+++ b/pw_blob_store/blob_store.cc
@@ -90,7 +90,7 @@
                         metadata.v1_metadata.checksum)
            .ok()) {
     PW_LOG_ERROR("BlobStore init - Invalidating blob with invalid checksum");
-    Invalidate().IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    Invalidate().IgnoreError();  // TODO(b/242598609): Handle Status properly
     return Status::DataLoss();
   }
 
@@ -120,7 +120,7 @@
   writer_open_ = true;
 
   // Clear any existing contents.
-  Invalidate().IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  Invalidate().IgnoreError();  // TODO(b/242598609): Handle Status properly
 
   return OkStatus();
 }
@@ -453,7 +453,7 @@
 
   // If any writes have been performed, reset the state.
   if (flash_address_ != 0) {
-    Invalidate().IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    Invalidate().IgnoreError();  // TODO(b/242598609): Handle Status properly
   }
 
   PW_TRY(partition_.Erase());
diff --git a/pw_blob_store/blob_store_chunk_write_test.cc b/pw_blob_store/blob_store_chunk_write_test.cc
index 6a57001..45d1d94 100644
--- a/pw_blob_store/blob_store_chunk_write_test.cc
+++ b/pw_blob_store/blob_store_chunk_write_test.cc
@@ -34,22 +34,18 @@
   BlobStoreChunkTest() : flash_(kFlashAlignment), partition_(&flash_) {}
 
   void InitFlashTo(span<const std::byte> contents) {
-    partition_.Erase()
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), partition_.Erase());
     std::memcpy(flash_.buffer().data(), contents.data(), contents.size());
   }
 
   void InitSourceBufferToRandom(uint64_t seed) {
-    partition_.Erase()
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), partition_.Erase());
     random::XorShiftStarRng64 rng(seed);
-    rng.Get(source_buffer_)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), rng.Get(source_buffer_).status());
   }
 
   void InitSourceBufferToFill(char fill) {
-    partition_.Erase()
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), partition_.Erase());
     std::memset(source_buffer_.data(), fill, source_buffer_.size());
   }
 
diff --git a/pw_blob_store/blob_store_test.cc b/pw_blob_store/blob_store_test.cc
index fecff6a..acaf2ff 100644
--- a/pw_blob_store/blob_store_test.cc
+++ b/pw_blob_store/blob_store_test.cc
@@ -41,8 +41,7 @@
   BlobStoreTest() : flash_(kFlashAlignment), partition_(&flash_) {}
 
   void InitFlashTo(span<const std::byte> contents) {
-    partition_.Erase()
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), partition_.Erase());
     std::memcpy(flash_.buffer().data(), contents.data(), contents.size());
   }
 
@@ -54,8 +53,8 @@
     std::memset(source_buffer_.data(),
                 static_cast<int>(flash_.erased_memory_content()),
                 source_buffer_.size());
-    rng.Get(span(source_buffer_).first(init_size_bytes))
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(),
+              rng.Get(span(source_buffer_).first(init_size_bytes)).status());
   }
 
   void InitSourceBufferToFill(char fill,
diff --git a/pw_blob_store/flat_file_system_entry_test.cc b/pw_blob_store/flat_file_system_entry_test.cc
index 2149688..774a6f8 100644
--- a/pw_blob_store/flat_file_system_entry_test.cc
+++ b/pw_blob_store/flat_file_system_entry_test.cc
@@ -55,8 +55,8 @@
     std::memset(source_buffer_.data(),
                 static_cast<int>(flash_.erased_memory_content()),
                 source_buffer_.size());
-    rng.Get(span(source_buffer_).first(init_size_bytes))
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(),
+              rng.Get(span(source_buffer_).first(init_size_bytes)).status());
   }
 
   // Fill the source buffer with random pattern based on given seed, written to
diff --git a/pw_blob_store/public/pw_blob_store/blob_store.h b/pw_blob_store/public/pw_blob_store/blob_store.h
index 5cad2b9..9bdb354 100644
--- a/pw_blob_store/public/pw_blob_store/blob_store.h
+++ b/pw_blob_store/public/pw_blob_store/blob_store.h
@@ -68,7 +68,7 @@
     BlobWriter& operator=(const BlobWriter&) = delete;
     ~BlobWriter() override {
       if (open_) {
-        Close().IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        Close().IgnoreError();  // TODO(b/242598609): Handle Status properly
       }
     }
 
diff --git a/pw_file/flat_file_system.cc b/pw_file/flat_file_system.cc
index 5fb7903..b185b73 100644
--- a/pw_file/flat_file_system.cc
+++ b/pw_file/flat_file_system.cc
@@ -73,12 +73,12 @@
     Status write_status = writer.Write(encoder);
     if (!write_status.ok()) {
       writer.Finish(write_status)
-          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+          .IgnoreError();  // TODO(b/242598609): Handle Status properly
       return;
     }
   }
   writer.Finish(OkStatus())
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
 }
 
 void FlatFileSystemService::List(ConstByteSpan request,
@@ -95,7 +95,7 @@
     if (!decoder.ReadString(&file_name_view).ok() ||
         file_name_view.length() == 0) {
       writer.Finish(Status::DataLoss())
-          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+          .IgnoreError();  // TODO(b/242598609): Handle Status properly
       return;
     }
 
@@ -103,7 +103,7 @@
     Result<Entry*> result = FindFile(file_name_view);
     if (!result.ok()) {
       writer.Finish(result.status())
-          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+          .IgnoreError();  // TODO(b/242598609): Handle Status properly
       return;
     }
 
@@ -111,12 +111,12 @@
     Status proto_encode_status = EnumerateFile(*result.value(), encoder);
     if (!proto_encode_status.ok()) {
       writer.Finish(proto_encode_status)
-          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+          .IgnoreError();  // TODO(b/242598609): Handle Status properly
       return;
     }
 
     writer.Finish(writer.Write(encoder))
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     return;
   }
 
diff --git a/pw_hdlc/rpc_packets.cc b/pw_hdlc/rpc_packets.cc
index e7f4d7b..d3261fb 100644
--- a/pw_hdlc/rpc_packets.cc
+++ b/pw_hdlc/rpc_packets.cc
@@ -33,7 +33,7 @@
       Frame& frame = result.value();
       if (frame.address() == rpc_address) {
         server.ProcessPacket(frame.data(), output)
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
       }
     }
   }
diff --git a/pw_hex_dump/hex_dump_test.cc b/pw_hex_dump/hex_dump_test.cc
index 4a4a969..7d64f9a 100644
--- a/pw_hex_dump/hex_dump_test.cc
+++ b/pw_hex_dump/hex_dump_test.cc
@@ -333,10 +333,9 @@
   constexpr size_t kTestBytesPerLine = 16;
   std::array<char, kHexAddrStringSize + 1> expected1;
   std::array<char, kHexAddrStringSize + 1> expected2;
-  DumpAddr(expected1, source_data.data())
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-  DumpAddr(expected2, source_data.data() + kTestBytesPerLine)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), DumpAddr(expected1, source_data.data()));
+  ASSERT_EQ(OkStatus(),
+            DumpAddr(expected2, source_data.data() + kTestBytesPerLine));
 
   default_flags_.bytes_per_line = kTestBytesPerLine;
   default_flags_.prefix_mode = FormattedHexDumper::AddressMode::kAbsolute;
diff --git a/pw_hex_dump/public/pw_hex_dump/hex_dump.h b/pw_hex_dump/public/pw_hex_dump/hex_dump.h
index 61ab7f0..b08ce04 100644
--- a/pw_hex_dump/public/pw_hex_dump/hex_dump.h
+++ b/pw_hex_dump/public/pw_hex_dump/hex_dump.h
@@ -99,12 +99,12 @@
   FormattedHexDumper() = default;
   FormattedHexDumper(span<char> dest) {
     SetLineBuffer(dest)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   }
   FormattedHexDumper(span<char> dest, Flags config_flags)
       : flags(config_flags) {
     SetLineBuffer(dest)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   }
 
   // TODO(b/234892215): Add iterator support.
diff --git a/pw_i2c/register_device.cc b/pw_i2c/register_device.cc
index 21e52ce..9c3b15e 100644
--- a/pw_i2c/register_device.cc
+++ b/pw_i2c/register_device.cc
@@ -112,7 +112,7 @@
 
     case 4:
       PutRegisterData32InByteBuilder(builder, register_data, data_order_)
-          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+          .IgnoreError();  // TODO(b/242598609): Handle Status properly
       break;
 
     default:
diff --git a/pw_kvs/alignment_test.cc b/pw_kvs/alignment_test.cc
index 38f6e0c..81edbb9 100644
--- a/pw_kvs/alignment_test.cc
+++ b/pw_kvs/alignment_test.cc
@@ -175,8 +175,8 @@
 
   {
     AlignedWriterBuffer<64> writer(3, output);
-    writer.Write(as_bytes(span("What is this?")))
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(),
+              writer.Write(as_bytes(span("What is this?"))).status());
     EXPECT_EQ(called_with_bytes, 0u);  // Buffer not full; no output yet.
   }
 
@@ -212,12 +212,11 @@
 
   {
     AlignedWriterBuffer<4> writer(3, output);
-    writer.Write(as_bytes(span("Everything is fine.")))
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(),
+              writer.Write(as_bytes(span("Everything is fine."))).status());
     output.state = OutputWithErrorInjection::kBreakOnNext;
     EXPECT_EQ(Status::Unknown(),
               writer.Write(as_bytes(span("No more writes, okay?"))).status());
-    writer.Flush().IgnoreError();  // TODO(pwbug/387): Handle Status properly
   }
 }
 
diff --git a/pw_kvs/fake_flash_test_key_value_store.cc b/pw_kvs/fake_flash_test_key_value_store.cc
index e6f1778..840eb72 100644
--- a/pw_kvs/fake_flash_test_key_value_store.cc
+++ b/pw_kvs/fake_flash_test_key_value_store.cc
@@ -72,7 +72,7 @@
 
 sync::Borrowable<KeyValueStore>& TestKvs() {
   if (!test_kvs.initialized()) {
-    test_kvs.Init().IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    test_kvs.Init().IgnoreError();  // TODO(b/242598609): Handle Status properly
   }
 
   return borrowable_kvs;
diff --git a/pw_kvs/key_value_store.cc b/pw_kvs/key_value_store.cc
index 6e992ba..b0b7f5f 100644
--- a/pw_kvs/key_value_store.cc
+++ b/pw_kvs/key_value_store.cc
@@ -497,7 +497,7 @@
   Entry entry;
   if (kvs_.ReadEntry(*iterator_, entry).ok()) {
     entry.ReadKey(key_buffer_)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   }
 }
 
@@ -1281,7 +1281,7 @@
 
   DBG("Reinitialize KVS metadata");
   InitializeMetadata()
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
 
   return FixErrors();
 }
diff --git a/pw_kvs/key_value_store_binary_format_test.cc b/pw_kvs/key_value_store_binary_format_test.cc
index 7220df3..4ce2d74 100644
--- a/pw_kvs/key_value_store_binary_format_test.cc
+++ b/pw_kvs/key_value_store_binary_format_test.cc
@@ -174,8 +174,7 @@
         kvs_(&partition_, default_format, kNoGcOptions) {}
 
   void InitFlashTo(span<const byte> contents) {
-    partition_.Erase()
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), partition_.Erase());
     std::memcpy(flash_.buffer().data(), contents.data(), contents.size());
   }
 
@@ -383,8 +382,7 @@
              kRecoveryNoGcOptions) {}
 
   void InitFlashTo(span<const byte> contents) {
-    partition_.Erase()
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), partition_.Erase());
     std::memcpy(flash_.buffer().data(), contents.data(), contents.size());
   }
 
@@ -641,8 +639,7 @@
                  {.magic = kNoChecksumMagic, .checksum = nullptr},
              }},
              kRecoveryNoGcOptions) {
-    partition_.Erase()
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    EXPECT_EQ(OkStatus(), partition_.Erase());
     std::memcpy(flash_.buffer().data(),
                 kInitialContents.data(),
                 kInitialContents.size());
@@ -876,8 +873,7 @@
                  {.magic = kNoChecksumMagic, .checksum = nullptr},
              }},
              kRecoveryNoGcOptions) {
-    partition_.Erase()
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    EXPECT_EQ(OkStatus(), partition_.Erase());
     std::memcpy(flash_.buffer().data(),
                 kInitialContents.data(),
                 kInitialContents.size());
@@ -930,8 +926,7 @@
         kvs_(&partition_,
              {.magic = kMagic, .checksum = &default_checksum},
              kRecoveryLazyGcOptions) {
-    partition_.Erase()
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    EXPECT_EQ(OkStatus(), partition_.Erase());
     std::memcpy(flash_.buffer().data(),
                 kInitialContents.data(),
                 kInitialContents.size());
@@ -1023,8 +1018,7 @@
         kvs_(&partition_,
              {.magic = kMagic, .checksum = &default_checksum},
              kRecoveryLazyGcOptions) {
-    partition_.Erase()
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    EXPECT_EQ(OkStatus(), partition_.Erase());
     std::memcpy(flash_.buffer().data(),
                 kInitialContents.data(),
                 kInitialContents.size());
diff --git a/pw_kvs/key_value_store_fuzz_test.cc b/pw_kvs/key_value_store_fuzz_test.cc
index f68e75d..74e33ed 100644
--- a/pw_kvs/key_value_store_fuzz_test.cc
+++ b/pw_kvs/key_value_store_fuzz_test.cc
@@ -46,8 +46,7 @@
 
 TEST(KvsFuzz, FuzzTest) {
   FlashPartition& test_partition = FlashTestPartition();
-  test_partition.Erase()
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), test_partition.Erase());
 
   KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs_(&test_partition,
                                                            default_format);
diff --git a/pw_kvs/key_value_store_initialized_test.cc b/pw_kvs/key_value_store_initialized_test.cc
index cc51e7a..2524a96 100644
--- a/pw_kvs/key_value_store_initialized_test.cc
+++ b/pw_kvs/key_value_store_initialized_test.cc
@@ -83,8 +83,7 @@
 class EmptyInitializedKvs : public ::testing::Test {
  protected:
   EmptyInitializedKvs() : kvs_(&test_partition, default_format) {
-    test_partition.Erase()
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    EXPECT_EQ(OkStatus(), test_partition.Erase());
     PW_CHECK_OK(kvs_.Init());
   }
 
@@ -460,8 +459,7 @@
   EXPECT_EQ(test2, value2);
 
   // Delete other key
-  kvs_.Delete(keys[1])
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), kvs_.Delete(keys[1]));
 
   // Verify it was erased
   EXPECT_EQ(kvs_.size(), 0u);
diff --git a/pw_kvs/key_value_store_map_test.cc b/pw_kvs/key_value_store_map_test.cc
index 7c2f1c8..0cf4b9f 100644
--- a/pw_kvs/key_value_store_map_test.cc
+++ b/pw_kvs/key_value_store_map_test.cc
@@ -166,8 +166,7 @@
       label << ((options == kReinitWithPartialGC) ? "PartialGC" : "");
       label << ((kvs_.redundancy() > 1) ? "Redundant" : "");
 
-      partition_.SaveStorageStats(kvs_, label.data())
-          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      ASSERT_EQ(OkStatus(), partition_.SaveStorageStats(kvs_, label.data()));
     }
   }
 
diff --git a/pw_kvs/key_value_store_put_test.cc b/pw_kvs/key_value_store_put_test.cc
index ca87f16..75754cd 100644
--- a/pw_kvs/key_value_store_put_test.cc
+++ b/pw_kvs/key_value_store_put_test.cc
@@ -44,8 +44,8 @@
   // human readable 4 bytes. See pw_kvs/format.h for more information.
   EmptyInitializedKvs()
       : kvs_(&test_partition, {.magic = 0x873a9b50, .checksum = &checksum}) {
-    test_partition.Erase(0, test_partition.sector_count())
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    EXPECT_EQ(OkStatus(),
+              test_partition.Erase(0, test_partition.sector_count()));
     PW_CHECK_OK(kvs_.Init());
   }
 
@@ -70,8 +70,8 @@
     }
   }
 
-  test_partition.SaveStorageStats(kvs_, "Put_VaryingKeysAndValues")
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(),
+            test_partition.SaveStorageStats(kvs_, "Put_VaryingKeysAndValues"));
 }
 
 }  // namespace
diff --git a/pw_kvs/key_value_store_test.cc b/pw_kvs/key_value_store_test.cc
index 8231836..11e4102 100644
--- a/pw_kvs/key_value_store_test.cc
+++ b/pw_kvs/key_value_store_test.cc
@@ -206,8 +206,7 @@
              sizeof(fname_buf),
              "WriteOneKeyMultipleTimes_%d.bin",
              reload);
-    flash.Dump(fname_buf)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), flash.Dump(fname_buf));
   }
 }
 
@@ -236,8 +235,7 @@
     EXPECT_OK(kvs.Put(key.view(), value));
     EXPECT_EQ(kvs.size(), i + 1);
   }
-  flash.Dump("WritingMultipleKeysIncreasesSize.bin")
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), flash.Dump("WritingMultipleKeysIncreasesSize.bin"));
 }
 
 TEST(InMemoryKvs, WriteAndReadOneKey) {
diff --git a/pw_kvs/key_value_store_wear_test.cc b/pw_kvs/key_value_store_wear_test.cc
index 9b1f5bf..506ca4a 100644
--- a/pw_kvs/key_value_store_wear_test.cc
+++ b/pw_kvs/key_value_store_wear_test.cc
@@ -73,8 +73,8 @@
   EXPECT_GE(partition_.min_erase_count(), 7u);
   EXPECT_LE(partition_.max_erase_count(), partition_.min_erase_count() + 1u);
 
-  partition_.SaveStorageStats(kvs_, "WearTest RepeatedLargeEntry")
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(),
+            partition_.SaveStorageStats(kvs_, "WearTest RepeatedLargeEntry"));
 }
 
 // Test a KVS with a number of entries, several sectors that are nearly full
diff --git a/pw_kvs/public/pw_kvs/alignment.h b/pw_kvs/public/pw_kvs/alignment.h
index bdcd7e7..cbb90cb 100644
--- a/pw_kvs/public/pw_kvs/alignment.h
+++ b/pw_kvs/public/pw_kvs/alignment.h
@@ -61,7 +61,7 @@
   AlignedWriter& operator=(const AlignedWriter&) = delete;
 
   ~AlignedWriter() {
-    Flush().IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    Flush().IgnoreError();  // TODO(b/242598609): Handle Status properly
   }
 
   // Writes bytes to the AlignedWriter. The output may be called if the internal
diff --git a/pw_kvs/public/pw_kvs/checksum.h b/pw_kvs/public/pw_kvs/checksum.h
index 9b0f257..9a307ea 100644
--- a/pw_kvs/public/pw_kvs/checksum.h
+++ b/pw_kvs/public/pw_kvs/checksum.h
@@ -91,7 +91,7 @@
  public:
   void Update(span<const std::byte> data) final {
     writer_.Write(data)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   }
 
  protected:
@@ -106,7 +106,7 @@
   static_assert(kBufferSize >= kAlignmentBytes);
 
   void Finalize() final {
-    writer_.Flush().IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    writer_.Flush().IgnoreError();  // TODO(b/242598609): Handle Status properly
     FinalizeAligned();
   }
 
diff --git a/pw_kvs/size_report/base_with_only_flash.cc b/pw_kvs/size_report/base_with_only_flash.cc
index b3873dd..f1fafa9 100644
--- a/pw_kvs/size_report/base_with_only_flash.cc
+++ b/pw_kvs/size_report/base_with_only_flash.cc
@@ -40,20 +40,20 @@
   is_set = (result != nullptr);
 
   test_partition.Erase()
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
 
   std::memset((void*)working_buffer, 0x55, sizeof(working_buffer));
 
   test_partition.Write(0, pw::as_bytes(pw::span(working_buffer)))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
 
   bool tmp_bool;
   test_partition.IsErased(&tmp_bool)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
   is_erased = tmp_bool;
 
   test_partition.Read(0, as_writable_bytes(pw::span(working_buffer)))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
 
   return 0;
 }
diff --git a/pw_kvs/size_report/with_kvs.cc b/pw_kvs/size_report/with_kvs.cc
index fccbab5..eed3e4b 100644
--- a/pw_kvs/size_report/with_kvs.cc
+++ b/pw_kvs/size_report/with_kvs.cc
@@ -49,17 +49,17 @@
       std::memset((void*)working_buffer, 0x55, sizeof(working_buffer));
   is_set = (result != nullptr);
 
-  kvs.Init().IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  kvs.Init().IgnoreError();  // TODO(b/242598609): Handle Status properly
 
   unsigned kvs_value = 42;
   kvs.Put("example_key", kvs_value)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
 
   kvs_entry_count = kvs.size();
 
   unsigned read_value = 0;
   kvs.Get("example_key", &read_value)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
 
   return 0;
 }
diff --git a/pw_log_basic/log_basic.cc b/pw_log_basic/log_basic.cc
index 71a6197..7a4744e 100644
--- a/pw_log_basic/log_basic.cc
+++ b/pw_log_basic/log_basic.cc
@@ -85,7 +85,7 @@
 
 void (*write_log)(std::string_view) = [](std::string_view log) {
   sys_io::WriteLine(log)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
 };
 
 }  // namespace
diff --git a/pw_log_rpc/rpc_log_drain.cc b/pw_log_rpc/rpc_log_drain.cc
index c567d3b..57e5a8c 100644
--- a/pw_log_rpc/rpc_log_drain.cc
+++ b/pw_log_rpc/rpc_log_drain.cc
@@ -123,7 +123,7 @@
     }
 
     encoder.WriteFirstEntrySequenceId(sequence_id_)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     sequence_id_ += packed_entry_count;
     const Status status = server_writer_.Write(encoder);
     sent_bundle_count++;
diff --git a/pw_metric/metric_service_nanopb.cc b/pw_metric/metric_service_nanopb.cc
index 12c6fd5..41ae6af 100644
--- a/pw_metric/metric_service_nanopb.cc
+++ b/pw_metric/metric_service_nanopb.cc
@@ -73,7 +73,7 @@
   void Flush() {
     if (response_.metrics_count) {
       response_writer_.Write(response_)
-          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+          .IgnoreError();  // TODO(b/242598609): Handle Status properly
       response_ = pw_metric_proto_MetricResponse_init_zero;
     }
   }
diff --git a/pw_multisink/public/pw_multisink/multisink.h b/pw_multisink/public/pw_multisink/multisink.h
index 8c3d819..c65d03d 100644
--- a/pw_multisink/public/pw_multisink/multisink.h
+++ b/pw_multisink/public/pw_multisink/multisink.h
@@ -313,7 +313,7 @@
   MultiSink(ByteSpan buffer)
       : ring_buffer_(true), sequence_id_(0), total_ingress_drops_(0) {
     ring_buffer_.SetBuffer(buffer)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     AttachDrain(oldest_entry_drain_);
   }
 
diff --git a/pw_persistent_ram/persistent_buffer_test.cc b/pw_persistent_ram/persistent_buffer_test.cc
index 7b93e9b..adaad30 100644
--- a/pw_persistent_ram/persistent_buffer_test.cc
+++ b/pw_persistent_ram/persistent_buffer_test.cc
@@ -59,8 +59,7 @@
     auto writer = persistent.GetWriter();
     EXPECT_EQ(persistent.size(), 0u);
 
-    writer.Write(as_bytes(span(&kExpectedNumber, 1)))
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), writer.Write(as_bytes(span(&kExpectedNumber, 1))));
     ASSERT_TRUE(persistent.has_value());
 
     persistent.~PersistentBuffer();  // Emulate shutdown / global destructors.
@@ -89,15 +88,13 @@
 
     auto writer = persistent.GetWriter();
     for (size_t i = 0; i < kTestString.length(); i += kWriteSize) {
-      writer
-          .Write(kTestString.data() + i,
-                 std::min(kWriteSize, kTestString.length() - i))
-          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      ASSERT_EQ(OkStatus(),
+                writer.Write(kTestString.data() + i,
+                             std::min(kWriteSize, kTestString.length() - i)));
     }
     // Need to manually write a null terminator since std::string_view doesn't
     // include one in the string length.
-    writer.Write(std::byte(0))
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), writer.Write(std::byte(0)));
 
     persistent.~PersistentBuffer();  // Emulate shutdown / global destructors.
   }
@@ -133,8 +130,7 @@
     EXPECT_EQ(persistent.size(), 0u);
 
     // Write an integer.
-    writer.Write(as_bytes(span(&kTestNumber, 1)))
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), writer.Write(as_bytes(span(&kTestNumber, 1))));
     ASSERT_TRUE(persistent.has_value());
 
     persistent.~PersistentBuffer();  // Emulate shutdown / global destructors.
@@ -148,8 +144,8 @@
     // Write more data.
     auto writer = persistent.GetWriter();
     EXPECT_EQ(persistent.size(), sizeof(kTestNumber));
-    writer.Write(as_bytes(span<const char>(kTestString)))
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(),
+              writer.Write(as_bytes(span<const char>(kTestString))));
 
     persistent.~PersistentBuffer();  // Emulate shutdown / global destructors.
   }
diff --git a/pw_protobuf/codegen_encoder_test.cc b/pw_protobuf/codegen_encoder_test.cc
index 0c3de7d..49f0362 100644
--- a/pw_protobuf/codegen_encoder_test.cc
+++ b/pw_protobuf/codegen_encoder_test.cc
@@ -42,47 +42,39 @@
   stream::MemoryWriter writer(encode_buffer);
 
   Pigweed::StreamEncoder pigweed(writer, temp_buffer);
-  pigweed.WriteMagicNumber(73)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-  pigweed.WriteZiggy(-111)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-  pigweed.WriteErrorMessage("not a typewriter")
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-  pigweed.WriteBin(Pigweed::Protobuf::Binary::ZERO)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), pigweed.WriteMagicNumber(73));
+  ASSERT_EQ(OkStatus(), pigweed.WriteZiggy(-111));
+  ASSERT_EQ(OkStatus(), pigweed.WriteErrorMessage("not a typewriter"));
+  ASSERT_EQ(OkStatus(), pigweed.WriteBin(Pigweed::Protobuf::Binary::ZERO));
 
   {
     Pigweed::Pigweed::StreamEncoder pigweed_pigweed =
         pigweed.GetPigweedEncoder();
-    pigweed_pigweed.WriteStatus(Bool::FILE_NOT_FOUND)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), pigweed_pigweed.WriteStatus(Bool::FILE_NOT_FOUND));
 
     ASSERT_EQ(pigweed_pigweed.status(), OkStatus());
   }
 
   {
     Proto::StreamEncoder proto = pigweed.GetProtoEncoder();
-    proto.WriteBin(Proto::Binary::OFF)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-    proto.WritePigweedPigweedBin(Pigweed::Pigweed::Binary::ZERO)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-    proto.WritePigweedProtobufBin(Pigweed::Protobuf::Binary::ZERO)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), proto.WriteBin(Proto::Binary::OFF));
+    ASSERT_EQ(OkStatus(),
+              proto.WritePigweedPigweedBin(Pigweed::Pigweed::Binary::ZERO));
+    ASSERT_EQ(OkStatus(),
+              proto.WritePigweedProtobufBin(Pigweed::Protobuf::Binary::ZERO));
 
     {
       Pigweed::Protobuf::Compiler::StreamEncoder meta = proto.GetMetaEncoder();
-      meta.WriteFileName("/etc/passwd")
-          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-      meta.WriteStatus(Pigweed::Protobuf::Compiler::Status::FUBAR)
-          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      ASSERT_EQ(OkStatus(), meta.WriteFileName("/etc/passwd"));
+      ASSERT_EQ(OkStatus(),
+                meta.WriteStatus(Pigweed::Protobuf::Compiler::Status::FUBAR));
     }
 
     {
       Pigweed::StreamEncoder nested_pigweed = proto.GetPigweedEncoder();
-      nested_pigweed.WriteErrorMessage("here we go again")
-          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-      nested_pigweed.WriteMagicNumber(616)
-          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      ASSERT_EQ(OkStatus(),
+                nested_pigweed.WriteErrorMessage("here we go again"));
+      ASSERT_EQ(OkStatus(), nested_pigweed.WriteMagicNumber(616));
 
       {
         DeviceInfo::StreamEncoder device_info =
@@ -91,31 +83,26 @@
         {
           KeyValuePair::StreamEncoder attributes =
               device_info.GetAttributesEncoder();
-          attributes.WriteKey("version")
-              .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-          attributes.WriteValue("5.3.1")
-              .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+          ASSERT_EQ(OkStatus(), attributes.WriteKey("version"));
+          ASSERT_EQ(OkStatus(), attributes.WriteValue("5.3.1"));
         }
 
         {
           KeyValuePair::StreamEncoder attributes =
               device_info.GetAttributesEncoder();
-          attributes.WriteKey("chip")
-              .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-          attributes.WriteValue("left-soc")
-              .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+          ASSERT_EQ(OkStatus(), attributes.WriteKey("chip"));
+          ASSERT_EQ(OkStatus(), attributes.WriteValue("left-soc"));
         }
 
-        device_info.WriteStatus(DeviceInfo::DeviceStatus::PANIC)
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        ASSERT_EQ(OkStatus(),
+                  device_info.WriteStatus(DeviceInfo::DeviceStatus::PANIC));
       }
     }
   }
 
   for (int i = 0; i < 5; ++i) {
     Proto::ID::StreamEncoder id = pigweed.GetIdEncoder();
-    id.WriteId(5 * i * i + 3 * i + 49)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), id.WriteId(5 * i * i + 3 * i + 49));
   }
 
   // clang-format off
@@ -206,22 +193,18 @@
   std::byte encode_buffer[(Crate::kMaxEncodedSizeBytes + 12) * 4];
 
   Crate::MemoryEncoder biggest_crate(encode_buffer);
-  biggest_crate.WriteName("Huge crate")
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), biggest_crate.WriteName("Huge crate"));
 
   {
     Crate::StreamEncoder medium_crate = biggest_crate.GetSmallerCratesEncoder();
-    medium_crate.WriteName("Medium crate")
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), medium_crate.WriteName("Medium crate"));
     {
       Crate::StreamEncoder small_crate = medium_crate.GetSmallerCratesEncoder();
-      small_crate.WriteName("Small crate")
-          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      ASSERT_EQ(OkStatus(), small_crate.WriteName("Small crate"));
     }
     {
       Crate::StreamEncoder tiny_crate = medium_crate.GetSmallerCratesEncoder();
-      tiny_crate.WriteName("Tiny crate")
-          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      ASSERT_EQ(OkStatus(), tiny_crate.WriteName("Tiny crate"));
     }
   }
 
@@ -257,13 +240,11 @@
   stream::MemoryWriter writer(encode_buffer);
   RepeatedTest::StreamEncoder repeated_test(writer, ByteSpan());
   for (int i = 0; i < 4; ++i) {
-    repeated_test.WriteUint32s(i * 16)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), repeated_test.WriteUint32s(i * 16));
   }
 
   for (int i = 0; i < 4; ++i) {
-    repeated_test.WriteFixed32s(i * 16)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), repeated_test.WriteFixed32s(i * 16));
   }
 
   // clang-format off
@@ -294,10 +275,8 @@
   stream::MemoryWriter writer(encode_buffer);
   RepeatedTest::StreamEncoder repeated_test(writer, ByteSpan());
   constexpr uint32_t values[] = {0, 16, 32, 48};
-  repeated_test.WriteUint32s(values)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-  repeated_test.WriteFixed32s(values)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), repeated_test.WriteUint32s(values));
+  ASSERT_EQ(OkStatus(), repeated_test.WriteFixed32s(values));
 
   // clang-format off
   constexpr uint8_t expected_proto[] = {
@@ -329,8 +308,7 @@
   stream::MemoryWriter writer(encode_buffer);
   RepeatedTest::StreamEncoder repeated_test(writer, ByteSpan());
   constexpr bool values[] = {true, false, true, true, false};
-  repeated_test.WriteBools(span(values))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), repeated_test.WriteBools(span(values)));
 
   // clang-format off
   constexpr uint8_t expected_proto[] = {
@@ -352,10 +330,8 @@
   stream::MemoryWriter writer(encode_buffer);
   RepeatedTest::StreamEncoder repeated_test(writer, ByteSpan());
   const pw::Vector<uint32_t, 4> values = {0, 16, 32, 48};
-  repeated_test.WriteUint32s(values)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-  repeated_test.WriteFixed32s(values)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), repeated_test.WriteUint32s(values));
+  ASSERT_EQ(OkStatus(), repeated_test.WriteFixed32s(values));
 
   // clang-format off
   constexpr uint8_t expected_proto[] = {
@@ -433,8 +409,7 @@
   RepeatedTest::StreamEncoder repeated_test(writer, ByteSpan());
   constexpr const char* strings[] = {"the", "quick", "brown", "fox"};
   for (const char* s : strings) {
-    repeated_test.WriteStrings(s)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), repeated_test.WriteStrings(s));
   }
 
   constexpr uint8_t expected_proto[] = {
@@ -453,10 +428,8 @@
   RepeatedTest::MemoryEncoder repeated_test(encode_buffer);
   for (int i = 0; i < 3; ++i) {
     auto structs = repeated_test.GetStructsEncoder();
-    structs.WriteOne(i * 1)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-    structs.WriteTwo(i * 2)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), structs.WriteOne(i * 1));
+    ASSERT_EQ(OkStatus(), structs.WriteTwo(i * 2));
   }
 
   // clang-format off
@@ -476,14 +449,13 @@
   std::byte encode_buffer[Foo::kMaxEncodedSizeBytes];
 
   Foo::MemoryEncoder foo(encode_buffer);
-  foo.WriteInteger(3).IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), foo.WriteInteger(3));
 
   {
     constexpr std::byte data[] = {
         std::byte(0xde), std::byte(0xad), std::byte(0xbe), std::byte(0xef)};
     Bar::StreamEncoder bar = foo.GetBarEncoder();
-    bar.WriteData(data)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), bar.WriteData(data));
   }
 
   constexpr uint8_t expected_proto[] = {
@@ -502,18 +474,14 @@
   Period::MemoryEncoder period(encode_buffer);
   {
     imported::Timestamp::StreamEncoder start = period.GetStartEncoder();
-    start.WriteSeconds(1589501793)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-    start.WriteNanoseconds(511613110)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), start.WriteSeconds(1589501793));
+    ASSERT_EQ(OkStatus(), start.WriteNanoseconds(511613110));
   }
 
   {
     imported::Timestamp::StreamEncoder end = period.GetEndEncoder();
-    end.WriteSeconds(1589501841)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-    end.WriteNanoseconds(490367432)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), end.WriteSeconds(1589501841));
+    ASSERT_EQ(OkStatus(), end.WriteNanoseconds(490367432));
   }
 
   EXPECT_EQ(period.status(), OkStatus());
@@ -525,10 +493,8 @@
   std::array<const int64_t, 2> repeated = {0, 1};
   stream::MemoryWriter writer(encode_buffer);
   Packed::StreamEncoder packed(writer, ByteSpan());
-  packed.WriteRep(span<const int64_t>(repeated))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-  packed.WritePacked("packed")
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), packed.WriteRep(span<const int64_t>(repeated)));
+  ASSERT_EQ(OkStatus(), packed.WritePacked("packed"));
 
   EXPECT_EQ(packed.status(), OkStatus());
 }
diff --git a/pw_protobuf/decoder_test.cc b/pw_protobuf/decoder_test.cc
index 37a09df..c922836 100644
--- a/pw_protobuf/decoder_test.cc
+++ b/pw_protobuf/decoder_test.cc
@@ -28,28 +28,22 @@
 
     switch (field_number) {
       case 1:
-        decoder.ReadInt32(&test_int32)
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        EXPECT_EQ(OkStatus(), decoder.ReadInt32(&test_int32));
         break;
       case 2:
-        decoder.ReadSint32(&test_sint32)
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        EXPECT_EQ(OkStatus(), decoder.ReadSint32(&test_sint32));
         break;
       case 3:
-        decoder.ReadBool(&test_bool)
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        EXPECT_EQ(OkStatus(), decoder.ReadBool(&test_bool));
         break;
       case 4:
-        decoder.ReadDouble(&test_double)
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        EXPECT_EQ(OkStatus(), decoder.ReadDouble(&test_double));
         break;
       case 5:
-        decoder.ReadFixed32(&test_fixed32)
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        EXPECT_EQ(OkStatus(), decoder.ReadFixed32(&test_fixed32));
         break;
       case 6:
-        decoder.ReadString(&str)
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        EXPECT_EQ(OkStatus(), decoder.ReadString(&str));
         std::memcpy(test_string, str.data(), str.size());
         test_string[str.size()] = '\0';
         break;
diff --git a/pw_protobuf/encoder.cc b/pw_protobuf/encoder.cc
index c7209f2..627baef 100644
--- a/pw_protobuf/encoder.cc
+++ b/pw_protobuf/encoder.cc
@@ -122,7 +122,7 @@
       field_number, WireType::kVarint, varint::EncodedSize(value)));
 
   WriteVarint(FieldKey(field_number, WireType::kVarint))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
   return WriteVarint(value);
 }
 
@@ -177,7 +177,7 @@
   PW_TRY(UpdateStatusForWrite(field_number, type, data.size()));
 
   WriteVarint(FieldKey(field_number, type))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
   if (Status status = writer_.Write(data); !status.ok()) {
     status_ = status;
   }
@@ -197,9 +197,9 @@
   PW_TRY(UpdateStatusForWrite(
       field_number, WireType::kDelimited, values.size_bytes()));
   WriteVarint(FieldKey(field_number, WireType::kDelimited))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
   WriteVarint(values.size_bytes())
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
 
   for (auto val_start = values.begin(); val_start != values.end();
        val_start += elem_size) {
diff --git a/pw_protobuf/encoder_fuzzer.cc b/pw_protobuf/encoder_fuzzer.cc
index 7f05783..a0e695e 100644
--- a/pw_protobuf/encoder_fuzzer.cc
+++ b/pw_protobuf/encoder_fuzzer.cc
@@ -152,163 +152,163 @@
         encoder
             .WriteUint32(provider.ConsumeIntegral<uint32_t>(),
                          provider.ConsumeIntegral<uint32_t>())
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kPackedUint32:
         encoder
             .WritePackedUint32(provider.ConsumeIntegral<uint32_t>(),
                                ConsumeSpan<uint32_t>(&provider, &u32s))
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kUint64:
         encoder
             .WriteUint64(provider.ConsumeIntegral<uint32_t>(),
                          provider.ConsumeIntegral<uint64_t>())
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kPackedUint64:
         encoder
             .WritePackedUint64(provider.ConsumeIntegral<uint32_t>(),
                                ConsumeSpan<uint64_t>(&provider, &u64s))
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kInt32:
         encoder
             .WriteInt32(provider.ConsumeIntegral<uint32_t>(),
                         provider.ConsumeIntegral<int32_t>())
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kPackedInt32:
         encoder
             .WritePackedInt32(provider.ConsumeIntegral<uint32_t>(),
                               ConsumeSpan<int32_t>(&provider, &s32s))
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kInt64:
         encoder
             .WriteInt64(provider.ConsumeIntegral<uint32_t>(),
                         provider.ConsumeIntegral<int64_t>())
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kPackedInt64:
         encoder
             .WritePackedInt64(provider.ConsumeIntegral<uint32_t>(),
                               ConsumeSpan<int64_t>(&provider, &s64s))
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kSint32:
         encoder
             .WriteSint32(provider.ConsumeIntegral<uint32_t>(),
                          provider.ConsumeIntegral<int32_t>())
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kPackedSint32:
         encoder
             .WritePackedSint32(provider.ConsumeIntegral<uint32_t>(),
                                ConsumeSpan<int32_t>(&provider, &s32s))
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kSint64:
         encoder
             .WriteSint64(provider.ConsumeIntegral<uint32_t>(),
                          provider.ConsumeIntegral<int64_t>())
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kPackedSint64:
         encoder
             .WritePackedSint64(provider.ConsumeIntegral<uint32_t>(),
                                ConsumeSpan<int64_t>(&provider, &s64s))
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kBool:
         encoder
             .WriteBool(provider.ConsumeIntegral<uint32_t>(),
                        provider.ConsumeBool())
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kFixed32:
         encoder
             .WriteFixed32(provider.ConsumeIntegral<uint32_t>(),
                           provider.ConsumeIntegral<uint32_t>())
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kPackedFixed32:
         encoder
             .WritePackedFixed32(provider.ConsumeIntegral<uint32_t>(),
                                 ConsumeSpan<uint32_t>(&provider, &u32s))
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kFixed64:
         encoder
             .WriteFixed64(provider.ConsumeIntegral<uint32_t>(),
                           provider.ConsumeIntegral<uint64_t>())
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kPackedFixed64:
         encoder
             .WritePackedFixed64(provider.ConsumeIntegral<uint32_t>(),
                                 ConsumeSpan<uint64_t>(&provider, &u64s))
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kSfixed32:
         encoder
             .WriteSfixed32(provider.ConsumeIntegral<uint32_t>(),
                            provider.ConsumeIntegral<int32_t>())
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kPackedSfixed32:
         encoder
             .WritePackedSfixed32(provider.ConsumeIntegral<uint32_t>(),
                                  ConsumeSpan<int32_t>(&provider, &s32s))
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kSfixed64:
         encoder
             .WriteSfixed64(provider.ConsumeIntegral<uint32_t>(),
                            provider.ConsumeIntegral<int64_t>())
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kPackedSfixed64:
         encoder
             .WritePackedSfixed64(provider.ConsumeIntegral<uint32_t>(),
                                  ConsumeSpan<int64_t>(&provider, &s64s))
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kFloat:
         encoder
             .WriteFloat(provider.ConsumeIntegral<uint32_t>(),
                         provider.ConsumeFloatingPoint<float>())
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kPackedFloat:
         encoder
             .WritePackedFloat(provider.ConsumeIntegral<uint32_t>(),
                               ConsumeSpan<float>(&provider, &floats))
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kDouble:
         encoder
             .WriteDouble(provider.ConsumeIntegral<uint32_t>(),
                          provider.ConsumeFloatingPoint<double>())
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kPackedDouble:
         encoder
             .WritePackedDouble(provider.ConsumeIntegral<uint32_t>(),
                                ConsumeSpan<double>(&provider, &doubles))
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kBytes:
         encoder
             .WriteBytes(provider.ConsumeIntegral<uint32_t>(),
                         ConsumeBytes(&provider, &bytes))
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kString:
         encoder
             .WriteString(provider.ConsumeIntegral<uint32_t>(),
                          ConsumeString(&provider, &strings))
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
       case kPush:
         // Special "field". The marks the start of a nested message.
diff --git a/pw_protobuf/encoder_test.cc b/pw_protobuf/encoder_test.cc
index 4833814..e6bc2bd 100644
--- a/pw_protobuf/encoder_test.cc
+++ b/pw_protobuf/encoder_test.cc
@@ -261,8 +261,7 @@
   // repeated uint32 values = 1;
   constexpr uint32_t values[] = {0, 50, 100, 150, 200};
   for (int i = 0; i < 5; ++i) {
-    encoder.WriteUint32(1, values[i])
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(), encoder.WriteUint32(1, values[i]));
   }
 
   constexpr uint8_t encoded_proto[] = {
@@ -281,8 +280,7 @@
 
   // repeated uint32 values = 1;
   constexpr uint32_t values[] = {0, 50, 100, 150, 200};
-  encoder.WritePackedUint32(1, values)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), encoder.WritePackedUint32(1, values));
 
   constexpr uint8_t encoded_proto[] = {
       0x0a, 0x07, 0x00, 0x32, 0x64, 0x96, 0x01, 0xc8, 0x01};
@@ -300,8 +298,7 @@
   MemoryEncoder encoder(encode_buffer);
 
   constexpr uint32_t values[] = {0, 50, 100, 150, 200};
-  encoder.WritePackedUint32(1, values)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(Status::ResourceExhausted(), encoder.WritePackedUint32(1, values));
 
   EXPECT_EQ(encoder.status(), Status::ResourceExhausted());
 }
@@ -312,8 +309,7 @@
 
   // repeated uint32 values = 1;
   const pw::Vector<uint32_t, 5> values = {0, 50, 100, 150, 200};
-  encoder.WriteRepeatedUint32(1, values)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), encoder.WriteRepeatedUint32(1, values));
 
   constexpr uint8_t encoded_proto[] = {
       0x0a, 0x07, 0x00, 0x32, 0x64, 0x96, 0x01, 0xc8, 0x01};
@@ -331,8 +327,8 @@
   MemoryEncoder encoder(encode_buffer);
 
   const pw::Vector<uint32_t, 5> values = {0, 50, 100, 150, 200};
-  encoder.WriteRepeatedUint32(1, values)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(Status::ResourceExhausted(),
+            encoder.WriteRepeatedUint32(1, values));
 
   EXPECT_EQ(encoder.status(), Status::ResourceExhausted());
 }
@@ -343,8 +339,7 @@
 
   // repeated bool values = 1;
   constexpr bool values[] = {true, false, true, true, false};
-  encoder.WritePackedBool(1, values)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), encoder.WritePackedBool(1, values));
 
   constexpr uint8_t encoded_proto[] = {
       0x0a, 0x05, 0x01, 0x00, 0x01, 0x01, 0x00};
@@ -363,13 +358,11 @@
 
   // repeated fixed32 values = 1;
   constexpr uint32_t values[] = {0, 50, 100, 150, 200};
-  encoder.WritePackedFixed32(1, values)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), encoder.WritePackedFixed32(1, values));
 
   // repeated fixed64 values64 = 2;
   constexpr uint64_t values64[] = {0x0102030405060708};
-  encoder.WritePackedFixed64(2, values64)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), encoder.WritePackedFixed64(2, values64));
 
   constexpr uint8_t encoded_proto[] = {
       0x0a, 0x14, 0x00, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x64,
@@ -389,13 +382,11 @@
 
   // repeated fixed32 values = 1;
   const pw::Vector<uint32_t, 5> values = {0, 50, 100, 150, 200};
-  encoder.WriteRepeatedFixed32(1, values)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), encoder.WriteRepeatedFixed32(1, values));
 
   // repeated fixed64 values64 = 2;
   const pw::Vector<uint64_t, 1> values64 = {0x0102030405060708};
-  encoder.WriteRepeatedFixed64(2, values64)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), encoder.WriteRepeatedFixed64(2, values64));
 
   constexpr uint8_t encoded_proto[] = {
       0x0a, 0x14, 0x00, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x64,
@@ -415,8 +406,7 @@
 
   // repeated sint32 values = 1;
   constexpr int32_t values[] = {-100, -25, -1, 0, 1, 25, 100};
-  encoder.WritePackedSint32(1, values)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), encoder.WritePackedSint32(1, values));
 
   constexpr uint8_t encoded_proto[] = {
       0x0a, 0x09, 0xc7, 0x01, 0x31, 0x01, 0x00, 0x02, 0x32, 0xc8, 0x01};
@@ -434,8 +424,7 @@
 
   // repeated sint32 values = 1;
   const pw::Vector<int32_t, 7> values = {-100, -25, -1, 0, 1, 25, 100};
-  encoder.WriteRepeatedSint32(1, values)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), encoder.WriteRepeatedSint32(1, values));
 
   constexpr uint8_t encoded_proto[] = {
       0x0a, 0x09, 0xc7, 0x01, 0x31, 0x01, 0x00, 0x02, 0x32, 0xc8, 0x01};
diff --git a/pw_protobuf/find_test.cc b/pw_protobuf/find_test.cc
index b1092e6..bacac86 100644
--- a/pw_protobuf/find_test.cc
+++ b/pw_protobuf/find_test.cc
@@ -45,8 +45,7 @@
   FindDecodeHandler finder(3);
 
   decoder.set_handler(&finder);
-  decoder.Decode(as_bytes(span(encoded_proto)))
-      .IgnoreError(); // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(Status::Cancelled(), decoder.Decode(as_bytes(span(encoded_proto))));
 
   EXPECT_TRUE(finder.found());
   EXPECT_TRUE(decoder.cancelled());
@@ -57,8 +56,7 @@
   FindDecodeHandler finder(8);
 
   decoder.set_handler(&finder);
-  decoder.Decode(as_bytes(span(encoded_proto)))
-      .IgnoreError(); // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), decoder.Decode(as_bytes(span(encoded_proto))));
 
   EXPECT_FALSE(finder.found());
   EXPECT_FALSE(decoder.cancelled());
@@ -70,8 +68,7 @@
   FindDecodeHandler finder(7, &nested_finder);
 
   decoder.set_handler(&finder);
-  decoder.Decode(as_bytes(span(encoded_proto)))
-      .IgnoreError(); // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(Status::Cancelled(), decoder.Decode(as_bytes(span(encoded_proto))));
 
   EXPECT_TRUE(finder.found());
   EXPECT_TRUE(nested_finder.found());
@@ -84,8 +81,7 @@
   FindDecodeHandler finder(7, &nested_finder);
 
   decoder.set_handler(&finder);
-  decoder.Decode(as_bytes(span(encoded_proto)))
-      .IgnoreError(); // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), decoder.Decode(as_bytes(span(encoded_proto))));
 
   EXPECT_TRUE(finder.found());
   EXPECT_FALSE(nested_finder.found());
diff --git a/pw_protobuf/public/pw_protobuf/encoder.h b/pw_protobuf/public/pw_protobuf/encoder.h
index 2f8701f..119bfd6 100644
--- a/pw_protobuf/public/pw_protobuf/encoder.h
+++ b/pw_protobuf/public/pw_protobuf/encoder.h
@@ -719,16 +719,16 @@
     }
 
     WriteVarint(FieldKey(field_number, WireType::kDelimited))
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     WriteVarint(payload_size)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     for (T value : values) {
       if (encode_type == VarintType::kZigZag) {
         WriteZigzagVarint(static_cast<std::make_signed_t<T>>(value))
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
       } else {
         WriteVarint(value)
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
       }
     }
 
diff --git a/pw_ring_buffer/prefixed_entry_ring_buffer.cc b/pw_ring_buffer/prefixed_entry_ring_buffer.cc
index e2f7f7b..93f70f7 100644
--- a/pw_ring_buffer/prefixed_entry_ring_buffer.cc
+++ b/pw_ring_buffer/prefixed_entry_ring_buffer.cc
@@ -227,7 +227,7 @@
   for (Reader& reader : readers_) {
     if (reader.entry_count_ == entry_count) {
       reader.PopFront()
-          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+          .IgnoreError();  // TODO(b/242598609): Handle Status properly
     }
   }
 }
diff --git a/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc b/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc
index 891cb6f..88ed331 100644
--- a/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc
+++ b/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc
@@ -331,8 +331,7 @@
       // wrapped.
       for (i = 0; i < (kTotalEntryCount * (main_loop_count % 64u)); i++) {
         memset(single_entry_buffer, i, sizeof(single_entry_buffer));
-        ring.PushBack(single_entry_buffer)
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        ASSERT_EQ(OkStatus(), ring.PushBack(single_entry_buffer));
       }
     }
 
@@ -350,8 +349,7 @@
       }
 
       // The ring buffer internally pushes the varint size byte.
-      ring.PushBack(single_entry_buffer)
-          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      ASSERT_EQ(OkStatus(), ring.PushBack(single_entry_buffer));
     }
 
     // Check values before doing the dering.
diff --git a/pw_ring_buffer/public/pw_ring_buffer/prefixed_entry_ring_buffer.h b/pw_ring_buffer/public/pw_ring_buffer/prefixed_entry_ring_buffer.h
index 654bd57..e2f2adb 100644
--- a/pw_ring_buffer/public/pw_ring_buffer/prefixed_entry_ring_buffer.h
+++ b/pw_ring_buffer/public/pw_ring_buffer/prefixed_entry_ring_buffer.h
@@ -510,7 +510,7 @@
   PrefixedEntryRingBuffer(bool user_preamble = false)
       : PrefixedEntryRingBufferMulti(user_preamble) {
     AttachReader(*this)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   }
 };
 
diff --git a/pw_ring_buffer/size_report/ring_buffer_multi.cc b/pw_ring_buffer/size_report/ring_buffer_multi.cc
index 5570469..c4e9232 100644
--- a/pw_ring_buffer/size_report/ring_buffer_multi.cc
+++ b/pw_ring_buffer/size_report/ring_buffer_multi.cc
@@ -36,7 +36,7 @@
   pw::ring_buffer::PrefixedEntryRingBufferMulti::Reader readers[kReaderCount];
   for (auto& reader : readers) {
     ring.AttachReader(reader)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   }
 
   // Push entries until the buffer is full.
@@ -94,7 +94,7 @@
 
   for (auto& reader : readers) {
     ring.DetachReader(reader)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   }
   ring.Clear();
   return 0;
diff --git a/pw_rpc/benchmark.cc b/pw_rpc/benchmark.cc
index 1ecdb9a..dfa11b6 100644
--- a/pw_rpc/benchmark.cc
+++ b/pw_rpc/benchmark.cc
@@ -47,7 +47,7 @@
     Status status = reader_writer_.Write(request);
     if (!status.ok()) {
       reader_writer_.Finish(status)
-          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+          .IgnoreError();  // TODO(b/242598609): Handle Status properly
     }
   });
 }
diff --git a/pw_rpc/raw/method_union_test.cc b/pw_rpc/raw/method_union_test.cc
index 110ca5f..b57fba9 100644
--- a/pw_rpc/raw/method_union_test.cc
+++ b/pw_rpc/raw/method_union_test.cc
@@ -83,12 +83,10 @@
 
       switch (field) {
         case TestRequest::Fields::INTEGER:
-          decoder.ReadInt64(&last_request.integer)
-              .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+          ASSERT_EQ(OkStatus(), decoder.ReadInt64(&last_request.integer));
           break;
         case TestRequest::Fields::STATUS_CODE:
-          decoder.ReadUint32(&last_request.status_code)
-              .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+          ASSERT_EQ(OkStatus(), decoder.ReadUint32(&last_request.status_code));
           break;
       }
     }
@@ -99,10 +97,8 @@
   std::byte buffer[16];
 
   TestRequest::MemoryEncoder test_request(buffer);
-  test_request.WriteInteger(456)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-  test_request.WriteStatusCode(7)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), test_request.WriteInteger(456));
+  ASSERT_EQ(OkStatus(), test_request.WriteStatusCode(7));
 
   const Method& method =
       std::get<1>(FakeGeneratedServiceImpl::kMethods).method();
@@ -127,10 +123,8 @@
   std::byte buffer[16];
 
   TestRequest::MemoryEncoder test_request(buffer);
-  test_request.WriteInteger(777)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-  test_request.WriteStatusCode(2)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), test_request.WriteInteger(777));
+  ASSERT_EQ(OkStatus(), test_request.WriteStatusCode(2));
 
   const Method& method =
       std::get<2>(FakeGeneratedServiceImpl::kMethods).method();
diff --git a/pw_rpc/size_report/base.cc b/pw_rpc/size_report/base.cc
index 76043ab..5248c80 100644
--- a/pw_rpc/size_report/base.cc
+++ b/pw_rpc/size_report/base.cc
@@ -28,9 +28,9 @@
 
   std::byte packet_buffer[128];
   pw::sys_io::ReadBytes(packet_buffer)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
   pw::sys_io::WriteBytes(packet_buffer)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
 
   return static_cast<int>(packet_buffer[92]);
 }
diff --git a/pw_rpc/size_report/server_only.cc b/pw_rpc/size_report/server_only.cc
index 007fbb6..97c91f9 100644
--- a/pw_rpc/size_report/server_only.cc
+++ b/pw_rpc/size_report/server_only.cc
@@ -46,12 +46,12 @@
 
   std::byte packet_buffer[128];
   pw::sys_io::ReadBytes(packet_buffer)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
   pw::sys_io::WriteBytes(packet_buffer)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
 
   my_product::server.ProcessPacket(packet_buffer, my_product::output)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
 
   return static_cast<int>(packet_buffer[92]);
 }
diff --git a/pw_snapshot/cpp_compile_test.cc b/pw_snapshot/cpp_compile_test.cc
index 1332ad7..43d35fd 100644
--- a/pw_snapshot/cpp_compile_test.cc
+++ b/pw_snapshot/cpp_compile_test.cc
@@ -30,15 +30,15 @@
   {
     Metadata::StreamEncoder metadata_encoder =
         snapshot_encoder.GetMetadataEncoder();
-    metadata_encoder
-        .WriteReason(as_bytes(span("It just died, I didn't do anything")))
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-    metadata_encoder.WriteFatal(true)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-    metadata_encoder.WriteProjectName(as_bytes(span("smart-shoe")))
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-    metadata_encoder.WriteDeviceName(as_bytes(span("smart-shoe-p1")))
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    ASSERT_EQ(OkStatus(),
+              metadata_encoder.WriteReason(
+                  as_bytes(span("It just died, I didn't do anything"))));
+    ASSERT_EQ(OkStatus(), metadata_encoder.WriteFatal(true));
+    ASSERT_EQ(OkStatus(),
+              metadata_encoder.WriteProjectName(as_bytes(span("smart-shoe"))));
+    ASSERT_EQ(
+        OkStatus(),
+        metadata_encoder.WriteDeviceName(as_bytes(span("smart-shoe-p1"))));
   }
   ASSERT_TRUE(snapshot_encoder.status().ok());
 }
diff --git a/pw_spi/public/pw_spi/device.h b/pw_spi/public/pw_spi/device.h
index d6a2cf7..3701155 100644
--- a/pw_spi/public/pw_spi/device.h
+++ b/pw_spi/public/pw_spi/device.h
@@ -93,7 +93,7 @@
           (behavior_ == ChipSelectBehavior::kPerTransaction) &&
           (!first_write_read_)) {
         selector_->Deactivate()
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
       }
     }
 
diff --git a/pw_string/size_report/format_many_without_error_handling.cc b/pw_string/size_report/format_many_without_error_handling.cc
index f38adac..fc46002 100644
--- a/pw_string/size_report/format_many_without_error_handling.cc
+++ b/pw_string/size_report/format_many_without_error_handling.cc
@@ -28,7 +28,7 @@
 
 #define FORMAT_CASE(...)                  \
   pw::string::Format(buffer, __VA_ARGS__) \
-      .IgnoreError()  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError()  // TODO(b/242598609): Handle Status properly
 
 #else  // std::snprintf
 
diff --git a/pw_trace/example/sample_app.cc b/pw_trace/example/sample_app.cc
index 49eff59..016f778 100644
--- a/pw_trace/example/sample_app.cc
+++ b/pw_trace/example/sample_app.cc
@@ -79,7 +79,7 @@
     pw::span<std::byte> buf_span = pw::span<std::byte>(
         reinterpret_cast<std::byte*>(jobs_buffer_), sizeof(jobs_buffer_));
     jobs_.SetBuffer(buf_span)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   }
   const char* Name() const override { return "Processing Task"; }
   bool ShouldRun() override { return jobs_.EntryCount() > 0; }
@@ -92,8 +92,9 @@
 
     // Get the next job from the queue.
     jobs_.PeekFront(job_bytes.bytes, &bytes_read)
-        .IgnoreError();              // TODO(pwbug/387): Handle Status properly
-    jobs_.PopFront().IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
+    jobs_.PopFront()
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     Job& job = job_bytes.job;
 
     // Process the job
@@ -138,7 +139,7 @@
   void AddJobInternal(uint32_t job_id, uint8_t value) {
     JobBytes job{.job = {.job_id = job_id, .value = value}};
     jobs_.PushBack(job.bytes)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   }
 } processing_task;
 
diff --git a/pw_trace_tokenized/example/filter.cc b/pw_trace_tokenized/example/filter.cc
index 6d68fb9..f76f64c 100644
--- a/pw_trace_tokenized/example/filter.cc
+++ b/pw_trace_tokenized/example/filter.cc
@@ -57,7 +57,7 @@
   // Register filter callback
   pw::trace::Callbacks::Instance()
       .RegisterEventCallback(TraceEventCallback)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
 
   PW_TRACE_SET_ENABLED(true);  // Start with tracing enabled
 
diff --git a/pw_trace_tokenized/example/public/pw_trace_tokenized/example/trace_to_file.h b/pw_trace_tokenized/example/public/pw_trace_tokenized/example/trace_to_file.h
index 7527143..6b3a6f6 100644
--- a/pw_trace_tokenized/example/public/pw_trace_tokenized/example/trace_to_file.h
+++ b/pw_trace_tokenized/example/public/pw_trace_tokenized/example/trace_to_file.h
@@ -35,14 +35,14 @@
                       TraceSinkEndBlock,
                       &out_,
                       &sink_handle_)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     out_.open(file_name, std::ios::out | std::ios::binary);
   }
 
   ~TraceToFile() {
     Callbacks::Instance()
         .UnregisterSink(sink_handle_)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     out_.close();
   }
 
diff --git a/pw_trace_tokenized/example/trigger.cc b/pw_trace_tokenized/example/trigger.cc
index 1995aff..7f84db4 100644
--- a/pw_trace_tokenized/example/trigger.cc
+++ b/pw_trace_tokenized/example/trigger.cc
@@ -80,7 +80,7 @@
   pw::trace::Callbacks::Instance()
       .RegisterEventCallback(TraceEventCallback,
                              pw::trace::CallbacksImpl::kCallOnEveryEvent)
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+      .IgnoreError();  // TODO(b/242598609): Handle Status properly
 
   // Ensure tracing is off at start, the trigger will turn it on.
   PW_TRACE_SET_ENABLED(false);
diff --git a/pw_trace_tokenized/public/pw_trace_tokenized/trace_callback.h b/pw_trace_tokenized/public/pw_trace_tokenized/trace_callback.h
index 5dc1cbe..f3d460a 100644
--- a/pw_trace_tokenized/public/pw_trace_tokenized/trace_callback.h
+++ b/pw_trace_tokenized/public/pw_trace_tokenized/trace_callback.h
@@ -212,7 +212,7 @@
       void* user_data = nullptr) {
     Callbacks::Instance()
         .RegisterEventCallback(event_callback, called_on_every_event, user_data)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   }
   RegisterCallbackWhenCreated(CallbacksImpl::SinkStartBlock sink_start,
                               CallbacksImpl::SinkAddBytes sink_add_bytes,
@@ -220,7 +220,7 @@
                               void* user_data = nullptr) {
     Callbacks::Instance()
         .RegisterSink(sink_start, sink_add_bytes, sink_end, user_data)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   }
 };
 
diff --git a/pw_trace_tokenized/trace.cc b/pw_trace_tokenized/trace.cc
index 4eda181..693c67f 100644
--- a/pw_trace_tokenized/trace.cc
+++ b/pw_trace_tokenized/trace.cc
@@ -229,7 +229,7 @@
 pw::Status CallbacksImpl::UnregisterAllSinks() {
   for (size_t sink_idx = 0; sink_idx < PW_TRACE_CONFIG_MAX_SINKS; sink_idx++) {
     UnregisterSink(sink_idx)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   }
   return PW_STATUS_OK;
 }
@@ -282,7 +282,7 @@
 pw::Status CallbacksImpl::UnregisterAllEventCallbacks() {
   for (size_t i = 0; i < PW_TRACE_CONFIG_MAX_EVENT_CALLBACKS; i++) {
     UnregisterEventCallback(i)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   }
   return PW_STATUS_OK;
 }
diff --git a/pw_trace_tokenized/trace_buffer.cc b/pw_trace_tokenized/trace_buffer.cc
index 23dffe0..b1de8e7 100644
--- a/pw_trace_tokenized/trace_buffer.cc
+++ b/pw_trace_tokenized/trace_buffer.cc
@@ -27,11 +27,11 @@
  public:
   TraceBuffer() {
     ring_buffer_.SetBuffer(raw_buffer_)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     Callbacks::Instance()
         .RegisterSink(
             TraceSinkStartBlock, TraceSinkAddBytes, TraceSinkEndBlock, this)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   }
 
   static void TraceSinkStartBlock(void* user_data, size_t size) {
@@ -64,7 +64,7 @@
     buffer->ring_buffer_
         .PushBack(span<const std::byte>(&buffer->current_block_[0],
                                         buffer->block_size_))
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   }
 
   pw::ring_buffer::PrefixedEntryRingBuffer& RingBuffer() {
@@ -73,7 +73,7 @@
 
   ConstByteSpan DeringAndViewRawBuffer() {
     ring_buffer_.Dering()
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     return ByteSpan(raw_buffer_, ring_buffer_.TotalUsedBytes());
   }
 
diff --git a/pw_trace_tokenized/trace_buffer_log.cc b/pw_trace_tokenized/trace_buffer_log.cc
index b7fae67..8a58cc0 100644
--- a/pw_trace_tokenized/trace_buffer_log.cc
+++ b/pw_trace_tokenized/trace_buffer_log.cc
@@ -55,7 +55,7 @@
   while (trace_buffer->PeekFront(span(entry_buffer).subspan(1), &bytes_read) !=
          pw::Status::OutOfRange()) {
     trace_buffer->PopFront()
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     entry_buffer[0] = static_cast<std::byte>(bytes_read);
     // The entry buffer is formatted as (size, entry) with an extra byte as
     // a header to the entry. The calcuation of bytes_read + 1 represents
diff --git a/pw_trace_tokenized/trace_buffer_log_test.cc b/pw_trace_tokenized/trace_buffer_log_test.cc
index 328706c..4f89fcf 100644
--- a/pw_trace_tokenized/trace_buffer_log_test.cc
+++ b/pw_trace_tokenized/trace_buffer_log_test.cc
@@ -19,6 +19,9 @@
 #include "gtest/gtest.h"
 #include "pw_trace/trace.h"
 
+namespace pw::trace {
+namespace {
+
 TEST(TokenizedTrace, DumpSmallBuffer) {
   // TODO(b/235283406): This test only verifies that the dump function does not
   // crash, and requires manual inspection to confirm that the log output is
@@ -27,8 +30,7 @@
   PW_TRACE_SET_ENABLED(true);
   PW_TRACE_INSTANT("test1");
   PW_TRACE_INSTANT("test2");
-  pw::trace::DumpTraceBufferToLog()
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), pw::trace::DumpTraceBufferToLog());
 }
 
 TEST(TokenizedTrace, DumpLargeBuffer) {
@@ -40,6 +42,8 @@
   for (int i = 0; i < 100; i++) {
     PW_TRACE_INSTANT("test");
   }
-  pw::trace::DumpTraceBufferToLog()
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(OkStatus(), pw::trace::DumpTraceBufferToLog());
 }
+
+}  // namespace
+}  // namespace pw::trace
diff --git a/pw_trace_tokenized/trace_rpc_service_nanopb.cc b/pw_trace_tokenized/trace_rpc_service_nanopb.cc
index 8398f79..38e8d82 100644
--- a/pw_trace_tokenized/trace_rpc_service_nanopb.cc
+++ b/pw_trace_tokenized/trace_rpc_service_nanopb.cc
@@ -45,7 +45,7 @@
   while (trace_buffer->PeekFront(as_writable_bytes(span(buffer.data.bytes)),
                                  &size) != pw::Status::OutOfRange()) {
     trace_buffer->PopFront()
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     buffer.data.size = size;
     pw::Status status = writer.Write(buffer);
     if (!status.ok()) {
@@ -54,6 +54,6 @@
       break;
     }
   }
-  writer.Finish().IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  writer.Finish().IgnoreError();  // TODO(b/242598609): Handle Status properly
 }
 }  // namespace pw::trace
diff --git a/pw_trace_tokenized/trace_test.cc b/pw_trace_tokenized/trace_test.cc
index d2dd316..de03b3d 100644
--- a/pw_trace_tokenized/trace_test.cc
+++ b/pw_trace_tokenized/trace_test.cc
@@ -56,27 +56,25 @@
 
   TraceTestInterface() {
     PW_TRACE_SET_ENABLED(true);
-    pw::trace::Callbacks::Instance()
-        .RegisterSink(TraceSinkStartBlock,
-                      TraceSinkAddBytes,
-                      TraceSinkEndBlock,
-                      this,
-                      &sink_handle_)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-    pw::trace::Callbacks::Instance()
-        .RegisterEventCallback(TraceEventCallback,
-                               pw::trace::CallbacksImpl::kCallOnlyWhenEnabled,
-                               this,
-                               &event_callback_handle_)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    EXPECT_EQ(pw::OkStatus(),
+              pw::trace::Callbacks::Instance().RegisterSink(TraceSinkStartBlock,
+                                                            TraceSinkAddBytes,
+                                                            TraceSinkEndBlock,
+                                                            this,
+                                                            &sink_handle_));
+    EXPECT_EQ(pw::OkStatus(),
+              pw::trace::Callbacks::Instance().RegisterEventCallback(
+                  TraceEventCallback,
+                  pw::trace::CallbacksImpl::kCallOnlyWhenEnabled,
+                  this,
+                  &event_callback_handle_));
   }
   ~TraceTestInterface() {
-    pw::trace::Callbacks::Instance()
-        .UnregisterSink(sink_handle_)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-    pw::trace::Callbacks::Instance()
-        .UnregisterEventCallback(event_callback_handle_)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    EXPECT_EQ(pw::OkStatus(),
+              pw::trace::Callbacks::Instance().UnregisterSink(sink_handle_));
+    EXPECT_EQ(pw::OkStatus(),
+              pw::trace::Callbacks::Instance().UnregisterEventCallback(
+                  event_callback_handle_));
   }
   // ActionOnEvent will perform a specific action within the callback when an
   // event matches one of the characteristics of event_match_.
@@ -574,8 +572,7 @@
   constexpr size_t kQueueSize = 5;
   pw::trace::internal::TraceQueue<kQueueSize> queue;
   constexpr size_t kTestNum = 1;
-  queue.TryPushBack(QUEUE_TESTS_ARGS(kTestNum))
-      .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  ASSERT_EQ(pw::OkStatus(), queue.TryPushBack(QUEUE_TESTS_ARGS(kTestNum)));
   EXPECT_FALSE(queue.IsEmpty());
   EXPECT_FALSE(queue.IsFull());
   EXPECT_TRUE(QUEUE_CHECK_RESULT(kQueueSize, queue.PeekFront(), kTestNum));
diff --git a/pw_unit_test/public/pw_unit_test/unit_test_service.h b/pw_unit_test/public/pw_unit_test/unit_test_service.h
index 80be9f3..7886601 100644
--- a/pw_unit_test/public/pw_unit_test/unit_test_service.h
+++ b/pw_unit_test/public/pw_unit_test/unit_test_service.h
@@ -41,7 +41,7 @@
     event_writer(event);
     if (event.status().ok()) {
       writer_.Write(event)
-          .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+          .IgnoreError();  // TODO(b/242598609): Handle Status properly
     }
   }
 
diff --git a/pw_unit_test/unit_test_service.cc b/pw_unit_test/unit_test_service.cc
index ef51cde..79ed49b 100644
--- a/pw_unit_test/unit_test_service.cc
+++ b/pw_unit_test/unit_test_service.cc
@@ -37,7 +37,7 @@
     switch (static_cast<TestRunRequest::Fields>(decoder.FieldNumber())) {
       case TestRunRequest::Fields::REPORT_PASSED_EXPECTATIONS:
         decoder.ReadBool(&verbose_)
-            .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+            .IgnoreError();  // TODO(b/242598609): Handle Status properly
         break;
 
       case TestRunRequest::Fields::TEST_SUITE: {
@@ -52,7 +52,7 @@
           PW_LOG_ERROR("Maximum of %u test suite filters supported",
                        static_cast<unsigned>(suites_to_run.max_size()));
           writer_.Finish(Status::InvalidArgument())
-              .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+              .IgnoreError();  // TODO(b/242598609): Handle Status properly
           return;
         }
 
@@ -63,7 +63,7 @@
 
   if (status != Status::OutOfRange()) {
     writer_.Finish(status)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     return;
   }
 
@@ -71,7 +71,7 @@
   handler_.ExecuteTests(suites_to_run);
   PW_LOG_INFO("Unit test run complete");
 
-  writer_.Finish().IgnoreError();  // TODO(pwbug/387): Handle Status properly
+  writer_.Finish().IgnoreError();  // TODO(b/242598609): Handle Status properly
 }
 
 void UnitTestService::WriteTestRunStart() {
@@ -84,13 +84,13 @@
   WriteEvent([&](Event::StreamEncoder& event) {
     TestRunEnd::StreamEncoder test_run_end = event.GetTestRunEndEncoder();
     test_run_end.WritePassed(summary.passed_tests)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     test_run_end.WriteFailed(summary.failed_tests)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     test_run_end.WriteSkipped(summary.skipped_tests)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     test_run_end.WriteDisabled(summary.disabled_tests)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   });
 }
 
@@ -99,18 +99,18 @@
     TestCaseDescriptor::StreamEncoder descriptor =
         event.GetTestCaseStartEncoder();
     descriptor.WriteSuiteName(test_case.suite_name)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     descriptor.WriteTestName(test_case.test_name)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     descriptor.WriteFileName(test_case.file_name)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   });
 }
 
 void UnitTestService::WriteTestCaseEnd(TestResult result) {
   WriteEvent([&](Event::StreamEncoder& event) {
     event.WriteTestCaseEnd(static_cast<TestCaseResult>(result))
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   });
 }
 
@@ -119,11 +119,11 @@
     TestCaseDescriptor::StreamEncoder descriptor =
         event.GetTestCaseDisabledEncoder();
     descriptor.WriteSuiteName(test_case.suite_name)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     descriptor.WriteTestName(test_case.test_name)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     descriptor.WriteFileName(test_case.file_name)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   });
 }
 
@@ -137,14 +137,14 @@
     TestCaseExpectation::StreamEncoder test_case_expectation =
         event.GetTestCaseExpectationEncoder();
     test_case_expectation.WriteExpression(expectation.expression)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     test_case_expectation
         .WriteEvaluatedExpression(expectation.evaluated_expression)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     test_case_expectation.WriteLineNumber(expectation.line_number)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
     test_case_expectation.WriteSuccess(expectation.success)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   });
 }
 
diff --git a/pw_work_queue/work_queue_test.cc b/pw_work_queue/work_queue_test.cc
index 6b793e0..ce349d7 100644
--- a/pw_work_queue/work_queue_test.cc
+++ b/pw_work_queue/work_queue_test.cc
@@ -40,21 +40,16 @@
 
   for (int i = 0; i < kPingPongs; ++i) {
     // Ping: throw work at the queue that will increment our counter.
-    work_queue
-        .PushWork([&context] {
-          context.counter++;
-          PW_LOG_INFO("Send pong...");
-          context.worker_ping.release();
-        })
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    EXPECT_EQ(OkStatus(), work_queue.PushWork([&context] {
+      context.counter++;
+      PW_LOG_INFO("Send pong...");
+      context.worker_ping.release();
+    }));
 
     // Throw a distraction in the queue.
-    work_queue
-        .PushWork([] {
-          PW_LOG_INFO(
-              "I'm a random task in the work queue; nothing to see here!");
-        })
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    EXPECT_EQ(OkStatus(), work_queue.PushWork([] {
+      PW_LOG_INFO("I'm a random task in the work queue; nothing to see here!");
+    }));
 
     // Pong: wait for the callback to notify us from the worker thread.
     context.worker_ping.acquire();
@@ -84,34 +79,30 @@
   // Run a bunch of work items in the queue.
   for (int i = 0; i < kPingPongs; ++i) {
     // Other requests...
-    work_queue.PushWork([] { PW_LOG_INFO("Chopping onions"); })
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    EXPECT_EQ(OkStatus(),
+              work_queue.PushWork([] { PW_LOG_INFO("Chopping onions"); }));
 
     // Ping A: throw work at the queue that will increment our counter.
-    work_queue
-        .PushWork([&context_a] {
-          context_a.counter++;
-          context_a.worker_ping.release();
-        })
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    EXPECT_EQ(OkStatus(), work_queue.PushWork([&context_a] {
+      context_a.counter++;
+      context_a.worker_ping.release();
+    }));
 
     // Other requests...
-    work_queue.PushWork([] { PW_LOG_INFO("Dicing carrots"); })
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
-    work_queue.PushWork([] { PW_LOG_INFO("Blanching spinach"); })
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    EXPECT_EQ(OkStatus(),
+              work_queue.PushWork([] { PW_LOG_INFO("Dicing carrots"); }));
+    EXPECT_EQ(OkStatus(),
+              work_queue.PushWork([] { PW_LOG_INFO("Blanching spinach"); }));
 
     // Ping B: throw work at the queue that will increment our counter.
-    work_queue
-        .PushWork([&context_b] {
-          context_b.counter++;
-          context_b.worker_ping.release();
-        })
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    EXPECT_EQ(OkStatus(), work_queue.PushWork([&context_b] {
+      context_b.counter++;
+      context_b.worker_ping.release();
+    }));
 
     // Other requests...
-    work_queue.PushWork([] { PW_LOG_INFO("Peeling potatoes"); })
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+    EXPECT_EQ(OkStatus(),
+              work_queue.PushWork([] { PW_LOG_INFO("Peeling potatoes"); }));
 
     // Pong A & B: wait for the callbacks to notify us from the worker thread.
     context_a.worker_ping.acquire();
diff --git a/targets/host/system_rpc_server.cc b/targets/host/system_rpc_server.cc
index 4647647..a0f53d8 100644
--- a/targets/host/system_rpc_server.cc
+++ b/targets/host/system_rpc_server.cc
@@ -54,7 +54,7 @@
   log_basic::SetOutput([](std::string_view log) {
     std::fprintf(stderr, "%.*s\n", static_cast<int>(log.size()), log.data());
     hdlc::WriteUIFrame(1, as_bytes(span(log)), socket_stream)
-        .IgnoreError();  // TODO(pwbug/387): Handle Status properly
+        .IgnoreError();  // TODO(b/242598609): Handle Status properly
   });
 
   PW_LOG_INFO("Starting pw_rpc server on port %d", socket_port);