diff --git a/pw_allocator/block.cc b/pw_allocator/block.cc
index bbf1a34..0bfa9f9 100644
--- a/pw_allocator/block.cc
+++ b/pw_allocator/block.cc
@@ -46,7 +46,7 @@
 #if defined(PW_ALLOCATOR_POISON_ENABLE) && PW_ALLOCATOR_POISON_ENABLE
   (*block)->PoisonBlock();
 #endif  // PW_ALLOCATOR_POISON_ENABLE
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status Block::Split(size_t head_block_inner_size, Block** new_block) {
@@ -118,7 +118,7 @@
   (*new_block)->PoisonBlock();
 #endif  // PW_ALLOCATOR_POISON_ENABLE
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status Block::MergeNext() {
@@ -142,7 +142,7 @@
     Next()->prev = this;
   }
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status Block::MergePrev() {
diff --git a/pw_allocator/block_test.cc b/pw_allocator/block_test.cc
index 0e09579..fb918ba 100644
--- a/pw_allocator/block_test.cc
+++ b/pw_allocator/block_test.cc
@@ -30,7 +30,7 @@
   Block* block = nullptr;
   auto status = Block::Init(std::span(bytes, kN), &block);
 
-  ASSERT_EQ(status, Status::Ok());
+  ASSERT_EQ(status, OkStatus());
   EXPECT_EQ(block->OuterSize(), kN);
   EXPECT_EQ(block->InnerSize(),
             kN - sizeof(Block) - 2 * PW_ALLOCATOR_POISON_OFFSET);
@@ -73,7 +73,7 @@
   Block* next_block = nullptr;
   auto status = block->Split(kSplitN, &next_block);
 
-  ASSERT_EQ(status, Status::Ok());
+  ASSERT_EQ(status, OkStatus());
   EXPECT_EQ(block->InnerSize(), kSplitN);
   EXPECT_EQ(block->OuterSize(),
             kSplitN + sizeof(Block) + 2 * PW_ALLOCATOR_POISON_OFFSET);
@@ -106,7 +106,7 @@
   Block* next_block = nullptr;
   auto status = block->Split(kSplitN, &next_block);
 
-  ASSERT_EQ(status, Status::Ok());
+  ASSERT_EQ(status, OkStatus());
   EXPECT_EQ(block->InnerSize(), split_len);
   EXPECT_EQ(block->OuterSize(),
             split_len + sizeof(Block) + 2 * PW_ALLOCATOR_POISON_OFFSET);
@@ -217,7 +217,7 @@
   Block* next_block = nullptr;
   auto status = block->Split(0, &next_block);
 
-  ASSERT_EQ(status, Status::Ok());
+  ASSERT_EQ(status, OkStatus());
   EXPECT_EQ(block->InnerSize(), static_cast<size_t>(0));
 }
 
@@ -234,7 +234,7 @@
       block->InnerSize() - sizeof(Block) - 2 * PW_ALLOCATOR_POISON_OFFSET,
       &next_block);
 
-  ASSERT_EQ(status, Status::Ok());
+  ASSERT_EQ(status, OkStatus());
   EXPECT_EQ(next_block->InnerSize(), static_cast<size_t>(0));
 }
 
@@ -287,7 +287,7 @@
   Block* block3 = nullptr;
   block->Split(kSplit2, &block3);
 
-  EXPECT_EQ(block3->MergeNext(), Status::Ok());
+  EXPECT_EQ(block3->MergeNext(), OkStatus());
 
   EXPECT_EQ(block->Next(), block3);
   EXPECT_EQ(block3->Prev(), block);
diff --git a/pw_allocator/freelist.cc b/pw_allocator/freelist.cc
index d46e010..03b514d 100644
--- a/pw_allocator/freelist.cc
+++ b/pw_allocator/freelist.cc
@@ -36,7 +36,7 @@
   aliased.node->next = chunks_[chunk_ptr];
   chunks_[chunk_ptr] = aliased.node;
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 std::span<std::byte> FreeList::FindChunk(size_t size) const {
@@ -92,7 +92,7 @@
   if (aliased.data == chunk.data()) {
     chunks_[chunk_ptr] = aliased.node->next;
 
-    return Status::Ok();
+    return OkStatus();
   }
 
   // No? Walk the nodes.
@@ -103,7 +103,7 @@
     if (aliased_next.data == chunk.data()) {
       // Found it, remove this node out of the chain
       aliased.node->next = aliased_next.node->next;
-      return Status::Ok();
+      return OkStatus();
     }
 
     aliased.node = aliased.node->next;
diff --git a/pw_allocator/freelist_test.cc b/pw_allocator/freelist_test.cc
index 865ea3f..8e0e145 100644
--- a/pw_allocator/freelist_test.cc
+++ b/pw_allocator/freelist_test.cc
@@ -43,7 +43,7 @@
   byte data[kN] = {std::byte(0)};
 
   auto status = list.AddChunk(std::span(data, kN));
-  EXPECT_EQ(status, Status::Ok());
+  EXPECT_EQ(status, OkStatus());
 
   auto item = list.FindChunk(kN);
   EXPECT_EQ(item.size(), kN);
@@ -70,7 +70,7 @@
 
   list.AddChunk(std::span(data, kN));
   auto status = list.RemoveChunk(std::span(data, kN));
-  EXPECT_EQ(status, Status::Ok());
+  EXPECT_EQ(status, OkStatus());
 
   auto item = list.FindChunk(kN);
   EXPECT_EQ(item.size(), static_cast<size_t>(0));
diff --git a/pw_assert/assert_backend_compile_test.cc b/pw_assert/assert_backend_compile_test.cc
index 6e1ac2e..5a98b15 100644
--- a/pw_assert/assert_backend_compile_test.cc
+++ b/pw_assert/assert_backend_compile_test.cc
@@ -216,10 +216,10 @@
   CHECK_OK(status, "msg: %d", 5);
 
   // Status from a literal.
-  PW_CHECK_OK(pw::Status::Ok());
+  PW_CHECK_OK(pw::OkStatus());
 
   // Status from a function.
-  PW_CHECK_OK(MakeStatus(pw::Status::Ok()));
+  PW_CHECK_OK(MakeStatus(pw::OkStatus()));
 
   // Status from C enums.
   PW_CHECK_OK(PW_STATUS_OK);
diff --git a/pw_assert/assert_facade_test.cc b/pw_assert/assert_facade_test.cc
index 083d206..376bdf5 100644
--- a/pw_assert/assert_facade_test.cc
+++ b/pw_assert/assert_facade_test.cc
@@ -477,19 +477,19 @@
 TEST_F(AssertFail, StatusNotOK) {
   pw::Status status = pw::Status::Unknown();
   PW_CHECK_OK(status);
-  EXPECT_MESSAGE("Check failed: status (=UNKNOWN) == Status::OK (=OK). ");
+  EXPECT_MESSAGE("Check failed: status (=UNKNOWN) == OkStatus() (=OK). ");
 }
 
 TEST_F(AssertFail, StatusNotOKMessageNoArguments) {
   pw::Status status = pw::Status::Unknown();
   PW_CHECK_OK(status, "msg");
-  EXPECT_MESSAGE("Check failed: status (=UNKNOWN) == Status::OK (=OK). msg");
+  EXPECT_MESSAGE("Check failed: status (=UNKNOWN) == OkStatus() (=OK). msg");
 }
 
 TEST_F(AssertFail, StatusNotOKMessageArguments) {
   pw::Status status = pw::Status::Unknown();
   PW_CHECK_OK(status, "msg: %d", 5);
-  EXPECT_MESSAGE("Check failed: status (=UNKNOWN) == Status::OK (=OK). msg: 5");
+  EXPECT_MESSAGE("Check failed: status (=UNKNOWN) == OkStatus() (=OK). msg: 5");
 }
 
 // Example expression for the test below.
@@ -498,13 +498,13 @@
 TEST_F(AssertFail, NonTrivialExpression) {
   PW_CHECK_OK(DoTheThing());
   EXPECT_MESSAGE(
-      "Check failed: DoTheThing() (=RESOURCE_EXHAUSTED) == Status::OK (=OK). ");
+      "Check failed: DoTheThing() (=RESOURCE_EXHAUSTED) == OkStatus() (=OK). ");
 }
 
 // Note: This function seems pointless but it is not, since pw::Status::FOO
 // constants are not actually status objects, but code objects. This way we can
 // ensure the macros work with both real status objects and literals.
-TEST_F(AssertPass, Function) { PW_CHECK_OK(pw::Status::Ok()); }
+TEST_F(AssertPass, Function) { PW_CHECK_OK(pw::OkStatus()); }
 TEST_F(AssertPass, Enum) { PW_CHECK_OK(PW_STATUS_OK); }
 TEST_F(AssertFail, Function) { PW_CHECK_OK(pw::Status::Unknown()); }
 TEST_F(AssertFail, Enum) { PW_CHECK_OK(PW_STATUS_UNKNOWN); }
@@ -512,14 +512,14 @@
 #if PW_ASSERT_ENABLE_DEBUG
 
 // In debug mode, the asserts should check their arguments.
-TEST_F(AssertPass, DCheckFunction) { PW_DCHECK_OK(pw::Status::Ok()); }
+TEST_F(AssertPass, DCheckFunction) { PW_DCHECK_OK(pw::OkStatus()); }
 TEST_F(AssertPass, DCheckEnum) { PW_DCHECK_OK(PW_STATUS_OK); }
 TEST_F(AssertFail, DCheckFunction) { PW_DCHECK_OK(pw::Status::Unknown()); }
 TEST_F(AssertFail, DCheckEnum) { PW_DCHECK_OK(PW_STATUS_UNKNOWN); }
 #else  // PW_ASSERT_ENABLE_DEBUG
 
 // In release mode, all the asserts should pass.
-TEST_F(AssertPass, DCheckFunction_Ok) { PW_DCHECK_OK(pw::Status::Ok()); }
+TEST_F(AssertPass, DCheckFunction_Ok) { PW_DCHECK_OK(pw::OkStatus()); }
 TEST_F(AssertPass, DCheckEnum_Ok) { PW_DCHECK_OK(PW_STATUS_OK); }
 TEST_F(AssertPass, DCheckFunction_Err) { PW_DCHECK_OK(pw::Status::Unknown()); }
 TEST_F(AssertPass, DCheckEnum_Err) { PW_DCHECK_OK(PW_STATUS_UNKNOWN); }
diff --git a/pw_assert/docs.rst b/pw_assert/docs.rst
index 2d96c60..aec3343 100644
--- a/pw_assert/docs.rst
+++ b/pw_assert/docs.rst
@@ -149,10 +149,9 @@
     tokenizing assert backend. For example, if ``x`` and ``b`` are integers,
     use instead ``PW_CHECK_INT_LT(x, b)``.
 
-    Additionally, use ``PW_CHECK_OK(status)`` when checking for a
-    ``Status::OK``, since it enables showing a human-readable status string
-    rather than an integer (e.g. ``status == RESOURCE_EXHAUSTED`` instead of
-    ``status == 5``.
+    Additionally, use ``PW_CHECK_OK(status)`` when checking for an OK status,
+    since it enables showing a human-readable status string rather than an
+    integer (e.g. ``status == RESOURCE_EXHAUSTED`` instead of ``status == 5``.
 
     +------------------------------------+-------------------------------------+
     | **Do NOT do this**                 | **Do this instead**                 |
@@ -164,7 +163,7 @@
     | ``PW_CHECK(Temp() <= 10.0)``       | ``PW_CHECK_FLOAT_EXACT_LE(``        |
     |                                    | ``    Temp(), 10.0)``               |
     +------------------------------------+-------------------------------------+
-    | ``PW_CHECK(Foo() == Status::OK)``  | ``PW_CHECK_OK(Foo())``              |
+    | ``PW_CHECK(Foo() == OkStatus())``  | ``PW_CHECK_OK(Foo())``              |
     +------------------------------------+-------------------------------------+
 
 .. cpp:function:: PW_CHECK_NOTNULL(ptr)
@@ -367,7 +366,7 @@
 .. cpp:function:: PW_DCHECK_OK(status)
 .. cpp:function:: PW_DCHECK_OK(status, format, ...)
 
-  Assert that ``status`` evaluates to ``pw::Status::OK`` (in C++) or
+  Assert that ``status`` evaluates to ``pw::OkStatus()`` (in C++) or
   ``PW_STATUS_OK`` (in C). Optionally include a message with arguments to
   report.
 
@@ -388,7 +387,7 @@
 
   .. note::
 
-    Using ``PW_CHECK_OK(status)`` instead of ``PW_CHECK(status == Status::OK)``
+    Using ``PW_CHECK_OK(status)`` instead of ``PW_CHECK(status == OkStatus())``
     enables displaying an error message with a string version of the error
     code; for example ``status == RESOURCE_EXHAUSTED`` instead of ``status ==
     5``.
diff --git a/pw_assert/public/pw_assert/internal/assert_impl.h b/pw_assert/public/pw_assert/internal/assert_impl.h
index 35eab1e..c13c298 100644
--- a/pw_assert/public/pw_assert/internal/assert_impl.h
+++ b/pw_assert/public/pw_assert/internal/assert_impl.h
@@ -314,14 +314,14 @@
 // PW_CHECK_OK version 1: No message or args
 #define _PW_CHECK_OK_HAS_MSG_0(status_expr_str, status_value_str, ignored_arg) \
   PW_HANDLE_ASSERT_BINARY_COMPARE_FAILURE(                                     \
-      status_expr_str, status_value_str, "==", "Status::OK", "OK", "%s", "")
+      status_expr_str, status_value_str, "==", "OkStatus()", "OK", "%s", "")
 
 // PW_CHECK_OK version 2: With message (and maybe args)
 #define _PW_CHECK_OK_HAS_MSG_1(status_expr_str, status_value_str, ...) \
   PW_HANDLE_ASSERT_BINARY_COMPARE_FAILURE(status_expr_str,             \
                                           status_value_str,            \
                                           "==",                        \
-                                          "Status::OK",                \
+                                          "OkStatus()",                \
                                           "OK",                        \
                                           "%s",                        \
                                           __VA_ARGS__)
diff --git a/pw_blob_store/blob_store.cc b/pw_blob_store/blob_store.cc
index 247886c..2389292 100644
--- a/pw_blob_store/blob_store.cc
+++ b/pw_blob_store/blob_store.cc
@@ -23,7 +23,7 @@
 
 Status BlobStore::Init() {
   if (initialized_) {
-    return Status::Ok();
+    return OkStatus();
   }
 
   PW_LOG_INFO("Init BlobStore");
@@ -44,7 +44,7 @@
 
     PW_LOG_DEBUG("BlobStore init - Have valid blob of %u bytes",
                  static_cast<unsigned>(write_address_));
-    return Status::Ok();
+    return OkStatus();
   }
 
   // No saved blob, check for flash being erased.
@@ -59,7 +59,7 @@
   } else {
     PW_LOG_DEBUG("BlobStore init - not erased");
   }
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status BlobStore::LoadMetadata() {
@@ -75,7 +75,7 @@
     return Status::DataLoss();
   }
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 size_t BlobStore::MaxDataSizeBytes() const { return partition_.size_bytes(); }
@@ -97,7 +97,7 @@
 
   Invalidate();
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status BlobStore::OpenRead() {
@@ -118,7 +118,7 @@
   PW_LOG_DEBUG("Blob reader open");
 
   readers_open_++;
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status BlobStore::CloseWrite() {
@@ -130,7 +130,7 @@
     }
 
     if (write_address_ == 0) {
-      return Status::Ok();
+      return OkStatus();
     }
 
     PW_LOG_DEBUG(
@@ -169,7 +169,7 @@
       return Status::DataLoss();
     }
 
-    return Status::Ok();
+    return OkStatus();
   };
 
   const Status status = do_close_write();
@@ -179,14 +179,14 @@
     valid_data_ = false;
     return Status::DataLoss();
   }
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status BlobStore::CloseRead() {
   PW_CHECK_UINT_GT(readers_open_, 0);
   readers_open_--;
   PW_LOG_DEBUG("Blob reader close");
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status BlobStore::Write(ConstByteSpan data) {
@@ -194,7 +194,7 @@
     return Status::DataLoss();
   }
   if (data.size_bytes() == 0) {
-    return Status::Ok();
+    return OkStatus();
   }
   if (WriteBytesRemaining() == 0) {
     return Status::OutOfRange();
@@ -238,7 +238,7 @@
       // If there was not enough bytes to finish filling the write buffer, there
       // should not be any bytes left.
       PW_DCHECK(data.size_bytes() == 0);
-      return Status::Ok();
+      return OkStatus();
     }
 
     // The write buffer is full, flush to flash.
@@ -275,7 +275,7 @@
     write_address_ += data.size_bytes();
   }
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status BlobStore::AddToWriteBuffer(ConstByteSpan data) {
@@ -295,7 +295,7 @@
       write_buffer_.data() + bytes_in_buffer, data.data(), data.size_bytes());
   write_address_ += data.size_bytes();
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status BlobStore::Flush() {
@@ -303,7 +303,7 @@
     return Status::DataLoss();
   }
   if (WriteBufferBytesUsed() == 0) {
-    return Status::Ok();
+    return OkStatus();
   }
   // Don't need to check available space, AddToWriteBuffer() will not enqueue
   // more than can be written to flash.
@@ -333,7 +333,7 @@
     PW_DCHECK_UINT_EQ(data.size_bytes(), 0);
   }
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status BlobStore::FlushFinalPartialChunk() {
@@ -394,7 +394,7 @@
     // Always just erase. Erase is smart enough to only erase if needed.
     return Erase();
   }
-  return Status::Ok();
+  return OkStatus();
 }
 
 StatusWithSize BlobStore::Read(size_t offset, ByteSpan dest) const {
@@ -439,7 +439,7 @@
     // Erased blobs should be valid as soon as the flash is erased. Even though
     // there are 0 bytes written, they are valid.
     PW_DCHECK(valid_data_);
-    return Status::Ok();
+    return OkStatus();
   }
 
   Invalidate();
@@ -468,8 +468,8 @@
 
   Status status = kvs_.Delete(MetadataKey());
 
-  return (status == Status::Ok() || status == Status::NotFound())
-             ? Status::Ok()
+  return (status == OkStatus() || status == Status::NotFound())
+             ? OkStatus()
              : Status::Internal();
 }
 
@@ -486,7 +486,7 @@
       return Status::DataLoss();
     }
 
-    return Status::Ok();
+    return OkStatus();
   }
 
   PW_LOG_DEBUG("Validate checksum of 0x%08x in flash for blob of %u bytes",
@@ -503,7 +503,7 @@
 
 Status BlobStore::CalculateChecksumFromFlash(size_t bytes_to_check) {
   if (checksum_algo_ == nullptr) {
-    return Status::Ok();
+    return OkStatus();
   }
 
   checksum_algo_->Reset();
@@ -524,7 +524,7 @@
   // Safe to ignore the return from Finish, checksum_algo_ keeps the state
   // information that it needs.
   checksum_algo_->Finish();
-  return Status::Ok();
+  return OkStatus();
 }
 
 }  // namespace pw::blob_store
diff --git a/pw_blob_store/blob_store_chunk_write_test.cc b/pw_blob_store/blob_store_chunk_write_test.cc
index 49e0016..3dabaa8 100644
--- a/pw_blob_store/blob_store_chunk_write_test.cc
+++ b/pw_blob_store/blob_store_chunk_write_test.cc
@@ -60,11 +60,11 @@
 
     BlobStoreBuffer<kBufferSize> blob(
         name, partition_, &checksum, kvs::TestKvs(), kBufferSize);
-    EXPECT_EQ(Status::Ok(), blob.Init());
+    EXPECT_EQ(OkStatus(), blob.Init());
 
     BlobStore::BlobWriter writer(blob);
-    EXPECT_EQ(Status::Ok(), writer.Open());
-    EXPECT_EQ(Status::Ok(), writer.Erase());
+    EXPECT_EQ(OkStatus(), writer.Open());
+    EXPECT_EQ(OkStatus(), writer.Erase());
 
     ByteSpan source = source_buffer_;
     while (source.size_bytes() > 0) {
@@ -74,20 +74,20 @@
                    static_cast<unsigned>(write_size),
                    static_cast<unsigned>(source.size_bytes()));
 
-      ASSERT_EQ(Status::Ok(), writer.Write(source.first(write_size)));
+      ASSERT_EQ(OkStatus(), writer.Write(source.first(write_size)));
 
       source = source.subspan(write_size);
     }
 
-    EXPECT_EQ(Status::Ok(), writer.Close());
+    EXPECT_EQ(OkStatus(), writer.Close());
 
     // Use reader to check for valid data.
     BlobStore::BlobReader reader(blob);
-    ASSERT_EQ(Status::Ok(), reader.Open());
+    ASSERT_EQ(OkStatus(), reader.Open());
     Result<ConstByteSpan> result = reader.GetMemoryMappedBlob();
     ASSERT_TRUE(result.ok());
     VerifyFlash(result.value());
-    EXPECT_EQ(Status::Ok(), reader.Close());
+    EXPECT_EQ(OkStatus(), reader.Close());
   }
 
   void VerifyFlash(ConstByteSpan verify_bytes) {
diff --git a/pw_blob_store/blob_store_deferred_write_test.cc b/pw_blob_store/blob_store_deferred_write_test.cc
index bd15ae3..02491e6 100644
--- a/pw_blob_store/blob_store_deferred_write_test.cc
+++ b/pw_blob_store/blob_store_deferred_write_test.cc
@@ -62,10 +62,10 @@
 
     BlobStoreBuffer<kBufferSize> blob(
         name, partition_, &checksum, kvs::TestKvs(), kWriteSize);
-    EXPECT_EQ(Status::Ok(), blob.Init());
+    EXPECT_EQ(OkStatus(), blob.Init());
 
     BlobStore::DeferredWriter writer(blob);
-    EXPECT_EQ(Status::Ok(), writer.Open());
+    EXPECT_EQ(OkStatus(), writer.Open());
 
     ByteSpan source = buffer_;
     while (source.size_bytes() > 0) {
@@ -75,7 +75,7 @@
                    static_cast<unsigned>(write_size),
                    static_cast<unsigned>(source.size_bytes()));
 
-      ASSERT_EQ(Status::Ok(), writer.Write(source.first(write_size)));
+      ASSERT_EQ(OkStatus(), writer.Write(source.first(write_size)));
       // TODO: Add check that the write did not go to flash yet.
 
       source = source.subspan(write_size);
@@ -83,19 +83,19 @@
 
       if (bytes_since_flush >= flush_interval) {
         bytes_since_flush = 0;
-        ASSERT_EQ(Status::Ok(), writer.Flush());
+        ASSERT_EQ(OkStatus(), writer.Flush());
       }
     }
 
-    EXPECT_EQ(Status::Ok(), writer.Close());
+    EXPECT_EQ(OkStatus(), writer.Close());
 
     // Use reader to check for valid data.
     BlobStore::BlobReader reader(blob);
-    ASSERT_EQ(Status::Ok(), reader.Open());
+    ASSERT_EQ(OkStatus(), reader.Open());
     Result<ConstByteSpan> result = reader.GetMemoryMappedBlob();
     ASSERT_TRUE(result.ok());
     VerifyFlash(result.value());
-    EXPECT_EQ(Status::Ok(), reader.Close());
+    EXPECT_EQ(OkStatus(), reader.Close());
   }
 
   void VerifyFlash(ConstByteSpan verify_bytes) {
diff --git a/pw_blob_store/blob_store_test.cc b/pw_blob_store/blob_store_test.cc
index d2ea203..dcb4bff 100644
--- a/pw_blob_store/blob_store_test.cc
+++ b/pw_blob_store/blob_store_test.cc
@@ -74,22 +74,22 @@
 
     BlobStoreBuffer<kBufferSize> blob(
         name, partition_, &checksum, kvs::TestKvs(), kBufferSize);
-    EXPECT_EQ(Status::Ok(), blob.Init());
+    EXPECT_EQ(OkStatus(), blob.Init());
 
     BlobStore::BlobWriter writer(blob);
-    EXPECT_EQ(Status::OK, writer.Open());
-    ASSERT_EQ(Status::OK, writer.Write(write_data));
-    EXPECT_EQ(Status::OK, writer.Close());
+    EXPECT_EQ(OkStatus(), writer.Open());
+    ASSERT_EQ(OkStatus(), writer.Write(write_data));
+    EXPECT_EQ(OkStatus(), writer.Close());
 
     // Use reader to check for valid data.
     BlobStore::BlobReader reader(blob);
-    ASSERT_EQ(Status::Ok(), reader.Open());
+    ASSERT_EQ(OkStatus(), reader.Open());
     Result<ConstByteSpan> result = reader.GetMemoryMappedBlob();
     ASSERT_TRUE(result.ok());
     EXPECT_EQ(write_size_bytes, result.value().size_bytes());
     VerifyFlash(result.value().first(write_size_bytes));
     VerifyFlash(flash_.buffer().first(write_size_bytes));
-    EXPECT_EQ(Status::OK, reader.Close());
+    EXPECT_EQ(OkStatus(), reader.Close());
   }
 
   // Open a new blob instance and read the blob using the given read chunk size.
@@ -102,18 +102,18 @@
     constexpr size_t kBufferSize = 16;
     BlobStoreBuffer<kBufferSize> blob(
         name, partition_, &checksum, kvs::TestKvs(), kBufferSize);
-    EXPECT_EQ(Status::Ok(), blob.Init());
+    EXPECT_EQ(OkStatus(), blob.Init());
 
     // Use reader to check for valid data.
     BlobStore::BlobReader reader1(blob);
-    ASSERT_EQ(Status::Ok(), reader1.Open());
+    ASSERT_EQ(OkStatus(), reader1.Open());
     Result<ConstByteSpan> possible_blob = reader1.GetMemoryMappedBlob();
     ASSERT_TRUE(possible_blob.ok());
     VerifyFlash(possible_blob.value());
-    EXPECT_EQ(Status::Ok(), reader1.Close());
+    EXPECT_EQ(OkStatus(), reader1.Close());
 
     BlobStore::BlobReader reader(blob);
-    ASSERT_EQ(Status::Ok(), reader.Open());
+    ASSERT_EQ(OkStatus(), reader.Open());
 
     std::array<std::byte, kBlobDataSize> read_buffer;
 
@@ -127,10 +127,10 @@
 
       ASSERT_EQ(read_span.size_bytes(), reader.ConservativeReadLimit());
       auto result = reader.Read(read_span.first(read_size));
-      ASSERT_EQ(result.status(), Status::Ok());
+      ASSERT_EQ(result.status(), OkStatus());
       read_span = read_span.subspan(read_size);
     }
-    EXPECT_EQ(Status::Ok(), reader.Close());
+    EXPECT_EQ(OkStatus(), reader.Close());
 
     VerifyFlash(read_buffer);
   }
@@ -163,38 +163,38 @@
   constexpr size_t kBufferSize = 256;
   BlobStoreBuffer<kBufferSize> blob(
       "Blob_OK", partition_, nullptr, kvs::TestKvs(), kBufferSize);
-  EXPECT_EQ(Status::Ok(), blob.Init());
+  EXPECT_EQ(OkStatus(), blob.Init());
 }
 
 TEST_F(BlobStoreTest, IsOpen) {
   constexpr size_t kBufferSize = 256;
   BlobStoreBuffer<kBufferSize> blob(
       "Blob_open", partition_, nullptr, kvs::TestKvs(), kBufferSize);
-  EXPECT_EQ(Status::Ok(), blob.Init());
+  EXPECT_EQ(OkStatus(), blob.Init());
 
   BlobStore::DeferredWriter deferred_writer(blob);
   EXPECT_EQ(false, deferred_writer.IsOpen());
-  EXPECT_EQ(Status::OK, deferred_writer.Open());
+  EXPECT_EQ(OkStatus(), deferred_writer.Open());
   EXPECT_EQ(true, deferred_writer.IsOpen());
-  EXPECT_EQ(Status::OK, deferred_writer.Close());
+  EXPECT_EQ(OkStatus(), deferred_writer.Close());
   EXPECT_EQ(false, deferred_writer.IsOpen());
 
   BlobStore::BlobWriter writer(blob);
   EXPECT_EQ(false, writer.IsOpen());
-  EXPECT_EQ(Status::OK, writer.Open());
+  EXPECT_EQ(OkStatus(), writer.Open());
   EXPECT_EQ(true, writer.IsOpen());
 
   // Need to write something, so the blob reader is able to open.
   std::array<std::byte, 64> tmp_buffer = {};
-  EXPECT_EQ(Status::OK, writer.Write(tmp_buffer));
-  EXPECT_EQ(Status::OK, writer.Close());
+  EXPECT_EQ(OkStatus(), writer.Write(tmp_buffer));
+  EXPECT_EQ(OkStatus(), writer.Close());
   EXPECT_EQ(false, writer.IsOpen());
 
   BlobStore::BlobReader reader(blob);
   EXPECT_EQ(false, reader.IsOpen());
-  ASSERT_EQ(Status::Ok(), reader.Open());
+  ASSERT_EQ(OkStatus(), reader.Open());
   EXPECT_EQ(true, reader.IsOpen());
-  EXPECT_EQ(Status::Ok(), reader.Close());
+  EXPECT_EQ(OkStatus(), reader.Close());
   EXPECT_EQ(false, reader.IsOpen());
 }
 
@@ -212,23 +212,23 @@
   constexpr size_t kBufferSize = 256;
   BlobStoreBuffer<kBufferSize> blob(
       blob_title, partition_, &checksum, kvs::TestKvs(), kBufferSize);
-  EXPECT_EQ(Status::OK, blob.Init());
+  EXPECT_EQ(OkStatus(), blob.Init());
 
   BlobStore::BlobWriter writer(blob);
 
-  EXPECT_EQ(Status::OK, writer.Open());
-  EXPECT_EQ(Status::OK, writer.Write(tmp_buffer));
+  EXPECT_EQ(OkStatus(), writer.Open());
+  EXPECT_EQ(OkStatus(), writer.Write(tmp_buffer));
 
   // The write does an implicit erase so there should be no key for this blob.
   EXPECT_EQ(Status::NOT_FOUND,
             kvs::TestKvs().Get(blob_title, tmp_buffer).status());
-  EXPECT_EQ(Status::OK, writer.Close());
+  EXPECT_EQ(OkStatus(), writer.Close());
 
-  EXPECT_EQ(Status::OK, kvs::TestKvs().Get(blob_title, tmp_buffer).status());
+  EXPECT_EQ(OkStatus(), kvs::TestKvs().Get(blob_title, tmp_buffer).status());
 
-  EXPECT_EQ(Status::OK, writer.Open());
-  EXPECT_EQ(Status::OK, writer.Discard());
-  EXPECT_EQ(Status::OK, writer.Close());
+  EXPECT_EQ(OkStatus(), writer.Open());
+  EXPECT_EQ(OkStatus(), writer.Discard());
+  EXPECT_EQ(OkStatus(), writer.Close());
 
   EXPECT_EQ(Status::NOT_FOUND,
             kvs::TestKvs().Get(blob_title, tmp_buffer).status());
@@ -238,14 +238,14 @@
   constexpr size_t kBufferSize = 256;
   BlobStoreBuffer<kBufferSize> blob(
       "Blob_OK", partition_, nullptr, kvs::TestKvs(), kBufferSize);
-  EXPECT_EQ(Status::Ok(), blob.Init());
+  EXPECT_EQ(OkStatus(), blob.Init());
 
   BlobStore::BlobWriter writer(blob);
-  EXPECT_EQ(Status::Ok(), writer.Open());
+  EXPECT_EQ(OkStatus(), writer.Open());
 
-  EXPECT_EQ(Status::Ok(), writer.Erase());
-  EXPECT_EQ(Status::Ok(), writer.Erase());
-  EXPECT_EQ(Status::Ok(), writer.Erase());
+  EXPECT_EQ(OkStatus(), writer.Erase());
+  EXPECT_EQ(OkStatus(), writer.Erase());
+  EXPECT_EQ(OkStatus(), writer.Erase());
 }
 
 TEST_F(BlobStoreTest, OffsetRead) {
@@ -261,17 +261,17 @@
   constexpr size_t kBufferSize = 16;
   BlobStoreBuffer<kBufferSize> blob(
       name, partition_, &checksum, kvs::TestKvs(), kBufferSize);
-  EXPECT_EQ(Status::Ok(), blob.Init());
+  EXPECT_EQ(OkStatus(), blob.Init());
   BlobStore::BlobReader reader(blob);
-  ASSERT_EQ(Status::Ok(), reader.Open(kOffset));
+  ASSERT_EQ(OkStatus(), reader.Open(kOffset));
 
   std::array<std::byte, kBlobDataSize - kOffset> read_buffer;
   ByteSpan read_span = read_buffer;
   ASSERT_EQ(read_span.size_bytes(), reader.ConservativeReadLimit());
 
   auto result = reader.Read(read_span);
-  ASSERT_EQ(result.status(), Status::Ok());
-  EXPECT_EQ(Status::Ok(), reader.Close());
+  ASSERT_EQ(result.status(), OkStatus());
+  EXPECT_EQ(OkStatus(), reader.Close());
   VerifyFlash(read_buffer, kOffset);
 }
 
@@ -287,7 +287,7 @@
   constexpr size_t kBufferSize = 16;
   BlobStoreBuffer<kBufferSize> blob(
       name, partition_, &checksum, kvs::TestKvs(), kBufferSize);
-  EXPECT_EQ(Status::Ok(), blob.Init());
+  EXPECT_EQ(OkStatus(), blob.Init());
   BlobStore::BlobReader reader(blob);
   ASSERT_EQ(Status::InvalidArgument(), reader.Open(kOffset));
 }
@@ -305,17 +305,17 @@
   constexpr size_t kBufferSize = 16;
   BlobStoreBuffer<kBufferSize> blob(
       name, partition_, &checksum, kvs::TestKvs(), kBufferSize);
-  EXPECT_EQ(Status::Ok(), blob.Init());
+  EXPECT_EQ(OkStatus(), blob.Init());
   BlobStore::BlobReader reader(blob);
-  ASSERT_EQ(Status::Ok(), reader.Open());
+  ASSERT_EQ(OkStatus(), reader.Open());
   EXPECT_EQ(kWriteBytes, reader.ConservativeReadLimit());
 
   std::array<std::byte, kWriteBytes + 10> read_buffer;
   ByteSpan read_span = read_buffer;
 
   auto result = reader.Read(read_span);
-  ASSERT_EQ(result.status(), Status::Ok());
-  EXPECT_EQ(Status::Ok(), reader.Close());
+  ASSERT_EQ(result.status(), OkStatus());
+  EXPECT_EQ(OkStatus(), reader.Close());
 }
 
 TEST_F(BlobStoreTest, ChunkRead1) {
diff --git a/pw_bytes/byte_builder.cc b/pw_bytes/byte_builder.cc
index ba01c0f..c3f2f7d 100644
--- a/pw_bytes/byte_builder.cc
+++ b/pw_bytes/byte_builder.cc
@@ -39,14 +39,14 @@
   }
 
   size_ += bytes_to_append;
-  status_ = Status::Ok();
+  status_ = OkStatus();
   return bytes_to_append;
 }
 
 void ByteBuilder::resize(size_t new_size) {
   if (new_size <= size_) {
     size_ = new_size;
-    status_ = Status::Ok();
+    status_ = OkStatus();
   } else {
     status_ = Status::OutOfRange();
   }
diff --git a/pw_bytes/byte_builder_test.cc b/pw_bytes/byte_builder_test.cc
index d1d1e7b..97e2bb6 100644
--- a/pw_bytes/byte_builder_test.cc
+++ b/pw_bytes/byte_builder_test.cc
@@ -197,7 +197,7 @@
 
 TEST(ByteBuilder, Status_StartsOk) {
   ByteBuffer<16> bb;
-  EXPECT_EQ(Status::Ok(), bb.status());
+  EXPECT_EQ(OkStatus(), bb.status());
 }
 
 TEST(ByteBuilder, Status_StatusUpdate) {
@@ -222,13 +222,13 @@
   EXPECT_EQ(Status::ResourceExhausted(), bb.status());
 
   bb.clear_status();
-  EXPECT_EQ(Status::Ok(), bb.status());
+  EXPECT_EQ(OkStatus(), bb.status());
 }
 
 TEST(ByteBuilder, PushBack) {
   ByteBuffer<12> bb;
   bb.push_back(byte{0x01});
-  EXPECT_EQ(Status::Ok(), bb.status());
+  EXPECT_EQ(OkStatus(), bb.status());
   EXPECT_EQ(1u, bb.size());
   EXPECT_EQ(byte{0x01}, bb.data()[0]);
 }
@@ -236,7 +236,7 @@
 TEST(ByteBuilder, PushBack_Full) {
   ByteBuffer<1> bb;
   bb.push_back(byte{0x01});
-  EXPECT_EQ(Status::Ok(), bb.status());
+  EXPECT_EQ(OkStatus(), bb.status());
   EXPECT_EQ(1u, bb.size());
 }
 
@@ -256,7 +256,7 @@
   bb.append(buffer.data(), 3);
 
   bb.pop_back();
-  EXPECT_EQ(Status::Ok(), bb.status());
+  EXPECT_EQ(OkStatus(), bb.status());
   EXPECT_EQ(2u, bb.size());
   EXPECT_EQ(byte{0x01}, bb.data()[0]);
   EXPECT_EQ(byte{0x02}, bb.data()[1]);
@@ -270,7 +270,7 @@
   bb.pop_back();
   bb.pop_back();
   bb.pop_back();
-  EXPECT_EQ(Status::Ok(), bb.status());
+  EXPECT_EQ(OkStatus(), bb.status());
   EXPECT_EQ(0u, bb.size());
   EXPECT_TRUE(bb.empty());
 }
@@ -338,7 +338,7 @@
 
   EXPECT_EQ(byte{0x01}, two.data()[0]);
   EXPECT_EQ(byte{0x02}, two.data()[1]);
-  EXPECT_EQ(Status::Ok(), two.status());
+  EXPECT_EQ(OkStatus(), two.status());
 }
 
 TEST(ByteBuilder, ResizeError_NoDataAddedAfter) {
@@ -372,7 +372,7 @@
 
   EXPECT_EQ(byte{0xFE}, bb.data()[0]);
   EXPECT_EQ(byte{0x02}, bb.data()[1]);
-  EXPECT_EQ(Status::Ok(), bb.status());
+  EXPECT_EQ(OkStatus(), bb.status());
 }
 
 TEST(ByteBuffer, Putting8ByteInts_Exhausted) {
@@ -396,7 +396,7 @@
   EXPECT_EQ(byte{0x08}, bb.data()[2]);
   EXPECT_EQ(byte{0x00}, bb.data()[3]);
 
-  EXPECT_EQ(Status::Ok(), bb.status());
+  EXPECT_EQ(OkStatus(), bb.status());
 }
 
 TEST(ByteBuffer, Putting16ByteInts_Exhausted_kBigEndian) {
@@ -428,7 +428,7 @@
   EXPECT_EQ(byte{0x00}, bb.data()[6]);
   EXPECT_EQ(byte{0x00}, bb.data()[7]);
 
-  EXPECT_EQ(Status::Ok(), bb.status());
+  EXPECT_EQ(OkStatus(), bb.status());
 }
 
 TEST(ByteBuffer, Putting32ByteInts_Exhausted_kBigEndian) {
@@ -472,7 +472,7 @@
   EXPECT_EQ(byte{0xFF}, bb.data()[14]);
   EXPECT_EQ(byte{0xFF}, bb.data()[15]);
 
-  EXPECT_EQ(Status::Ok(), bb.status());
+  EXPECT_EQ(OkStatus(), bb.status());
 }
 
 TEST(ByteBuffer, Putting64ByteInts_Exhausted_kBigEndian) {
@@ -527,7 +527,7 @@
   EXPECT_EQ(byte{0x17}, bb.data()[14]);
   EXPECT_EQ(byte{0xFB}, bb.data()[15]);
 
-  EXPECT_EQ(Status::Ok(), bb.status());
+  EXPECT_EQ(OkStatus(), bb.status());
 }
 
 TEST(ByteBuffer, Iterator) {
diff --git a/pw_bytes/public/pw_bytes/byte_builder.h b/pw_bytes/public/pw_bytes/byte_builder.h
index f046cb0..a145353 100644
--- a/pw_bytes/public/pw_bytes/byte_builder.h
+++ b/pw_bytes/public/pw_bytes/byte_builder.h
@@ -228,7 +228,7 @@
     return StatusWithSize(status_, size_);
   }
 
-  // True if status() is Status::Ok().
+  // True if status() is OkStatus().
   bool ok() const { return status_.ok(); }
 
   // True if the bytes builder is empty.
@@ -243,11 +243,11 @@
   // Clears the bytes and resets its error state.
   void clear() {
     size_ = 0;
-    status_ = Status::Ok();
+    status_ = OkStatus();
   };
 
-  // Sets the statuses to Status::Ok();
-  void clear_status() { status_ = Status::Ok(); }
+  // Sets the statuses to OkStatus();
+  void clear_status() { status_ = OkStatus(); }
 
   // Appends a single byte. Sets the status to RESOURCE_EXHAUSTED if the
   // byte cannot be added because the buffer is full.
diff --git a/pw_cpu_exception_armv7m/proto_dump.cc b/pw_cpu_exception_armv7m/proto_dump.cc
index 086652d..ea6774e 100644
--- a/pw_cpu_exception_armv7m/proto_dump.cc
+++ b/pw_cpu_exception_armv7m/proto_dump.cc
@@ -58,7 +58,7 @@
     return status == Status::ResourceExhausted() ? Status::ResourceExhausted()
                                                  : Status::Unknown();
   }
-  return Status::Ok();
+  return OkStatus();
 }
 
 }  // namespace pw::cpu_exception
diff --git a/pw_hdlc_lite/decoder.cc b/pw_hdlc_lite/decoder.cc
index fc96824..76d7ca0 100644
--- a/pw_hdlc_lite/decoder.cc
+++ b/pw_hdlc_lite/decoder.cc
@@ -125,7 +125,7 @@
     return Status::DataLoss();
   }
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 bool Decoder::VerifyFrameCheckSequence() const {
diff --git a/pw_hdlc_lite/decoder_test.cc b/pw_hdlc_lite/decoder_test.cc
index b8400e2..a74b34c 100644
--- a/pw_hdlc_lite/decoder_test.cc
+++ b/pw_hdlc_lite/decoder_test.cc
@@ -52,7 +52,7 @@
       bytes::String("~1234\xa3\xe0\xe3\x9b~"),
       [&status](const Result<Frame>& result) { status = result.status(); });
 
-  EXPECT_EQ(Status::Ok(), status);
+  EXPECT_EQ(OkStatus(), status);
 }
 
 TEST(Decoder, ExactFit) {
@@ -62,7 +62,7 @@
     EXPECT_EQ(Status::Unavailable(), decoder.Process(b).status());
   }
   auto result = decoder.Process(kFlag);
-  ASSERT_EQ(Status::Ok(), result.status());
+  ASSERT_EQ(OkStatus(), result.status());
   ASSERT_EQ(result.value().data().size(), 2u);
   ASSERT_EQ(result.value().data()[0], byte{'3'});
   ASSERT_EQ(result.value().data()[1], byte{'4'});
@@ -76,7 +76,7 @@
   }
 
   auto result = decoder.Process(kFlag);
-  ASSERT_EQ(Status::Ok(), result.status());
+  ASSERT_EQ(OkStatus(), result.status());
   EXPECT_EQ(result.value().data().size(), 0u);
 }
 
@@ -121,7 +121,7 @@
   for (byte b : bytes::String("1234\xa3\xe0\xe3\x9b")) {
     EXPECT_EQ(Status::Unavailable(), decoder.Process(b).status());
   }
-  EXPECT_EQ(Status::Ok(), decoder.Process(kFlag).status());
+  EXPECT_EQ(OkStatus(), decoder.Process(kFlag).status());
 }
 
 }  // namespace
diff --git a/pw_hdlc_lite/encoder.cc b/pw_hdlc_lite/encoder.cc
index 01b73f6..0602481 100644
--- a/pw_hdlc_lite/encoder.cc
+++ b/pw_hdlc_lite/encoder.cc
@@ -99,7 +99,7 @@
     }
     if (end == data.end()) {
       fcs_.Update(data);
-      return Status::Ok();
+      return OkStatus();
     }
     if (Status status = EscapeAndWrite(*end, writer_); !status.ok()) {
       return status;
diff --git a/pw_hdlc_lite/encoder_test.cc b/pw_hdlc_lite/encoder_test.cc
index 7c03bb5..195f3e4 100644
--- a/pw_hdlc_lite/encoder_test.cc
+++ b/pw_hdlc_lite/encoder_test.cc
@@ -51,20 +51,19 @@
 constexpr byte kUnnumberedControl = byte{0x3};
 
 TEST_F(WriteUnnumberedFrame, EmptyPayload) {
-  ASSERT_EQ(Status::Ok(), WriteUIFrame(kAddress, std::span<byte>(), writer_));
+  ASSERT_EQ(OkStatus(), WriteUIFrame(kAddress, std::span<byte>(), writer_));
   EXPECT_ENCODER_WROTE(bytes::Concat(
       kFlag, kAddress, kUnnumberedControl, uint32_t{0x141BE378}, kFlag));
 }
 
 TEST_F(WriteUnnumberedFrame, OneBytePayload) {
-  ASSERT_EQ(Status::Ok(), WriteUIFrame(kAddress, bytes::String("A"), writer_));
+  ASSERT_EQ(OkStatus(), WriteUIFrame(kAddress, bytes::String("A"), writer_));
   EXPECT_ENCODER_WROTE(bytes::Concat(
       kFlag, kAddress, kUnnumberedControl, 'A', uint32_t{0x8D137C66}, kFlag));
 }
 
 TEST_F(WriteUnnumberedFrame, OneBytePayload_Escape0x7d) {
-  ASSERT_EQ(Status::Ok(),
-            WriteUIFrame(kAddress, bytes::Array<0x7d>(), writer_));
+  ASSERT_EQ(OkStatus(), WriteUIFrame(kAddress, bytes::Array<0x7d>(), writer_));
   EXPECT_ENCODER_WROTE(bytes::Concat(kFlag,
                                      kAddress,
                                      kUnnumberedControl,
@@ -75,8 +74,7 @@
 }
 
 TEST_F(WriteUnnumberedFrame, OneBytePayload_Escape0x7E) {
-  ASSERT_EQ(Status::Ok(),
-            WriteUIFrame(kAddress, bytes::Array<0x7e>(), writer_));
+  ASSERT_EQ(OkStatus(), WriteUIFrame(kAddress, bytes::Array<0x7e>(), writer_));
   EXPECT_ENCODER_WROTE(bytes::Concat(kFlag,
                                      kAddress,
                                      kUnnumberedControl,
@@ -87,7 +85,7 @@
 }
 
 TEST_F(WriteUnnumberedFrame, AddressNeedsEscaping) {
-  ASSERT_EQ(Status::Ok(), WriteUIFrame(0x7d, bytes::String("A"), writer_));
+  ASSERT_EQ(OkStatus(), WriteUIFrame(0x7d, bytes::String("A"), writer_));
   EXPECT_ENCODER_WROTE(bytes::Concat(kFlag,
                                      kEscape,
                                      byte{0x5d},
@@ -98,7 +96,7 @@
 }
 
 TEST_F(WriteUnnumberedFrame, Crc32NeedsEscaping) {
-  ASSERT_EQ(Status::Ok(), WriteUIFrame(kAddress, bytes::String("a"), writer_));
+  ASSERT_EQ(OkStatus(), WriteUIFrame(kAddress, bytes::String("a"), writer_));
 
   // The CRC-32 is 0xB67D5CAE, so the 0x7D must be escaped.
   constexpr auto expected_crc32 = bytes::Array<0xae, 0x5c, 0x7d, 0x5d, 0xb6>();
@@ -111,10 +109,8 @@
 }
 
 TEST_F(WriteUnnumberedFrame, MultiplePayloads) {
-  ASSERT_EQ(Status::Ok(),
-            WriteUIFrame(kAddress, bytes::String("ABC"), writer_));
-  ASSERT_EQ(Status::Ok(),
-            WriteUIFrame(kAddress, bytes::String("DEF"), writer_));
+  ASSERT_EQ(OkStatus(), WriteUIFrame(kAddress, bytes::String("ABC"), writer_));
+  ASSERT_EQ(OkStatus(), WriteUIFrame(kAddress, bytes::String("DEF"), writer_));
   EXPECT_ENCODER_WROTE(bytes::Concat(kFlag,
                                      kAddress,
                                      kUnnumberedControl,
@@ -131,7 +127,7 @@
 
 TEST_F(WriteUnnumberedFrame, PayloadWithNoEscapes) {
   ASSERT_EQ(
-      Status::Ok(),
+      OkStatus(),
       WriteUIFrame(kAddress, bytes::String("1995 toyota corolla"), writer_));
 
   EXPECT_ENCODER_WROTE(bytes::Concat(kFlag,
@@ -144,7 +140,7 @@
 
 TEST_F(WriteUnnumberedFrame, PayloadWithMultipleEscapes) {
   ASSERT_EQ(
-      Status::Ok(),
+      OkStatus(),
       WriteUIFrame(kAddress,
                    bytes::Array<0x7E, 0x7B, 0x61, 0x62, 0x63, 0x7D, 0x7E>(),
                    writer_));
diff --git a/pw_hdlc_lite/public/pw_hdlc_lite/rpc_channel.h b/pw_hdlc_lite/public/pw_hdlc_lite/rpc_channel.h
index 049b1f7..a0ae997 100644
--- a/pw_hdlc_lite/public/pw_hdlc_lite/rpc_channel.h
+++ b/pw_hdlc_lite/public/pw_hdlc_lite/rpc_channel.h
@@ -47,7 +47,7 @@
   Status SendAndReleaseBuffer(std::span<const std::byte> buffer) override {
     PW_DASSERT(buffer.data() == buffer_.data());
     if (buffer.empty()) {
-      return Status::Ok();
+      return OkStatus();
     }
     return hdlc_lite::WriteUIFrame(address_, buffer, writer_);
   }
@@ -75,7 +75,7 @@
   Status SendAndReleaseBuffer(std::span<const std::byte> buffer) override {
     PW_DASSERT(buffer.data() == buffer_.data());
     if (buffer.empty()) {
-      return Status::Ok();
+      return OkStatus();
     }
     return hdlc_lite::WriteUIFrame(address_, buffer, writer_);
   }
diff --git a/pw_hdlc_lite/py/decode_test.py b/pw_hdlc_lite/py/decode_test.py
index ae90d69..9881bec 100755
--- a/pw_hdlc_lite/py/decode_test.py
+++ b/pw_hdlc_lite/py/decode_test.py
@@ -225,7 +225,7 @@
     if (std::holds_alternative<Status>(expected)) {{
       EXPECT_EQ(Status::DATA_LOSS, result.status());
     }} else {{
-      ASSERT_EQ(Status::OK, result.status());
+      ASSERT_EQ(OkStatus(), result.status());
 
       const Frame& decoded_frame = result.value();
       const Frame& expected_frame = std::get<Frame>(expected);
diff --git a/pw_hdlc_lite/rpc_channel_test.cc b/pw_hdlc_lite/rpc_channel_test.cc
index a7d4af3..4f40ba2 100644
--- a/pw_hdlc_lite/rpc_channel_test.cc
+++ b/pw_hdlc_lite/rpc_channel_test.cc
@@ -62,7 +62,7 @@
   constexpr auto expected = bytes::Concat(
       kFlag, kAddress, kControl, 'A', uint32_t{0x8D137C66}, kFlag);
 
-  EXPECT_EQ(Status::Ok(),
+  EXPECT_EQ(OkStatus(),
             output.SendAndReleaseBuffer(buffer.first(sizeof(test_data))));
 
   ASSERT_EQ(memory_writer.bytes_written(), expected.size());
@@ -90,7 +90,7 @@
                                           byte{0x7d} ^ byte{0x20},
                                           uint32_t{0xA27C00E1},
                                           kFlag);
-  EXPECT_EQ(Status::Ok(),
+  EXPECT_EQ(OkStatus(),
             output.SendAndReleaseBuffer(buffer.first(test_data.size())));
 
   ASSERT_EQ(memory_writer.bytes_written(), 10u);
@@ -113,7 +113,7 @@
   constexpr auto expected = bytes::Concat(
       kFlag, kAddress, kControl, 'A', uint32_t{0x8D137C66}, kFlag);
 
-  EXPECT_EQ(Status::Ok(),
+  EXPECT_EQ(OkStatus(),
             output.SendAndReleaseBuffer(buffer.first(sizeof(test_data))));
 
   ASSERT_EQ(memory_writer.bytes_written(), expected.size());
diff --git a/pw_hex_dump/hex_dump.cc b/pw_hex_dump/hex_dump.cc
index ae979df..67f0f3c 100644
--- a/pw_hex_dump/hex_dump.cc
+++ b/pw_hex_dump/hex_dump.cc
@@ -215,7 +215,7 @@
     return Status::InvalidArgument();
   }
   dest_ = dest;
-  return ValidateBufferSize().ok() ? Status::Ok() : Status::ResourceExhausted();
+  return ValidateBufferSize().ok() ? OkStatus() : Status::ResourceExhausted();
 }
 
 Status FormattedHexDumper::BeginDump(ConstByteSpan data) {
@@ -227,8 +227,7 @@
   if (dest_.data() != nullptr && dest_.size_bytes() > 0) {
     dest_[0] = 0;
   }
-  return ValidateBufferSize().ok() ? Status::Ok()
-                                   : Status::FailedPrecondition();
+  return ValidateBufferSize().ok() ? OkStatus() : Status::FailedPrecondition();
 }
 
 Status FormattedHexDumper::ValidateBufferSize() {
@@ -254,7 +253,7 @@
     return Status::ResourceExhausted();
   }
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 }  // namespace pw::dump
diff --git a/pw_hex_dump/hex_dump_test.cc b/pw_hex_dump/hex_dump_test.cc
index 1b10251..f374431 100644
--- a/pw_hex_dump/hex_dump_test.cc
+++ b/pw_hex_dump/hex_dump_test.cc
@@ -100,7 +100,7 @@
 TEST_F(HexDump, DumpAddr_ZeroSizeT) {
   constexpr const char* expected = EXPECTED_SIGNIFICANT_BYTES("00000000");
   size_t zero = 0;
-  EXPECT_EQ(DumpAddr(dest_, zero), Status::Ok());
+  EXPECT_EQ(DumpAddr(dest_, zero), OkStatus());
   EXPECT_STREQ(expected, dest_.data());
 }
 
diff --git a/pw_kvs/alignment_test.cc b/pw_kvs/alignment_test.cc
index 536de87..fca1a7f 100644
--- a/pw_kvs/alignment_test.cc
+++ b/pw_kvs/alignment_test.cc
@@ -141,26 +141,26 @@
   AlignedWriterBuffer<32> writer(kAlignment, check_against_data);
 
   // Write values smaller than the alignment.
-  EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(0, 1)).status());
-  EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(1, 9)).status());
+  EXPECT_EQ(OkStatus(), writer.Write(kBytes.subspan(0, 1)).status());
+  EXPECT_EQ(OkStatus(), writer.Write(kBytes.subspan(1, 9)).status());
 
   // Write values larger than the alignment but smaller than the buffer.
-  EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(10, 11)).status());
+  EXPECT_EQ(OkStatus(), writer.Write(kBytes.subspan(10, 11)).status());
 
   // Exactly fill the remainder of the buffer.
-  EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(21, 11)).status());
+  EXPECT_EQ(OkStatus(), writer.Write(kBytes.subspan(21, 11)).status());
 
   // Fill the buffer more than once.
-  EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(32, 66)).status());
+  EXPECT_EQ(OkStatus(), writer.Write(kBytes.subspan(32, 66)).status());
 
   // Write nothing.
-  EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(98, 0)).status());
+  EXPECT_EQ(OkStatus(), writer.Write(kBytes.subspan(98, 0)).status());
 
   // Write the remaining data.
-  EXPECT_EQ(Status::Ok(), writer.Write(kBytes.subspan(98, 2)).status());
+  EXPECT_EQ(OkStatus(), writer.Write(kBytes.subspan(98, 2)).status());
 
   auto result = writer.Flush();
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(OkStatus(), result.status());
   EXPECT_EQ(kData.size(), result.size());
 }
 
@@ -222,7 +222,7 @@
 
 TEST(AlignedWriter, Write_ReturnsTotalBytesWritten) {
   static Status return_status;
-  return_status = Status::Ok();
+  return_status = OkStatus();
 
   OutputToFunction output([](std::span<const byte> data) {
     return StatusWithSize(return_status, data.size());
@@ -232,11 +232,11 @@
 
   StatusWithSize result =
       writer.Write(std::as_bytes(std::span("12345678901"sv)));
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(OkStatus(), result.status());
   EXPECT_EQ(0u, result.size());  // No writes; haven't filled buffer.
 
   result = writer.Write(std::as_bytes(std::span("2345678901"sv)));
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(OkStatus(), result.status());
   EXPECT_EQ(20u, result.size());
 
   return_status = Status::PermissionDenied();
@@ -252,11 +252,11 @@
 
   AlignedWriterBuffer<4> writer(2, output);
 
-  EXPECT_EQ(Status::Ok(),
+  EXPECT_EQ(OkStatus(),
             writer.Write(std::as_bytes(std::span("12345678901"sv))).status());
 
   StatusWithSize result = writer.Flush();
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(OkStatus(), result.status());
   EXPECT_EQ(12u, result.size());
 }
 
@@ -306,11 +306,11 @@
 
   InputWithErrorInjection input;
   StatusWithSize result = writer.Write(input, kData.size());
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(OkStatus(), result.status());
   EXPECT_LE(result.size(), kData.size());  // May not have written it all yet.
 
   result = writer.Flush();
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(OkStatus(), result.status());
   EXPECT_EQ(kData.size(), result.size());
 }
 
diff --git a/pw_kvs/checksum.cc b/pw_kvs/checksum.cc
index 08f59b8..4215406 100644
--- a/pw_kvs/checksum.cc
+++ b/pw_kvs/checksum.cc
@@ -27,7 +27,7 @@
   if (std::memcmp(state_.data(), checksum.data(), size_bytes()) != 0) {
     return Status::DataLoss();
   }
-  return Status::Ok();
+  return OkStatus();
 }
 
 }  // namespace pw::kvs
diff --git a/pw_kvs/checksum_test.cc b/pw_kvs/checksum_test.cc
index 4fffae0..17e8f01 100644
--- a/pw_kvs/checksum_test.cc
+++ b/pw_kvs/checksum_test.cc
@@ -32,8 +32,7 @@
   ChecksumAlgorithm& algo = crc16_algo;
 
   algo.Update(kString.data(), kString.size());
-  EXPECT_EQ(Status::Ok(),
-            algo.Verify(std::as_bytes(std::span(&kStringCrc, 1))));
+  EXPECT_EQ(OkStatus(), algo.Verify(std::as_bytes(std::span(&kStringCrc, 1))));
 }
 
 TEST(Checksum, Verify_Failure) {
@@ -56,7 +55,7 @@
 
   algo.Update(std::as_bytes(std::span(kString)));
 
-  EXPECT_EQ(Status::Ok(), algo.Verify(crc));
+  EXPECT_EQ(OkStatus(), algo.Verify(crc));
 }
 
 TEST(Checksum, Reset) {
@@ -72,20 +71,20 @@
 TEST(IgnoreChecksum, NeverUpdate_VerifyWithoutData) {
   IgnoreChecksum checksum;
 
-  EXPECT_EQ(Status::Ok(), checksum.Verify({}));
+  EXPECT_EQ(OkStatus(), checksum.Verify({}));
 }
 
 TEST(IgnoreChecksum, NeverUpdate_VerifyWithData) {
   IgnoreChecksum checksum;
 
-  EXPECT_EQ(Status::Ok(), checksum.Verify(std::as_bytes(std::span(kString))));
+  EXPECT_EQ(OkStatus(), checksum.Verify(std::as_bytes(std::span(kString))));
 }
 
 TEST(IgnoreChecksum, AfterUpdate_Verify) {
   IgnoreChecksum checksum;
 
   checksum.Update(std::as_bytes(std::span(kString)));
-  EXPECT_EQ(Status::Ok(), checksum.Verify({}));
+  EXPECT_EQ(OkStatus(), checksum.Verify({}));
 }
 
 constexpr size_t kAlignment = 10;
@@ -144,7 +143,7 @@
   EXPECT_EQ(std::string_view(reinterpret_cast<const char*>(state.data()),
                              state.size()),
             kData);
-  EXPECT_EQ(Status::Ok(), checksum.Verify(kBytes));
+  EXPECT_EQ(OkStatus(), checksum.Verify(kBytes));
 }
 
 }  // namespace
diff --git a/pw_kvs/entry.cc b/pw_kvs/entry.cc
index 18fa216..fc01b0c 100644
--- a/pw_kvs/entry.cc
+++ b/pw_kvs/entry.cc
@@ -58,7 +58,7 @@
   }
 
   *entry = Entry(&partition, address, *format, header);
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status Entry::ReadKey(FlashPartition& partition,
@@ -183,12 +183,12 @@
     value_ptr += read_size;
   }
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status Entry::VerifyChecksum(Key key, std::span<const byte> value) const {
   if (checksum_algo_ == nullptr) {
-    return header_.checksum == 0 ? Status::Ok() : Status::DataLoss();
+    return header_.checksum == 0 ? OkStatus() : Status::DataLoss();
   }
   CalculateChecksum(key, value);
   return checksum_algo_->Verify(checksum_bytes());
@@ -218,7 +218,7 @@
   }
 
   if (checksum_algo_ == nullptr) {
-    return header_.checksum == 0 ? Status::Ok() : Status::DataLoss();
+    return header_.checksum == 0 ? OkStatus() : Status::DataLoss();
   }
 
   // The checksum is calculated as if the header's checksum field were 0.
@@ -279,7 +279,7 @@
   header_.checksum = 0;
 
   if (checksum_algo_ == nullptr) {
-    return Status::Ok();
+    return OkStatus();
   }
 
   checksum_algo_->Reset();
@@ -305,7 +305,7 @@
   std::memcpy(&header_.checksum,
               checksum.data(),
               std::min(checksum.size(), sizeof(header_.checksum)));
-  return Status::Ok();
+  return OkStatus();
 }
 
 void Entry::AddPaddingBytesToChecksum() const {
diff --git a/pw_kvs/entry_cache.cc b/pw_kvs/entry_cache.cc
index c63e349..e71d42e 100644
--- a/pw_kvs/entry_cache.cc
+++ b/pw_kvs/entry_cache.cc
@@ -107,7 +107,7 @@
       } else if (key == read_key) {
         PW_LOG_DEBUG("Found match for key hash 0x%08" PRIx32, hash);
         *metadata = EntryMetadata(descriptors_[i], addresses(i));
-        return StatusWithSize::Ok(error_val);
+        return StatusWithSize(error_val);
       } else {
         PW_LOG_WARN("Found key hash collision for 0x%08" PRIx32, hash);
         return StatusWithSize::AlreadyExists(error_val);
@@ -142,14 +142,14 @@
       return Status::ResourceExhausted();
     }
     AddNew(descriptor, address);
-    return Status::Ok();
+    return OkStatus();
   }
 
   // Existing entry is old; replace the existing entry with the new one.
   if (descriptor.transaction_id > descriptors_[index].transaction_id) {
     descriptors_[index] = descriptor;
     ResetAddresses(index, address);
-    return Status::Ok();
+    return OkStatus();
   }
 
   // If the entries have a duplicate transaction ID, add the new (redundant)
@@ -177,7 +177,7 @@
   } else {
     PW_LOG_DEBUG("Found stale entry when appending; ignoring");
   }
-  return Status::Ok();
+  return OkStatus();
 }
 
 size_t EntryCache::present_entries() const {
diff --git a/pw_kvs/entry_cache_test.cc b/pw_kvs/entry_cache_test.cc
index 7d6a25f..6b7c9fa 100644
--- a/pw_kvs/entry_cache_test.cc
+++ b/pw_kvs/entry_cache_test.cc
@@ -83,7 +83,7 @@
 }
 
 TEST_F(EmptyEntryCache, AddNewOrUpdateExisting_NewEntry) {
-  ASSERT_EQ(Status::Ok(),
+  ASSERT_EQ(OkStatus(),
             entries_.AddNewOrUpdateExisting(kDescriptor, 1000, 2000));
 
   EXPECT_EQ(1u, entries_.present_entries());
@@ -98,7 +98,7 @@
 TEST_F(EmptyEntryCache, AddNewOrUpdateExisting_NewEntry_Full) {
   for (uint32_t i = 0; i < kMaxEntries; ++i) {
     ASSERT_EQ(  // Fill up the cache
-        Status::Ok(),
+        OkStatus(),
         entries_.AddNewOrUpdateExisting({i, i, EntryState::kValid}, i, 1));
   }
   ASSERT_EQ(kMaxEntries, entries_.total_entries());
@@ -113,7 +113,7 @@
   KeyDescriptor kd = kDescriptor;
   kd.transaction_id += 3;
 
-  ASSERT_EQ(Status::Ok(), entries_.AddNewOrUpdateExisting(kd, 3210, 2000));
+  ASSERT_EQ(OkStatus(), entries_.AddNewOrUpdateExisting(kd, 3210, 2000));
 
   EXPECT_EQ(1u, entries_.present_entries());
 
@@ -125,15 +125,15 @@
 }
 
 TEST_F(EmptyEntryCache, AddNewOrUpdateExisting_AddDuplicateEntry) {
-  ASSERT_EQ(Status::Ok(),
+  ASSERT_EQ(OkStatus(),
             entries_.AddNewOrUpdateExisting(kDescriptor, 1000, 2000));
-  ASSERT_EQ(Status::Ok(),
+  ASSERT_EQ(OkStatus(),
             entries_.AddNewOrUpdateExisting(kDescriptor, 3000, 2000));
-  ASSERT_EQ(Status::Ok(),
+  ASSERT_EQ(OkStatus(),
             entries_.AddNewOrUpdateExisting(kDescriptor, 7000, 2000));
 
   // Duplicates beyond the redundancy are ignored.
-  ASSERT_EQ(Status::Ok(),
+  ASSERT_EQ(OkStatus(),
             entries_.AddNewOrUpdateExisting(kDescriptor, 9000, 2000));
 
   EXPECT_EQ(1u, entries_.present_entries());
@@ -150,7 +150,7 @@
 }
 
 TEST_F(EmptyEntryCache, AddNewOrUpdateExisting_AddDuplicateEntryInSameSector) {
-  ASSERT_EQ(Status::Ok(),
+  ASSERT_EQ(OkStatus(),
             entries_.AddNewOrUpdateExisting(kDescriptor, 1000, 1000));
   EXPECT_EQ(Status::DataLoss(),
             entries_.AddNewOrUpdateExisting(kDescriptor, 1950, 1000));
@@ -320,7 +320,7 @@
   StatusWithSize result =
       entries_.Find(partition_, sectors_, format_, kTheKey, &metadata);
 
-  ASSERT_EQ(Status::Ok(), result.status());
+  ASSERT_EQ(OkStatus(), result.status());
   EXPECT_EQ(0u, result.size());
   EXPECT_EQ(Hash(kTheKey), metadata.hash());
   EXPECT_EQ(EntryState::kValid, metadata.state());
@@ -337,7 +337,7 @@
   StatusWithSize result =
       entries_.Find(partition_, sectors_, format_, kTheKey, &metadata);
 
-  ASSERT_EQ(Status::Ok(), result.status());
+  ASSERT_EQ(OkStatus(), result.status());
   EXPECT_EQ(1u, result.size());
   EXPECT_EQ(Hash(kTheKey), metadata.hash());
   EXPECT_EQ(EntryState::kValid, metadata.state());
@@ -364,7 +364,7 @@
   StatusWithSize result =
       entries_.Find(partition_, sectors_, format_, "delorted", &metadata);
 
-  ASSERT_EQ(Status::Ok(), result.status());
+  ASSERT_EQ(OkStatus(), result.status());
   EXPECT_EQ(0u, result.size());
   EXPECT_EQ(Hash("delorted"), metadata.hash());
   EXPECT_EQ(EntryState::kDeleted, metadata.state());
diff --git a/pw_kvs/entry_test.cc b/pw_kvs/entry_test.cc
index 8ac1d1a..f9496e3 100644
--- a/pw_kvs/entry_test.cc
+++ b/pw_kvs/entry_test.cc
@@ -116,7 +116,7 @@
 class ValidEntryInFlash : public ::testing::Test {
  protected:
   ValidEntryInFlash() : flash_(kEntry1), partition_(&flash_) {
-    EXPECT_EQ(Status::Ok(), Entry::Read(partition_, 0, kFormats, &entry_));
+    EXPECT_EQ(OkStatus(), Entry::Read(partition_, 0, kFormats, &entry_));
   }
 
   FakeFlashMemoryBuffer<1024, 4> flash_;
@@ -125,8 +125,8 @@
 };
 
 TEST_F(ValidEntryInFlash, PassesChecksumVerification) {
-  EXPECT_EQ(Status::Ok(), entry_.VerifyChecksumInFlash());
-  EXPECT_EQ(Status::Ok(), entry_.VerifyChecksum("key45", kValue1));
+  EXPECT_EQ(OkStatus(), entry_.VerifyChecksumInFlash());
+  EXPECT_EQ(OkStatus(), entry_.VerifyChecksum("key45", kValue1));
 }
 
 TEST_F(ValidEntryInFlash, HeaderContents) {
@@ -141,7 +141,7 @@
   Entry::KeyBuffer key = {};
   auto result = entry_.ReadKey(key);
 
-  ASSERT_EQ(Status::Ok(), result.status());
+  ASSERT_EQ(OkStatus(), result.status());
   EXPECT_EQ(result.size(), entry_.key_length());
   EXPECT_STREQ(key.data(), "key45");
 }
@@ -150,7 +150,7 @@
   char value[32] = {};
   auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)));
 
-  ASSERT_EQ(Status::Ok(), result.status());
+  ASSERT_EQ(OkStatus(), result.status());
   EXPECT_EQ(result.size(), entry_.value_size());
   EXPECT_STREQ(value, "VALUE!");
 }
@@ -170,7 +170,7 @@
   char value[3] = {};
   auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)), 3);
 
-  ASSERT_EQ(Status::Ok(), result.status());
+  ASSERT_EQ(OkStatus(), result.status());
   EXPECT_EQ(3u, result.size());
   EXPECT_EQ(value[0], 'U');
   EXPECT_EQ(value[1], 'E');
@@ -190,7 +190,7 @@
   char value[16] = {'?'};
   auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)), 6);
 
-  ASSERT_EQ(Status::Ok(), result.status());
+  ASSERT_EQ(OkStatus(), result.status());
   EXPECT_EQ(0u, result.size());
   EXPECT_EQ(value[0], '?');
 }
@@ -211,7 +211,7 @@
       partition, 64, kFormatWithChecksum, "key45", kValue1, kTransactionId1);
 
   auto result = entry.Write("key45", kValue1);
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(OkStatus(), result.status());
   EXPECT_EQ(32u, result.size());
   EXPECT_EQ(std::memcmp(&flash.buffer()[64], kEntry1.data(), kEntry1.size()),
             0);
@@ -233,7 +233,7 @@
  protected:
   TombstoneEntryInFlash()
       : flash_(bytes::Concat(kHeader2, kKeyAndPadding2)), partition_(&flash_) {
-    EXPECT_EQ(Status::Ok(), Entry::Read(partition_, 0, kFormats, &entry_));
+    EXPECT_EQ(OkStatus(), Entry::Read(partition_, 0, kFormats, &entry_));
   }
 
   FakeFlashMemoryBuffer<1024, 4> flash_;
@@ -242,8 +242,8 @@
 };
 
 TEST_F(TombstoneEntryInFlash, PassesChecksumVerification) {
-  EXPECT_EQ(Status::Ok(), entry_.VerifyChecksumInFlash());
-  EXPECT_EQ(Status::Ok(), entry_.VerifyChecksum("K", {}));
+  EXPECT_EQ(OkStatus(), entry_.VerifyChecksumInFlash());
+  EXPECT_EQ(OkStatus(), entry_.VerifyChecksum("K", {}));
 }
 
 TEST_F(TombstoneEntryInFlash, HeaderContents) {
@@ -258,7 +258,7 @@
   Entry::KeyBuffer key = {};
   auto result = entry_.ReadKey(key);
 
-  ASSERT_EQ(Status::Ok(), result.status());
+  ASSERT_EQ(OkStatus(), result.status());
   EXPECT_EQ(result.size(), entry_.key_length());
   EXPECT_STREQ(key.data(), "K");
 }
@@ -267,7 +267,7 @@
   char value[32] = {};
   auto result = entry_.ReadValue(std::as_writable_bytes(std::span(value)));
 
-  ASSERT_EQ(Status::Ok(), result.status());
+  ASSERT_EQ(OkStatus(), result.status());
   EXPECT_EQ(0u, result.size());
 }
 
@@ -280,7 +280,7 @@
       Entry::Tombstone(partition, 16, kFormatWithChecksum, "K", 0x03020100);
 
   auto result = entry.Write("K", {});
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(OkStatus(), result.status());
   EXPECT_EQ(32u, result.size());
   EXPECT_EQ(std::memcmp(&flash.buffer()[16],
                         bytes::Concat(kHeader2, kKeyAndPadding2).data(),
@@ -296,15 +296,15 @@
   const EntryFormat format{kMagicWithChecksum, nullptr};
   const internal::EntryFormats formats(format);
 
-  ASSERT_EQ(Status::Ok(), Entry::Read(partition, 0, formats, &entry));
+  ASSERT_EQ(OkStatus(), Entry::Read(partition, 0, formats, &entry));
 
   EXPECT_EQ(Status::DataLoss(), entry.VerifyChecksumInFlash());
   EXPECT_EQ(Status::DataLoss(), entry.VerifyChecksum({}, {}));
 
   std::memset(&flash.buffer()[4], 0, 4);  // set the checksum field to 0
-  ASSERT_EQ(Status::Ok(), Entry::Read(partition, 0, formats, &entry));
-  EXPECT_EQ(Status::Ok(), entry.VerifyChecksumInFlash());
-  EXPECT_EQ(Status::Ok(), entry.VerifyChecksum({}, {}));
+  ASSERT_EQ(OkStatus(), Entry::Read(partition, 0, formats, &entry));
+  EXPECT_EQ(OkStatus(), entry.VerifyChecksumInFlash());
+  EXPECT_EQ(OkStatus(), entry.VerifyChecksum({}, {}));
 }
 
 TEST(Entry, Checksum_ChecksPadding) {
@@ -312,20 +312,20 @@
       bytes::Concat(kHeader1, kKey1, kValue1, bytes::String("\0\0\0\0\1")));
   FlashPartition partition(&flash);
   Entry entry;
-  ASSERT_EQ(Status::Ok(), Entry::Read(partition, 0, kFormats, &entry));
+  ASSERT_EQ(OkStatus(), Entry::Read(partition, 0, kFormats, &entry));
 
   // Last byte in padding is a 1; should fail.
   EXPECT_EQ(Status::DataLoss(), entry.VerifyChecksumInFlash());
 
   // The in-memory verification fills in 0s for the padding.
-  EXPECT_EQ(Status::Ok(), entry.VerifyChecksum("key45", kValue1));
+  EXPECT_EQ(OkStatus(), entry.VerifyChecksum("key45", kValue1));
 
   flash.buffer()[kEntry1.size() - 1] = byte{0};
-  EXPECT_EQ(Status::Ok(), entry.VerifyChecksumInFlash());
+  EXPECT_EQ(OkStatus(), entry.VerifyChecksumInFlash());
 }
 
 TEST_F(ValidEntryInFlash, Update_SameFormat_TransactionIdIsUpdated) {
-  ASSERT_EQ(Status::Ok(),
+  ASSERT_EQ(OkStatus(),
             entry_.Update(kFormatWithChecksum, kTransactionId1 + 3));
 
   EXPECT_EQ(kFormatWithChecksum.magic, entry_.magic());
@@ -336,7 +336,7 @@
 
 TEST_F(ValidEntryInFlash,
        Update_DifferentFormat_MagicAndTransactionIdAreUpdated) {
-  ASSERT_EQ(Status::Ok(), entry_.Update(kFormat, kTransactionId1 + 6));
+  ASSERT_EQ(OkStatus(), entry_.Update(kFormat, kTransactionId1 + 6));
 
   EXPECT_EQ(kFormat.magic, entry_.magic());
   EXPECT_EQ(0u, entry_.address());
@@ -359,14 +359,13 @@
 TEST_F(ValidEntryInFlash, Update_ReadError_NoChecksumIsOkay) {
   flash_.InjectReadError(FlashError::Unconditional(Status::Aborted()));
 
-  EXPECT_EQ(Status::Ok(),
-            entry_.Update(kNoChecksumFormat, kTransactionId1 + 1));
+  EXPECT_EQ(OkStatus(), entry_.Update(kNoChecksumFormat, kTransactionId1 + 1));
 }
 
 TEST_F(ValidEntryInFlash, Copy) {
   auto result = entry_.Copy(123);
 
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(OkStatus(), result.status());
   EXPECT_EQ(entry_.size(), result.size());
   EXPECT_EQ(0,
             std::memcmp(
@@ -436,10 +435,10 @@
 
 TEST_F(ValidEntryInFlash, UpdateAndCopy_DifferentFormatSmallerAlignment) {
   // Uses 16-bit alignment, smaller than the original entry's alignment.
-  ASSERT_EQ(Status::Ok(), entry_.Update(kFormatWithSum, kTransactionId1 + 1));
+  ASSERT_EQ(OkStatus(), entry_.Update(kFormatWithSum, kTransactionId1 + 1));
 
   StatusWithSize result = entry_.Copy(kEntry1.size());
-  ASSERT_EQ(Status::Ok(), result.status());
+  ASSERT_EQ(OkStatus(), result.status());
   EXPECT_EQ(kEntry1.size(), result.size());
 
   constexpr auto new_data = MakeNewFormatWithSumEntry<16>();
@@ -450,9 +449,9 @@
       std::memcmp(
           &flash_.buffer()[kEntry1.size()], new_data.data(), new_data.size()));
   Entry new_entry;
-  ASSERT_EQ(Status::Ok(),
+  ASSERT_EQ(OkStatus(),
             Entry::Read(partition_, 32, kFormatsWithSum, &new_entry));
-  EXPECT_EQ(Status::Ok(), new_entry.VerifyChecksumInFlash());
+  EXPECT_EQ(OkStatus(), new_entry.VerifyChecksumInFlash());
   EXPECT_EQ(kFormatWithSum.magic, new_entry.magic());
   EXPECT_EQ(kTransactionId1 + 1, new_entry.transaction_id());
 }
@@ -462,12 +461,12 @@
   FakeFlashMemoryBuffer<1024, 4> flash(kEntry1);
   FlashPartition partition(&flash, 0, 4, 32);
   Entry entry;
-  ASSERT_EQ(Status::Ok(), Entry::Read(partition, 0, kFormats, &entry));
+  ASSERT_EQ(OkStatus(), Entry::Read(partition, 0, kFormats, &entry));
 
-  ASSERT_EQ(Status::Ok(), entry.Update(kFormatWithSum, kTransactionId1 + 1));
+  ASSERT_EQ(OkStatus(), entry.Update(kFormatWithSum, kTransactionId1 + 1));
 
   StatusWithSize result = entry.Copy(32);
-  ASSERT_EQ(Status::Ok(), result.status());
+  ASSERT_EQ(OkStatus(), result.status());
   EXPECT_EQ(AlignUp(kEntry1.size(), 32), result.size());
 
   constexpr auto new_data = MakeNewFormatWithSumEntry<32>();
@@ -477,9 +476,9 @@
             std::memcmp(&flash.buffer()[32], new_data.data(), new_data.size()));
 
   Entry new_entry;
-  ASSERT_EQ(Status::Ok(),
+  ASSERT_EQ(OkStatus(),
             Entry::Read(partition, 32, kFormatsWithSum, &new_entry));
-  EXPECT_EQ(Status::Ok(), new_entry.VerifyChecksumInFlash());
+  EXPECT_EQ(OkStatus(), new_entry.VerifyChecksumInFlash());
   EXPECT_EQ(kTransactionId1 + 1, new_entry.transaction_id());
 }
 
@@ -488,12 +487,12 @@
   FakeFlashMemoryBuffer<1024, 4> flash(kEntry1);
   FlashPartition partition(&flash, 0, 4, 64);
   Entry entry;
-  ASSERT_EQ(Status::Ok(), Entry::Read(partition, 0, kFormats, &entry));
+  ASSERT_EQ(OkStatus(), Entry::Read(partition, 0, kFormats, &entry));
 
-  ASSERT_EQ(Status::Ok(), entry.Update(kFormatWithSum, kTransactionId1 + 1));
+  ASSERT_EQ(OkStatus(), entry.Update(kFormatWithSum, kTransactionId1 + 1));
 
   StatusWithSize result = entry.Copy(64);
-  ASSERT_EQ(Status::Ok(), result.status());
+  ASSERT_EQ(OkStatus(), result.status());
   EXPECT_EQ(AlignUp(kEntry1.size(), 64), result.size());
 
   constexpr auto new_data = MakeNewFormatWithSumEntry<64>();
@@ -503,9 +502,9 @@
             std::memcmp(&flash.buffer()[64], new_data.data(), new_data.size()));
 
   Entry new_entry;
-  ASSERT_EQ(Status::Ok(),
+  ASSERT_EQ(OkStatus(),
             Entry::Read(partition, 64, kFormatsWithSum, &new_entry));
-  EXPECT_EQ(Status::Ok(), new_entry.VerifyChecksumInFlash());
+  EXPECT_EQ(OkStatus(), new_entry.VerifyChecksumInFlash());
   EXPECT_EQ(kTransactionId1 + 1, new_entry.transaction_id());
 }
 
@@ -514,10 +513,10 @@
   // readable 4 bytes. See pw_kvs/format.h for more information.
   constexpr EntryFormat no_checksum{.magic = 0x43fae18f, .checksum = nullptr};
 
-  ASSERT_EQ(Status::Ok(), entry_.Update(no_checksum, kTransactionId1 + 1));
+  ASSERT_EQ(OkStatus(), entry_.Update(no_checksum, kTransactionId1 + 1));
 
   auto result = entry_.Copy(kEntry1.size());
-  ASSERT_EQ(Status::Ok(), result.status());
+  ASSERT_EQ(OkStatus(), result.status());
   EXPECT_EQ(kEntry1.size(), result.size());
 
   constexpr auto kNewHeader1 =
@@ -537,23 +536,23 @@
 }
 
 TEST_F(ValidEntryInFlash, UpdateAndCopyMultple_DifferentFormat) {
-  ASSERT_EQ(Status::Ok(), entry_.Update(kFormatWithSum, kTransactionId1 + 6));
+  ASSERT_EQ(OkStatus(), entry_.Update(kFormatWithSum, kTransactionId1 + 6));
 
   FlashPartition::Address new_address = entry_.size();
 
   for (int i = 0; i < 10; i++) {
     StatusWithSize copy_result = entry_.Copy(new_address + (i * entry_.size()));
-    ASSERT_EQ(Status::Ok(), copy_result.status());
+    ASSERT_EQ(OkStatus(), copy_result.status());
     ASSERT_EQ(kEntry1.size(), copy_result.size());
   }
 
   for (int j = 0; j < 10; j++) {
     Entry entry;
     FlashPartition::Address read_address = (new_address + (j * entry_.size()));
-    ASSERT_EQ(Status::Ok(),
+    ASSERT_EQ(OkStatus(),
               Entry::Read(partition_, read_address, kFormatsWithSum, &entry));
 
-    EXPECT_EQ(Status::Ok(), entry.VerifyChecksumInFlash());
+    EXPECT_EQ(OkStatus(), entry.VerifyChecksumInFlash());
     EXPECT_EQ(kFormatWithSum.magic, entry.magic());
     EXPECT_EQ(read_address, entry.address());
     EXPECT_EQ(kTransactionId1 + 6, entry.transaction_id());
@@ -562,12 +561,12 @@
 }
 
 TEST_F(ValidEntryInFlash, DifferentFormat_UpdatedCopy_FailsWithWrongMagic) {
-  ASSERT_EQ(Status::Ok(), entry_.Update(kFormatWithSum, kTransactionId1 + 6));
+  ASSERT_EQ(OkStatus(), entry_.Update(kFormatWithSum, kTransactionId1 + 6));
 
   FlashPartition::Address new_address = entry_.size();
 
   StatusWithSize copy_result = entry_.Copy(new_address);
-  ASSERT_EQ(Status::Ok(), copy_result.status());
+  ASSERT_EQ(OkStatus(), copy_result.status());
   ASSERT_EQ(kEntry1.size(), copy_result.size());
 
   Entry entry;
@@ -578,8 +577,7 @@
 TEST_F(ValidEntryInFlash, UpdateAndCopy_WriteError) {
   flash_.InjectWriteError(FlashError::Unconditional(Status::Cancelled()));
 
-  ASSERT_EQ(Status::Ok(),
-            entry_.Update(kNoChecksumFormat, kTransactionId1 + 1));
+  ASSERT_EQ(OkStatus(), entry_.Update(kNoChecksumFormat, kTransactionId1 + 1));
 
   auto result = entry_.Copy(kEntry1.size());
   EXPECT_EQ(Status::Cancelled(), result.status());
diff --git a/pw_kvs/fake_flash_memory.cc b/pw_kvs/fake_flash_memory.cc
index 7796a72..4c30913 100644
--- a/pw_kvs/fake_flash_memory.cc
+++ b/pw_kvs/fake_flash_memory.cc
@@ -31,23 +31,23 @@
     }
   }
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status FlashError::Check(FlashMemory::Address start_address, size_t size) {
   // Check if the event overlaps with this address range.
   if (begin_ != kAnyAddress &&
       (start_address >= end_ || (start_address + size) <= begin_)) {
-    return Status::Ok();
+    return OkStatus();
   }
 
   if (delay_ > 0u) {
     delay_ -= 1;
-    return Status::Ok();
+    return OkStatus();
   }
 
   if (remaining_ == 0u) {
-    return Status::Ok();
+    return OkStatus();
   }
 
   if (remaining_ != kAlways) {
@@ -76,7 +76,7 @@
 
   std::memset(
       &buffer_[address], int(kErasedValue), sector_size_bytes() * num_sectors);
-  return Status::Ok();
+  return OkStatus();
 }
 
 StatusWithSize FakeFlashMemory::Read(Address address,
diff --git a/pw_kvs/flash_memory.cc b/pw_kvs/flash_memory.cc
index 93e08d7..1bcacf6 100644
--- a/pw_kvs/flash_memory.cc
+++ b/pw_kvs/flash_memory.cc
@@ -125,7 +125,7 @@
     for (byte b : std::span(buffer, read_size)) {
       if (b != erased_byte) {
         // Detected memory chunk is not entirely erased
-        return Status::Ok();
+        return OkStatus();
       }
     }
 
@@ -133,7 +133,7 @@
     length -= read_size;
   }
   *is_erased = true;
-  return Status::Ok();
+  return OkStatus();
 }
 
 bool FlashPartition::AppearsErased(std::span<const byte> data) const {
@@ -154,7 +154,7 @@
         unsigned(length));
     return Status::OutOfRange();
   }
-  return Status::Ok();
+  return OkStatus();
 }
 
 }  // namespace pw::kvs
diff --git a/pw_kvs/flash_partition_test.cc b/pw_kvs/flash_partition_test.cc
index b9a2299..193f3d2 100644
--- a/pw_kvs/flash_partition_test.cc
+++ b/pw_kvs/flash_partition_test.cc
@@ -37,7 +37,7 @@
 
   const size_t alignment = partition.alignment_bytes();
 
-  ASSERT_EQ(Status::Ok(), partition.Erase(0, partition.sector_count()));
+  ASSERT_EQ(OkStatus(), partition.Erase(0, partition.sector_count()));
 
   const size_t chunks_per_sector = partition.sector_size_bytes() / alignment;
 
@@ -53,7 +53,7 @@
          chunk_index++) {
       StatusWithSize status =
           partition.Write(address, as_bytes(std::span(test_data, alignment)));
-      ASSERT_EQ(Status::Ok(), status.status());
+      ASSERT_EQ(OkStatus(), status.status());
       ASSERT_EQ(alignment, status.size());
       address += alignment;
     }
@@ -71,7 +71,7 @@
       memset(test_data, 0, sizeof(test_data));
       StatusWithSize status = partition.Read(address, alignment, test_data);
 
-      EXPECT_EQ(Status::Ok(), status.status());
+      EXPECT_EQ(OkStatus(), status.status());
       EXPECT_EQ(alignment, status.size());
       if (!status.ok() || (alignment != status.size())) {
         error_count++;
@@ -140,8 +140,7 @@
       std::min(sizeof(test_data), test_partition.sector_size_bytes());
   auto data_span = std::span(test_data, block_size);
 
-  ASSERT_EQ(Status::Ok(),
-            test_partition.Erase(0, test_partition.sector_count()));
+  ASSERT_EQ(OkStatus(), test_partition.Erase(0, test_partition.sector_count()));
 
   // Write to the first page of each sector.
   for (size_t sector_index = 0; sector_index < test_partition.sector_count();
@@ -150,20 +149,20 @@
         sector_index * test_partition.sector_size_bytes();
 
     StatusWithSize status = test_partition.Write(address, as_bytes(data_span));
-    ASSERT_EQ(Status::Ok(), status.status());
+    ASSERT_EQ(OkStatus(), status.status());
     ASSERT_EQ(block_size, status.size());
   }
 
   // Preset the flag to make sure the check actually sets it.
   bool is_erased = true;
-  ASSERT_EQ(Status::Ok(), test_partition.IsErased(&is_erased));
+  ASSERT_EQ(OkStatus(), test_partition.IsErased(&is_erased));
   ASSERT_EQ(false, is_erased);
 
-  ASSERT_EQ(Status::Ok(), test_partition.Erase());
+  ASSERT_EQ(OkStatus(), test_partition.Erase());
 
   // Preset the flag to make sure the check actually sets it.
   is_erased = false;
-  ASSERT_EQ(Status::Ok(), test_partition.IsErased(&is_erased));
+  ASSERT_EQ(OkStatus(), test_partition.IsErased(&is_erased));
   ASSERT_EQ(true, is_erased);
 
   // Read the first page of each sector and make sure it has been erased.
@@ -174,7 +173,7 @@
 
     StatusWithSize status =
         test_partition.Read(address, data_span.size_bytes(), data_span.data());
-    EXPECT_EQ(Status::Ok(), status.status());
+    EXPECT_EQ(OkStatus(), status.status());
     EXPECT_EQ(data_span.size_bytes(), status.size());
 
     EXPECT_EQ(true, test_partition.AppearsErased(as_bytes(data_span)));
@@ -243,10 +242,10 @@
   // Make sure the partition is big enough to do this test.
   ASSERT_GE(test_partition.size_bytes(), 3 * kMaxFlashAlignment);
 
-  ASSERT_EQ(Status::Ok(), test_partition.Erase());
+  ASSERT_EQ(OkStatus(), test_partition.Erase());
 
   bool is_erased = true;
-  ASSERT_EQ(Status::Ok(), test_partition.IsErased(&is_erased));
+  ASSERT_EQ(OkStatus(), test_partition.IsErased(&is_erased));
   ASSERT_EQ(true, is_erased);
 
   static const uint8_t fill_byte = 0x55;
@@ -256,26 +255,26 @@
 
   // Write the chunk with fill byte.
   StatusWithSize status = test_partition.Write(alignment, as_bytes(data_span));
-  ASSERT_EQ(Status::Ok(), status.status());
+  ASSERT_EQ(OkStatus(), status.status());
   ASSERT_EQ(data_span.size_bytes(), status.size());
 
-  EXPECT_EQ(Status::Ok(), test_partition.IsErased(&is_erased));
+  EXPECT_EQ(OkStatus(), test_partition.IsErased(&is_erased));
   EXPECT_EQ(false, is_erased);
 
   // Check the chunk that was written.
-  EXPECT_EQ(Status::Ok(),
+  EXPECT_EQ(OkStatus(),
             test_partition.IsRegionErased(
                 alignment, data_span.size_bytes(), &is_erased));
   EXPECT_EQ(false, is_erased);
 
   // Check a region that starts erased but later has been written.
-  EXPECT_EQ(Status::Ok(),
+  EXPECT_EQ(OkStatus(),
             test_partition.IsRegionErased(0, 2 * alignment, &is_erased));
   EXPECT_EQ(false, is_erased);
 
   // Check erased for a region smaller than kMaxFlashAlignment. This has been a
   // bug in the past.
-  EXPECT_EQ(Status::Ok(),
+  EXPECT_EQ(OkStatus(),
             test_partition.IsRegionErased(0, alignment, &is_erased));
   EXPECT_EQ(true, is_erased);
 }
diff --git a/pw_kvs/flash_partition_with_stats.cc b/pw_kvs/flash_partition_with_stats.cc
index 6b2431b..26b0eee 100644
--- a/pw_kvs/flash_partition_with_stats.cc
+++ b/pw_kvs/flash_partition_with_stats.cc
@@ -29,7 +29,7 @@
                                                  const char* label) {
   // If size is zero saving stats is disabled so do not save any stats.
   if (sector_counters_.size() == 0) {
-    return Status::Ok();
+    return OkStatus();
   }
 
   KeyValueStore::StorageStats stats = kvs.GetStorageStats();
@@ -67,7 +67,7 @@
 
   std::fprintf(out_file, "\n");
   std::fclose(out_file);
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status FlashPartitionWithStats::Erase(Address address, size_t num_sectors) {
diff --git a/pw_kvs/key_value_store.cc b/pw_kvs/key_value_store.cc
index 77ed52d..6c2a1a6 100644
--- a/pw_kvs/key_value_store.cc
+++ b/pw_kvs/key_value_store.cc
@@ -134,7 +134,7 @@
     return Status::DataLoss();
   }
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status KeyValueStore::InitializeMetadata() {
@@ -295,7 +295,7 @@
         unsigned(entry_copies_missing));
     return Status::FailedPrecondition();
   }
-  return Status::Ok();
+  return OkStatus();
 }
 
 KeyValueStore::StorageStats KeyValueStore::GetStorageStats() const {
@@ -394,7 +394,7 @@
     if (formats_.KnownMagic(magic)) {
       DBG("Found entry magic at address %u", unsigned(address));
       *next_entry_address = address;
-      return Status::Ok();
+      return OkStatus();
     }
   }
 
@@ -605,7 +605,7 @@
   if (!initialized()) {
     return Status::FailedPrecondition();
   }
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status KeyValueStore::CheckReadOperation(Key key) const {
@@ -618,7 +618,7 @@
   if (initialized_ == InitializationState::kNotInitialized) {
     return Status::FailedPrecondition();
   }
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status KeyValueStore::WriteEntryForExistingKey(EntryMetadata& metadata,
@@ -659,7 +659,7 @@
     // keep the existing entry.
     DBG("Write for key 0x%08x with matching value skipped",
         unsigned(prior_metadata->hash()));
-    return Status::Ok();
+    return OkStatus();
   }
 
   // List of addresses for sectors with space for this entry.
@@ -686,7 +686,7 @@
     PW_TRY(AppendEntry(entry, key, value));
     new_metadata.AddNewAddress(reserved_addresses[i]);
   }
-  return Status::Ok();
+  return OkStatus();
 }
 
 KeyValueStore::EntryMetadata KeyValueStore::CreateOrUpdateKeyDescriptor(
@@ -730,7 +730,7 @@
         unsigned(write_addresses[i]));
   }
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 // Finds a sector to use for writing a new entry to. Does automatic garbage
@@ -813,7 +813,7 @@
 
   sector.RemoveWritableBytes(result.size());
   sector.AddValidBytes(result.size());
-  return Status::Ok();
+  return OkStatus();
 }
 
 StatusWithSize KeyValueStore::CopyEntryToSector(Entry& entry,
@@ -864,7 +864,7 @@
   sectors_.FromAddress(address).RemoveValidBytes(result_size);
   address = new_address;
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status KeyValueStore::FullMaintenanceHelper(MaintenanceType maintenance_type) {
@@ -976,7 +976,7 @@
     }
   }
 
-  return Status::Ok();
+  return OkStatus();
 };
 
 Status KeyValueStore::GarbageCollectSector(
@@ -1008,7 +1008,7 @@
   }
 
   DBG("  Garbage Collect sector %u complete", sectors_.Index(sector_to_gc));
-  return Status::Ok();
+  return OkStatus();
 }
 
 StatusWithSize KeyValueStore::UpdateEntriesToPrimaryFormat() {
@@ -1078,7 +1078,7 @@
 
     metadata.AddNewAddress(new_address);
   }
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status KeyValueStore::RepairCorruptSectors() {
@@ -1086,7 +1086,7 @@
   // sector failed on the first pass, then do a second pass, since a later
   // sector might have cleared up space or otherwise unblocked the earlier
   // failed sector.
-  Status repair_status = Status::Ok();
+  Status repair_status = OkStatus();
 
   size_t loop_count = 0;
   do {
@@ -1094,7 +1094,7 @@
     // Error of RESOURCE_EXHAUSTED indicates no space found for relocation.
     // Reset back to OK for the next pass.
     if (repair_status == Status::ResourceExhausted()) {
-      repair_status = Status::Ok();
+      repair_status = OkStatus();
     }
 
     DBG("   Pass %u", unsigned(loop_count));
@@ -1117,7 +1117,7 @@
 }
 
 Status KeyValueStore::EnsureFreeSectorExists() {
-  Status repair_status = Status::Ok();
+  Status repair_status = OkStatus();
   bool empty_sector_found = false;
 
   DBG("   Find empty sector");
@@ -1141,11 +1141,11 @@
 }
 
 Status KeyValueStore::EnsureEntryRedundancy() {
-  Status repair_status = Status::Ok();
+  Status repair_status = OkStatus();
 
   if (redundancy() == 1) {
     DBG("   Redundancy not in use, nothting to check");
-    return Status::Ok();
+    return OkStatus();
   }
 
   DBG("   Write any needed additional duplicate copies of keys to fulfill %u"
diff --git a/pw_kvs/key_value_store_binary_format_test.cc b/pw_kvs/key_value_store_binary_format_test.cc
index 76c0667..1fb046a 100644
--- a/pw_kvs/key_value_store_binary_format_test.cc
+++ b/pw_kvs/key_value_store_binary_format_test.cc
@@ -189,10 +189,10 @@
 TEST_F(KvsErrorHandling, Init_Ok) {
   InitFlashTo(bytes::Concat(kEntry1, kEntry2));
 
-  EXPECT_EQ(Status::Ok(), kvs_.Init());
+  EXPECT_EQ(OkStatus(), kvs_.Init());
   byte buffer[64];
-  EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
-  EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+  EXPECT_EQ(OkStatus(), kvs_.Get("key1", buffer).status());
+  EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
 }
 
 TEST_F(KvsErrorHandling, Init_DuplicateEntries_ReturnsDataLossButReadsEntry) {
@@ -200,7 +200,7 @@
 
   EXPECT_EQ(Status::DataLoss(), kvs_.Init());
   byte buffer[64];
-  EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
+  EXPECT_EQ(OkStatus(), kvs_.Get("key1", buffer).status());
   EXPECT_EQ(Status::NotFound(), kvs_.Get("k2", buffer).status());
 }
 
@@ -213,7 +213,7 @@
     ASSERT_EQ(Status::DataLoss(), kvs_.Init());
     byte buffer[64];
     ASSERT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
-    ASSERT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+    ASSERT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
 
     auto stats = kvs_.GetStorageStats();
     // One valid entry.
@@ -236,9 +236,9 @@
 
   byte buffer[64];
   EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
-  EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+  EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
   EXPECT_EQ(Status::NotFound(), kvs_.Get("k3y", buffer).status());
-  EXPECT_EQ(Status::Ok(), kvs_.Get("4k", buffer).status());
+  EXPECT_EQ(OkStatus(), kvs_.Get("4k", buffer).status());
 
   auto stats = kvs_.GetStorageStats();
   ASSERT_EQ(64u, stats.in_use_bytes);
@@ -276,7 +276,7 @@
   EXPECT_EQ(1u, kvs_.size());
   byte buffer[64];
   EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
-  EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+  EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
 
   auto stats = kvs_.GetStorageStats();
   EXPECT_EQ(32u, stats.in_use_bytes);
@@ -314,8 +314,8 @@
   byte buffer[64];
   EXPECT_EQ(2u, kvs_.size());
   EXPECT_EQ(true, kvs_.error_detected());
-  EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
-  EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+  EXPECT_EQ(OkStatus(), kvs_.Get("key1", buffer).status());
+  EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
 
   auto stats = kvs_.GetStorageStats();
   EXPECT_EQ(64u, stats.in_use_bytes);
@@ -341,7 +341,7 @@
   EXPECT_EQ(1u, kvs_.size());
 
   auto result = kvs_.Get("my_key", std::as_writable_bytes(std::span(buffer)));
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(OkStatus(), result.status());
   EXPECT_EQ(sizeof("version 7") - 1, result.size());
   EXPECT_STREQ("version 7", buffer);
 
@@ -352,7 +352,7 @@
 // the KvsErrorRecovery and KvsErrorHandling test fixtures (different KVS
 // configurations).
 TEST_F(KvsErrorHandling, Put_WriteFailure_EntryNotAddedButBytesMarkedWritten) {
-  ASSERT_EQ(Status::Ok(), kvs_.Init());
+  ASSERT_EQ(OkStatus(), kvs_.Init());
   flash_.InjectWriteError(FlashError::Unconditional(Status::Unavailable(), 1));
 
   EXPECT_EQ(Status::Unavailable(), kvs_.Put("key1", bytes::String("value1")));
@@ -367,7 +367,7 @@
 
   // The bytes were marked used, so a new key should not overlap with the bytes
   // from the failed Put.
-  EXPECT_EQ(Status::Ok(), kvs_.Put("key1", bytes::String("value1")));
+  EXPECT_EQ(OkStatus(), kvs_.Put("key1", bytes::String("value1")));
 
   stats = kvs_.GetStorageStats();
   EXPECT_EQ(stats.in_use_bytes, (32u * kvs_.redundancy()));
@@ -397,21 +397,21 @@
 TEST_F(KvsErrorRecovery, Init_Ok) {
   InitFlashTo(bytes::Concat(kEntry1, kEntry2));
 
-  EXPECT_EQ(Status::Ok(), kvs_.Init());
+  EXPECT_EQ(OkStatus(), kvs_.Init());
   byte buffer[64];
-  EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
-  EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+  EXPECT_EQ(OkStatus(), kvs_.Get("key1", buffer).status());
+  EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
 }
 
 TEST_F(KvsErrorRecovery, Init_DuplicateEntries_RecoversDuringInit) {
   InitFlashTo(bytes::Concat(kEntry1, kEntry1));
 
-  EXPECT_EQ(Status::Ok(), kvs_.Init());
+  EXPECT_EQ(OkStatus(), kvs_.Init());
   auto stats = kvs_.GetStorageStats();
   EXPECT_EQ(stats.corrupt_sectors_recovered, 1u);
 
   byte buffer[64];
-  EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
+  EXPECT_EQ(OkStatus(), kvs_.Get("key1", buffer).status());
   EXPECT_EQ(Status::NotFound(), kvs_.Get("k2", buffer).status());
 }
 
@@ -421,10 +421,10 @@
     InitFlashTo(bytes::Concat(kEntry1, kEntry2));
     flash_.buffer()[i] = byte(int(flash_.buffer()[i]) + 1);
 
-    ASSERT_EQ(Status::Ok(), kvs_.Init());
+    ASSERT_EQ(OkStatus(), kvs_.Init());
     byte buffer[64];
     ASSERT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
-    ASSERT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+    ASSERT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
 
     auto stats = kvs_.GetStorageStats();
     // One valid entry.
@@ -442,15 +442,15 @@
   flash_.buffer()[9] = byte(0xef);
   flash_.buffer()[67] = byte(0xef);
 
-  ASSERT_EQ(Status::Ok(), kvs_.Init());
+  ASSERT_EQ(OkStatus(), kvs_.Init());
 
   EXPECT_EQ(2u, kvs_.size());
 
   byte buffer[64];
   EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
-  EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+  EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
   EXPECT_EQ(Status::NotFound(), kvs_.Get("k3y", buffer).status());
-  EXPECT_EQ(Status::Ok(), kvs_.Get("4k", buffer).status());
+  EXPECT_EQ(OkStatus(), kvs_.Get("4k", buffer).status());
 
   auto stats = kvs_.GetStorageStats();
   ASSERT_EQ(64u, stats.in_use_bytes);
@@ -465,7 +465,7 @@
   flash_.InjectReadError(
       FlashError::InRange(Status::Unauthenticated(), kEntry1.size()));
 
-  EXPECT_EQ(Status::Ok(), kvs_.Init());
+  EXPECT_EQ(OkStatus(), kvs_.Init());
   EXPECT_TRUE(kvs_.initialized());
   auto stats = kvs_.GetStorageStats();
   ASSERT_EQ(32u, stats.in_use_bytes);
@@ -484,15 +484,15 @@
   flash_.buffer()[513] = byte(0xef);
   flash_.buffer()[1025] = byte(0xef);
 
-  ASSERT_EQ(Status::Ok(), kvs_.Init());
-  EXPECT_EQ(Status::Ok(), kvs_.Put("hello", bytes::String("world")));
-  EXPECT_EQ(Status::Ok(), kvs_.Put("a", bytes::String("b")));
+  ASSERT_EQ(OkStatus(), kvs_.Init());
+  EXPECT_EQ(OkStatus(), kvs_.Put("hello", bytes::String("world")));
+  EXPECT_EQ(OkStatus(), kvs_.Put("a", bytes::String("b")));
 
   // Existing valid entries should still be readable.
   EXPECT_EQ(3u, kvs_.size());
   byte buffer[64];
   EXPECT_EQ(Status::NotFound(), kvs_.Get("key1", buffer).status());
-  EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+  EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
 
   auto stats = kvs_.GetStorageStats();
   EXPECT_EQ(96u, stats.in_use_bytes);
@@ -512,7 +512,7 @@
   flash_.buffer()[1025] = byte(0xef);
   flash_.buffer()[1537] = byte(0xef);
 
-  ASSERT_EQ(Status::Ok(), kvs_.Init());
+  ASSERT_EQ(OkStatus(), kvs_.Init());
 
   auto stats = kvs_.GetStorageStats();
   EXPECT_EQ(64u, stats.in_use_bytes);
@@ -528,12 +528,12 @@
 TEST_F(KvsErrorRecovery, DISABLED_Init_OkWithWriteErrorOnFlash) {
   InitFlashTo(bytes::Concat(kEntry1, kEmpty32Bytes, kEntry2));
 
-  EXPECT_EQ(Status::Ok(), kvs_.Init());
+  EXPECT_EQ(OkStatus(), kvs_.Init());
   byte buffer[64];
   EXPECT_EQ(2u, kvs_.size());
   EXPECT_EQ(false, kvs_.error_detected());
-  EXPECT_EQ(Status::Ok(), kvs_.Get("key1", buffer).status());
-  EXPECT_EQ(Status::Ok(), kvs_.Get("k2", buffer).status());
+  EXPECT_EQ(OkStatus(), kvs_.Get("key1", buffer).status());
+  EXPECT_EQ(OkStatus(), kvs_.Get("k2", buffer).status());
 
   auto stats = kvs_.GetStorageStats();
   EXPECT_EQ(64u, stats.in_use_bytes);
@@ -554,14 +554,14 @@
   // Corrupt a byte of entry version 8 (addresses 32-63).
   flash_.buffer()[34] = byte(0xef);
 
-  ASSERT_EQ(Status::Ok(), kvs_.Init());
+  ASSERT_EQ(OkStatus(), kvs_.Init());
 
   char buffer[64] = {};
 
   EXPECT_EQ(1u, kvs_.size());
 
   auto result = kvs_.Get("my_key", std::as_writable_bytes(std::span(buffer)));
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(OkStatus(), result.status());
   EXPECT_EQ(sizeof("version 7") - 1, result.size());
   EXPECT_STREQ("version 7", buffer);
 
@@ -572,7 +572,7 @@
 // the KvsErrorRecovery and KvsErrorHandling test fixtures (different KVS
 // configurations).
 TEST_F(KvsErrorRecovery, Put_WriteFailure_EntryNotAddedButBytesMarkedWritten) {
-  ASSERT_EQ(Status::Ok(), kvs_.Init());
+  ASSERT_EQ(OkStatus(), kvs_.Init());
   flash_.InjectWriteError(FlashError::Unconditional(Status::Unavailable(), 1));
 
   EXPECT_EQ(Status::Unavailable(), kvs_.Put("key1", bytes::String("value1")));
@@ -590,7 +590,7 @@
 
   // The bytes were marked used, so a new key should not overlap with the bytes
   // from the failed Put.
-  EXPECT_EQ(Status::Ok(), kvs_.Put("key1", bytes::String("value1")));
+  EXPECT_EQ(OkStatus(), kvs_.Put("key1", bytes::String("value1")));
 
   stats = kvs_.GetStorageStats();
   EXPECT_EQ(stats.in_use_bytes, (32u * kvs_.redundancy()));
@@ -647,7 +647,7 @@
                 kInitialContents.data(),
                 kInitialContents.size());
 
-    EXPECT_EQ(Status::Ok(), kvs_.Init());
+    EXPECT_EQ(OkStatus(), kvs_.Init());
   }
 
   FakeFlashMemoryBuffer<512, 4, 3> flash_;
@@ -660,7 +660,7 @@
     char val[sizeof(str_value)] = {};                          \
     StatusWithSize stat =                                      \
         kvs_.Get(key, std::as_writable_bytes(std::span(val))); \
-    ASSERT_EQ(Status::Ok(), stat.status());                    \
+    ASSERT_EQ(OkStatus(), stat.status());                      \
     ASSERT_EQ(sizeof(str_value) - 1, stat.size());             \
     ASSERT_STREQ(str_value, val);                              \
   } while (0)
@@ -681,7 +681,7 @@
   EXPECT_EQ(stats.corrupt_sectors_recovered, 0u);
   EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
 
-  EXPECT_EQ(Status::Ok(), partition_.Erase(0, 1));
+  EXPECT_EQ(OkStatus(), partition_.Erase(0, 1));
 
   ASSERT_CONTAINS_ENTRY("key1", "value1");
   ASSERT_CONTAINS_ENTRY("k2", "value2");
@@ -698,7 +698,7 @@
   EXPECT_EQ(stats.corrupt_sectors_recovered, 0u);
   EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
 
-  EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
+  EXPECT_EQ(OkStatus(), kvs_.FullMaintenance());
   stats = kvs_.GetStorageStats();
   EXPECT_EQ(stats.in_use_bytes, (192u * kvs_.redundancy()));
   EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -715,7 +715,7 @@
   EXPECT_EQ(stats.corrupt_sectors_recovered, 0u);
   EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
 
-  EXPECT_EQ(Status::Ok(), partition_.Erase(partition_.sector_size_bytes(), 1));
+  EXPECT_EQ(OkStatus(), partition_.Erase(partition_.sector_size_bytes(), 1));
 
   ASSERT_CONTAINS_ENTRY("key1", "value1");
   ASSERT_CONTAINS_ENTRY("k2", "value2");
@@ -725,7 +725,7 @@
 
   EXPECT_EQ(false, kvs_.error_detected());
 
-  EXPECT_EQ(Status::Ok(), kvs_.Init());
+  EXPECT_EQ(OkStatus(), kvs_.Init());
   stats = kvs_.GetStorageStats();
   EXPECT_EQ(stats.in_use_bytes, (192u * kvs_.redundancy()));
   EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -773,10 +773,10 @@
 
   char val[20] = {};
   EXPECT_EQ(
-      Status::Ok(),
+      OkStatus(),
       kvs_.Get("new key", std::as_writable_bytes(std::span(val))).status());
 
-  EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
+  EXPECT_EQ(OkStatus(), kvs_.FullMaintenance());
   stats = kvs_.GetStorageStats();
   EXPECT_EQ(stats.in_use_bytes, (224u * kvs_.redundancy()));
   EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -785,12 +785,12 @@
   EXPECT_EQ(stats.missing_redundant_entries_recovered, 0u);
 
   EXPECT_EQ(
-      Status::Ok(),
+      OkStatus(),
       kvs_.Get("new key", std::as_writable_bytes(std::span(val))).status());
 }
 
 TEST_F(InitializedRedundantMultiMagicKvs, DataLossAfterLosingBothCopies) {
-  EXPECT_EQ(Status::Ok(), partition_.Erase(0, 2));
+  EXPECT_EQ(OkStatus(), partition_.Erase(0, 2));
 
   char val[20] = {};
   EXPECT_EQ(Status::DataLoss(),
@@ -815,7 +815,7 @@
 }
 
 TEST_F(InitializedRedundantMultiMagicKvs, PutNewEntry_UsesFirstFormat) {
-  EXPECT_EQ(Status::Ok(), kvs_.Put("new key", bytes::String("abcd?")));
+  EXPECT_EQ(OkStatus(), kvs_.Put("new key", bytes::String("abcd?")));
 
   constexpr auto kNewEntry =
       MakeValidEntry(kMagic, 129, "new key", bytes::String("abcd?"));
@@ -827,7 +827,7 @@
 }
 
 TEST_F(InitializedRedundantMultiMagicKvs, PutExistingEntry_UsesFirstFormat) {
-  EXPECT_EQ(Status::Ok(), kvs_.Put("A Key", bytes::String("New value!")));
+  EXPECT_EQ(OkStatus(), kvs_.Put("A Key", bytes::String("New value!")));
 
   constexpr auto kNewEntry =
       MakeValidEntry(kMagic, 129, "A Key", bytes::String("New value!"));
@@ -843,20 +843,20 @@
     char val[sizeof(str_value)] = {};                         \
     StatusWithSize stat =                                     \
         kvs.Get(key, std::as_writable_bytes(std::span(val))); \
-    ASSERT_EQ(Status::Ok(), stat.status());                   \
+    ASSERT_EQ(OkStatus(), stat.status());                     \
     ASSERT_EQ(sizeof(str_value) - 1, stat.size());            \
     ASSERT_STREQ(str_value, val);                             \
   } while (0)
 
 TEST_F(InitializedRedundantMultiMagicKvs, UpdateEntryFormat) {
-  ASSERT_EQ(Status::Ok(), kvs_.FullMaintenance());
+  ASSERT_EQ(OkStatus(), kvs_.FullMaintenance());
 
   KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors, 2, 1> local_kvs(
       &partition_,
       {.magic = kMagic, .checksum = &default_checksum},
       kNoGcOptions);
 
-  ASSERT_EQ(Status::Ok(), local_kvs.Init());
+  ASSERT_EQ(OkStatus(), local_kvs.Init());
   EXPECT_EQ(false, local_kvs.error_detected());
   ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "key1", "value1");
   ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "k2", "value2");
@@ -885,7 +885,7 @@
                 kInitialContents.data(),
                 kInitialContents.size());
 
-    EXPECT_EQ(Status::Ok(), kvs_.Init());
+    EXPECT_EQ(OkStatus(), kvs_.Init());
   }
 
   FakeFlashMemoryBuffer<512, 4, 3> flash_;
@@ -906,14 +906,14 @@
 // Similar to test for InitializedRedundantMultiMagicKvs. Doing similar test
 // with different KVS configuration.
 TEST_F(InitializedMultiMagicKvs, UpdateEntryFormat) {
-  ASSERT_EQ(Status::Ok(), kvs_.FullMaintenance());
+  ASSERT_EQ(OkStatus(), kvs_.FullMaintenance());
 
   KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors, 1, 1> local_kvs(
       &partition_,
       {.magic = kMagic, .checksum = &default_checksum},
       kNoGcOptions);
 
-  ASSERT_EQ(Status::Ok(), local_kvs.Init());
+  ASSERT_EQ(OkStatus(), local_kvs.Init());
   EXPECT_EQ(false, local_kvs.error_detected());
   ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "key1", "value1");
   ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "k2", "value2");
@@ -938,7 +938,7 @@
                 kInitialContents.data(),
                 kInitialContents.size());
 
-    EXPECT_EQ(Status::Ok(), kvs_.Init());
+    EXPECT_EQ(OkStatus(), kvs_.Init());
   }
 
   FakeFlashMemoryBuffer<512, 4, 3> flash_;
@@ -947,7 +947,7 @@
 };
 
 TEST_F(InitializedRedundantLazyRecoveryKvs, WriteAfterDataLoss) {
-  EXPECT_EQ(Status::Ok(), partition_.Erase(0, 4));
+  EXPECT_EQ(OkStatus(), partition_.Erase(0, 4));
 
   char val[20] = {};
   EXPECT_EQ(Status::DataLoss(),
@@ -970,7 +970,7 @@
 
   ASSERT_EQ(Status::DataLoss(), kvs_.Put("key1", 1000));
 
-  EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
+  EXPECT_EQ(OkStatus(), kvs_.FullMaintenance());
   stats = kvs_.GetStorageStats();
   EXPECT_EQ(stats.in_use_bytes, 0u);
   EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -1005,7 +1005,7 @@
   ASSERT_CONTAINS_ENTRY("k3y", "value3");
   ASSERT_CONTAINS_ENTRY("4k", "value4");
 
-  EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
+  EXPECT_EQ(OkStatus(), kvs_.FullMaintenance());
   stats = kvs_.GetStorageStats();
   EXPECT_EQ(stats.in_use_bytes, (128u * kvs_.redundancy()));
   EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -1030,7 +1030,7 @@
                 kInitialContents.data(),
                 kInitialContents.size());
 
-    EXPECT_EQ(Status::Ok(), kvs_.Init());
+    EXPECT_EQ(OkStatus(), kvs_.Init());
   }
 
   FakeFlashMemoryBuffer<512, 8> flash_;
@@ -1066,17 +1066,17 @@
   // Add a near-sector size key entry to fill the KVS with a valid large entry
   // and stale data. Modify the value in between Puts so it actually writes
   // (identical value writes are skipped).
-  EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
+  EXPECT_EQ(OkStatus(), kvs_.Put("big_key", test_data));
   test_data[0]++;
-  EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
+  EXPECT_EQ(OkStatus(), kvs_.Put("big_key", test_data));
   test_data[0]++;
-  EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
+  EXPECT_EQ(OkStatus(), kvs_.Put("big_key", test_data));
   test_data[0]++;
-  EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
+  EXPECT_EQ(OkStatus(), kvs_.Put("big_key", test_data));
   test_data[0]++;
-  EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
+  EXPECT_EQ(OkStatus(), kvs_.Put("big_key", test_data));
   test_data[0]++;
-  EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
+  EXPECT_EQ(OkStatus(), kvs_.Put("big_key", test_data));
 
   // Instantiate a new KVS with redundancy of 2. This KVS should add an extra
   // copy of each valid key as part of the init process. Because there is not
@@ -1086,7 +1086,7 @@
       &partition_,
       {.magic = kMagic, .checksum = &default_checksum},
       kRecoveryLazyGcOptions);
-  ASSERT_EQ(Status::Ok(), local_kvs.Init());
+  ASSERT_EQ(OkStatus(), local_kvs.Init());
 
   // Verify no errors found in the new KVS and all the entries are present.
   EXPECT_EQ(false, local_kvs.error_detected());
@@ -1095,7 +1095,7 @@
   ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "k3y", "value3");
   ASSERT_KVS_CONTAINS_ENTRY(local_kvs, "4k", "value4");
   StatusWithSize big_key_size = local_kvs.ValueSize("big_key");
-  EXPECT_EQ(Status::Ok(), big_key_size.status());
+  EXPECT_EQ(OkStatus(), big_key_size.status());
   EXPECT_EQ(sizeof(test_data), big_key_size.size());
 
   // Verify that storage stats of the new redundant KVS match expected values.
diff --git a/pw_kvs/key_value_store_fuzz_test.cc b/pw_kvs/key_value_store_fuzz_test.cc
index 4fd86bc..6a257d6 100644
--- a/pw_kvs/key_value_store_fuzz_test.cc
+++ b/pw_kvs/key_value_store_fuzz_test.cc
@@ -46,7 +46,7 @@
   EmptyInitializedKvs()
       : kvs_(&test_partition, {.magic = 0x873a9b50, .checksum = &checksum}) {
     test_partition.Erase(0, test_partition.sector_count());
-    ASSERT_EQ(Status::Ok(), kvs_.Init());
+    ASSERT_EQ(OkStatus(), kvs_.Init());
   }
 
   KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs_;
@@ -63,7 +63,7 @@
   for (int i = 0; i < kFuzzIterations; ++i) {
     for (unsigned key_size = 1; key_size < sizeof(value); ++key_size) {
       for (unsigned value_size = 0; value_size < sizeof(value); ++value_size) {
-        ASSERT_EQ(Status::Ok(),
+        ASSERT_EQ(OkStatus(),
                   kvs_.Put(std::string_view(value, key_size),
                            std::as_bytes(std::span(value, value_size))));
       }
diff --git a/pw_kvs/key_value_store_initialized_test.cc b/pw_kvs/key_value_store_initialized_test.cc
index 7ea3fd9..9994fb6 100644
--- a/pw_kvs/key_value_store_initialized_test.cc
+++ b/pw_kvs/key_value_store_initialized_test.cc
@@ -83,7 +83,7 @@
  protected:
   EmptyInitializedKvs() : kvs_(&test_partition, default_format) {
     test_partition.Erase();
-    ASSERT_EQ(Status::Ok(), kvs_.Init());
+    ASSERT_EQ(OkStatus(), kvs_.Init());
   }
 
   // Intention of this is to put and erase key-val to fill up sectors. It's a
@@ -107,7 +107,7 @@
     while (size_to_fill > 0) {
       // Changing buffer value so put actually does something
       buffer[0] = static_cast<byte>(static_cast<uint8_t>(buffer[0]) + 1);
-      ASSERT_EQ(Status::Ok(),
+      ASSERT_EQ(OkStatus(),
                 kvs_.Put(key,
                          std::span(buffer.data(),
                                    chunk_len - kvs_attr.ChunkHeaderSize() -
@@ -115,7 +115,7 @@
       size_to_fill -= chunk_len;
       chunk_len = std::min(size_to_fill, kMaxPutSize);
     }
-    ASSERT_EQ(Status::Ok(), kvs_.Delete(key));
+    ASSERT_EQ(OkStatus(), kvs_.Delete(key));
   }
 
   KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs_;
@@ -127,7 +127,7 @@
   std::array<char, 8> value{'v', 'a', 'l', 'u', 'e', '6', '7', '\0'};
 
   for (int i = 0; i < 1000; ++i) {
-    ASSERT_EQ(Status::Ok(),
+    ASSERT_EQ(OkStatus(),
               kvs_.Put("The Key!", std::as_bytes(std::span(value))));
   }
 }
@@ -136,7 +136,7 @@
   std::array<char, 7> value{'v', 'a', 'l', 'u', 'e', '6', '\0'};
 
   for (int i = 0; i < 1000; ++i) {
-    ASSERT_EQ(Status::Ok(),
+    ASSERT_EQ(OkStatus(),
               kvs_.Put("The Key!", std::as_bytes(std::span(value))));
   }
 }
@@ -146,27 +146,27 @@
 
   for (int i = 0; i < 100; ++i) {
     for (unsigned size = 0; size < value.size(); ++size) {
-      ASSERT_EQ(Status::Ok(), kvs_.Put("The Key!", i));
+      ASSERT_EQ(OkStatus(), kvs_.Put("The Key!", i));
     }
   }
 }
 
 TEST_F(EmptyInitializedKvs, PutAndGetByValue_ConvertibleToSpan) {
   constexpr float input[] = {1.0, -3.5};
-  ASSERT_EQ(Status::Ok(), kvs_.Put("key", input));
+  ASSERT_EQ(OkStatus(), kvs_.Put("key", input));
 
   float output[2] = {};
-  ASSERT_EQ(Status::Ok(), kvs_.Get("key", &output));
+  ASSERT_EQ(OkStatus(), kvs_.Get("key", &output));
   EXPECT_EQ(input[0], output[0]);
   EXPECT_EQ(input[1], output[1]);
 }
 
 TEST_F(EmptyInitializedKvs, PutAndGetByValue_Span) {
   float input[] = {1.0, -3.5};
-  ASSERT_EQ(Status::Ok(), kvs_.Put("key", std::span(input)));
+  ASSERT_EQ(OkStatus(), kvs_.Put("key", std::span(input)));
 
   float output[2] = {};
-  ASSERT_EQ(Status::Ok(), kvs_.Get("key", &output));
+  ASSERT_EQ(OkStatus(), kvs_.Get("key", &output));
   EXPECT_EQ(input[0], output[0]);
   EXPECT_EQ(input[1], output[1]);
 }
@@ -178,39 +178,39 @@
   };
   const TestStruct input{-1234.5, true};
 
-  ASSERT_EQ(Status::Ok(), kvs_.Put("key", input));
+  ASSERT_EQ(OkStatus(), kvs_.Put("key", input));
 
   TestStruct output;
-  ASSERT_EQ(Status::Ok(), kvs_.Get("key", &output));
+  ASSERT_EQ(OkStatus(), kvs_.Get("key", &output));
   EXPECT_EQ(input.a, output.a);
   EXPECT_EQ(input.b, output.b);
 }
 
 TEST_F(EmptyInitializedKvs, Get_Simple) {
-  ASSERT_EQ(Status::Ok(),
+  ASSERT_EQ(OkStatus(),
             kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
 
   char value[16];
   auto result = kvs_.Get("Charles", std::as_writable_bytes(std::span(value)));
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(OkStatus(), result.status());
   EXPECT_EQ(sizeof("Mingus"), result.size());
   EXPECT_STREQ("Mingus", value);
 }
 
 TEST_F(EmptyInitializedKvs, Get_WithOffset) {
-  ASSERT_EQ(Status::Ok(),
+  ASSERT_EQ(OkStatus(),
             kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
 
   char value[16];
   auto result =
       kvs_.Get("Charles", std::as_writable_bytes(std::span(value)), 4);
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(OkStatus(), result.status());
   EXPECT_EQ(sizeof("Mingus") - 4, result.size());
   EXPECT_STREQ("us", value);
 }
 
 TEST_F(EmptyInitializedKvs, Get_WithOffset_FillBuffer) {
-  ASSERT_EQ(Status::Ok(),
+  ASSERT_EQ(OkStatus(),
             kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
 
   char value[4] = {};
@@ -222,7 +222,7 @@
 }
 
 TEST_F(EmptyInitializedKvs, Get_WithOffset_PastEnd) {
-  ASSERT_EQ(Status::Ok(),
+  ASSERT_EQ(OkStatus(),
             kvs_.Put("Charles", std::as_bytes(std::span("Mingus"))));
 
   char value[16];
@@ -234,15 +234,15 @@
 }
 
 TEST_F(EmptyInitializedKvs, GetValue) {
-  ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
+  ASSERT_EQ(OkStatus(), kvs_.Put("key", uint32_t(0xfeedbeef)));
 
   uint32_t value = 0;
-  EXPECT_EQ(Status::Ok(), kvs_.Get("key", &value));
+  EXPECT_EQ(OkStatus(), kvs_.Get("key", &value));
   EXPECT_EQ(uint32_t(0xfeedbeef), value);
 }
 
 TEST_F(EmptyInitializedKvs, GetValue_TooSmall) {
-  ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
+  ASSERT_EQ(OkStatus(), kvs_.Put("key", uint32_t(0xfeedbeef)));
 
   uint8_t value = 0;
   EXPECT_EQ(Status::InvalidArgument(), kvs_.Get("key", &value));
@@ -250,7 +250,7 @@
 }
 
 TEST_F(EmptyInitializedKvs, GetValue_TooLarge) {
-  ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
+  ASSERT_EQ(OkStatus(), kvs_.Put("key", uint32_t(0xfeedbeef)));
 
   uint64_t value = 0;
   EXPECT_EQ(Status::InvalidArgument(), kvs_.Get("key", &value));
@@ -258,37 +258,36 @@
 }
 
 TEST_F(EmptyInitializedKvs, Delete_GetDeletedKey_ReturnsNotFound) {
-  ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
-  ASSERT_EQ(Status::Ok(), kvs_.Delete("kEy"));
+  ASSERT_EQ(OkStatus(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+  ASSERT_EQ(OkStatus(), kvs_.Delete("kEy"));
 
   EXPECT_EQ(Status::NotFound(), kvs_.Get("kEy", {}).status());
   EXPECT_EQ(Status::NotFound(), kvs_.ValueSize("kEy").status());
 }
 
 TEST_F(EmptyInitializedKvs, Delete_AddBackKey_PersistsAfterInitialization) {
-  ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
-  ASSERT_EQ(Status::Ok(), kvs_.Delete("kEy"));
+  ASSERT_EQ(OkStatus(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+  ASSERT_EQ(OkStatus(), kvs_.Delete("kEy"));
 
-  EXPECT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("45678"))));
+  EXPECT_EQ(OkStatus(), kvs_.Put("kEy", std::as_bytes(std::span("45678"))));
   char data[6] = {};
-  ASSERT_EQ(Status::Ok(), kvs_.Get("kEy", &data));
+  ASSERT_EQ(OkStatus(), kvs_.Get("kEy", &data));
   EXPECT_STREQ(data, "45678");
 
   // Ensure that the re-added key is still present after reinitialization.
   KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> new_kvs(&test_partition,
                                                               default_format);
-  ASSERT_EQ(Status::Ok(), new_kvs.Init());
+  ASSERT_EQ(OkStatus(), new_kvs.Init());
 
-  EXPECT_EQ(Status::Ok(),
-            new_kvs.Put("kEy", std::as_bytes(std::span("45678"))));
+  EXPECT_EQ(OkStatus(), new_kvs.Put("kEy", std::as_bytes(std::span("45678"))));
   char new_data[6] = {};
-  EXPECT_EQ(Status::Ok(), new_kvs.Get("kEy", &new_data));
+  EXPECT_EQ(OkStatus(), new_kvs.Get("kEy", &new_data));
   EXPECT_STREQ(data, "45678");
 }
 
 TEST_F(EmptyInitializedKvs, Delete_AllItems_KvsIsEmpty) {
-  ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
-  ASSERT_EQ(Status::Ok(), kvs_.Delete("kEy"));
+  ASSERT_EQ(OkStatus(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+  ASSERT_EQ(OkStatus(), kvs_.Delete("kEy"));
 
   EXPECT_EQ(0u, kvs_.size());
   EXPECT_TRUE(kvs_.empty());
@@ -299,12 +298,12 @@
   constexpr std::string_view key1 = "D4";
   constexpr std::string_view key2 = "dFU6S";
 
-  ASSERT_EQ(Status::Ok(), kvs_.Put(key1, 1000));
+  ASSERT_EQ(OkStatus(), kvs_.Put(key1, 1000));
 
   EXPECT_EQ(Status::AlreadyExists(), kvs_.Put(key2, 999));
 
   int value = 0;
-  EXPECT_EQ(Status::Ok(), kvs_.Get(key1, &value));
+  EXPECT_EQ(OkStatus(), kvs_.Get(key1, &value));
   EXPECT_EQ(1000, value);
 
   EXPECT_EQ(Status::NotFound(), kvs_.Get(key2, &value));
@@ -317,8 +316,8 @@
   constexpr std::string_view key1 = "1U2";
   constexpr std::string_view key2 = "ahj9d";
 
-  ASSERT_EQ(Status::Ok(), kvs_.Put(key1, 1000));
-  ASSERT_EQ(Status::Ok(), kvs_.Delete(key1));
+  ASSERT_EQ(OkStatus(), kvs_.Put(key1, 1000));
+  ASSERT_EQ(OkStatus(), kvs_.Delete(key1));
 
   // key2 collides with key1's tombstone.
   EXPECT_EQ(Status::AlreadyExists(), kvs_.Put(key2, 999));
@@ -346,42 +345,41 @@
 }
 
 TEST_F(EmptyInitializedKvs, Iteration_OneItem) {
-  ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+  ASSERT_EQ(OkStatus(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
 
   for (KeyValueStore::Item entry : kvs_) {
     EXPECT_STREQ(entry.key(), "kEy");  // Make sure null-terminated.
 
     char temp[sizeof("123")] = {};
-    EXPECT_EQ(Status::Ok(), entry.Get(&temp));
+    EXPECT_EQ(OkStatus(), entry.Get(&temp));
     EXPECT_STREQ("123", temp);
   }
 }
 
 TEST_F(EmptyInitializedKvs, Iteration_GetWithOffset) {
-  ASSERT_EQ(Status::Ok(),
-            kvs_.Put("key", std::as_bytes(std::span("not bad!"))));
+  ASSERT_EQ(OkStatus(), kvs_.Put("key", std::as_bytes(std::span("not bad!"))));
 
   for (KeyValueStore::Item entry : kvs_) {
     char temp[5];
     auto result = entry.Get(std::as_writable_bytes(std::span(temp)), 4);
-    EXPECT_EQ(Status::Ok(), result.status());
+    EXPECT_EQ(OkStatus(), result.status());
     EXPECT_EQ(5u, result.size());
     EXPECT_STREQ("bad!", temp);
   }
 }
 
 TEST_F(EmptyInitializedKvs, Iteration_GetValue) {
-  ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
+  ASSERT_EQ(OkStatus(), kvs_.Put("key", uint32_t(0xfeedbeef)));
 
   for (KeyValueStore::Item entry : kvs_) {
     uint32_t value = 0;
-    EXPECT_EQ(Status::Ok(), entry.Get(&value));
+    EXPECT_EQ(OkStatus(), entry.Get(&value));
     EXPECT_EQ(uint32_t(0xfeedbeef), value);
   }
 }
 
 TEST_F(EmptyInitializedKvs, Iteration_GetValue_TooSmall) {
-  ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
+  ASSERT_EQ(OkStatus(), kvs_.Put("key", uint32_t(0xfeedbeef)));
 
   for (KeyValueStore::Item entry : kvs_) {
     uint8_t value = 0;
@@ -391,7 +389,7 @@
 }
 
 TEST_F(EmptyInitializedKvs, Iteration_GetValue_TooLarge) {
-  ASSERT_EQ(Status::Ok(), kvs_.Put("key", uint32_t(0xfeedbeef)));
+  ASSERT_EQ(OkStatus(), kvs_.Put("key", uint32_t(0xfeedbeef)));
 
   for (KeyValueStore::Item entry : kvs_) {
     uint64_t value = 0;
@@ -401,8 +399,8 @@
 }
 
 TEST_F(EmptyInitializedKvs, Iteration_EmptyAfterDeletion) {
-  ASSERT_EQ(Status::Ok(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
-  ASSERT_EQ(Status::Ok(), kvs_.Delete("kEy"));
+  ASSERT_EQ(OkStatus(), kvs_.Put("kEy", std::as_bytes(std::span("123"))));
+  ASSERT_EQ(OkStatus(), kvs_.Delete("kEy"));
 
   for (KeyValueStore::Item entry : kvs_) {
     static_cast<void>(entry);
@@ -425,10 +423,10 @@
   std::memset(buf2, 2, sizeof(buf2));
 
   // Start with things in KVS
-  ASSERT_EQ(Status::Ok(), kvs_.Put(key1, buf1));
-  ASSERT_EQ(Status::Ok(), kvs_.Put(key2, buf2));
+  ASSERT_EQ(OkStatus(), kvs_.Put(key1, buf1));
+  ASSERT_EQ(OkStatus(), kvs_.Put(key2, buf2));
   for (size_t j = 0; j < keys.size(); j++) {
-    ASSERT_EQ(Status::Ok(), kvs_.Put(keys[j], j));
+    ASSERT_EQ(OkStatus(), kvs_.Put(keys[j], j));
   }
 
   for (size_t i = 0; i < 100; i++) {
@@ -437,28 +435,28 @@
     size_t size2 = (kLargestBufSize) / (100 - i);
     for (size_t j = 0; j < 50; j++) {
       // Rewrite a single key many times, can fill up a sector
-      ASSERT_EQ(Status::Ok(), kvs_.Put("some_data", j));
+      ASSERT_EQ(OkStatus(), kvs_.Put("some_data", j));
     }
     // Delete and re-add everything
-    ASSERT_EQ(Status::Ok(), kvs_.Delete(key1));
-    ASSERT_EQ(Status::Ok(), kvs_.Put(key1, std::span(buf1, size1)));
-    ASSERT_EQ(Status::Ok(), kvs_.Delete(key2));
-    ASSERT_EQ(Status::Ok(), kvs_.Put(key2, std::span(buf2, size2)));
+    ASSERT_EQ(OkStatus(), kvs_.Delete(key1));
+    ASSERT_EQ(OkStatus(), kvs_.Put(key1, std::span(buf1, size1)));
+    ASSERT_EQ(OkStatus(), kvs_.Delete(key2));
+    ASSERT_EQ(OkStatus(), kvs_.Put(key2, std::span(buf2, size2)));
     for (size_t j = 0; j < keys.size(); j++) {
-      ASSERT_EQ(Status::Ok(), kvs_.Delete(keys[j]));
-      ASSERT_EQ(Status::Ok(), kvs_.Put(keys[j], j));
+      ASSERT_EQ(OkStatus(), kvs_.Delete(keys[j]));
+      ASSERT_EQ(OkStatus(), kvs_.Put(keys[j], j));
     }
 
     // Re-enable and verify
-    ASSERT_EQ(Status::Ok(), kvs_.Init());
+    ASSERT_EQ(OkStatus(), kvs_.Init());
     static byte buf[4 * 1024];
-    ASSERT_EQ(Status::Ok(), kvs_.Get(key1, std::span(buf, size1)).status());
+    ASSERT_EQ(OkStatus(), kvs_.Get(key1, std::span(buf, size1)).status());
     ASSERT_EQ(std::memcmp(buf, buf1, size1), 0);
-    ASSERT_EQ(Status::Ok(), kvs_.Get(key2, std::span(buf, size2)).status());
+    ASSERT_EQ(OkStatus(), kvs_.Get(key2, std::span(buf, size2)).status());
     ASSERT_EQ(std::memcmp(buf2, buf2, size2), 0);
     for (size_t j = 0; j < keys.size(); j++) {
       size_t ret = 1000;
-      ASSERT_EQ(Status::Ok(), kvs_.Get(keys[j], &ret));
+      ASSERT_EQ(OkStatus(), kvs_.Get(keys[j], &ret));
       ASSERT_EQ(ret, j);
     }
   }
@@ -468,28 +466,28 @@
   // Add some data
   uint8_t value1 = 0xDA;
   ASSERT_EQ(
-      Status::Ok(),
+      OkStatus(),
       kvs_.Put(keys[0], std::as_bytes(std::span(&value1, sizeof(value1)))));
 
   uint32_t value2 = 0xBAD0301f;
-  ASSERT_EQ(Status::Ok(), kvs_.Put(keys[1], value2));
+  ASSERT_EQ(OkStatus(), kvs_.Put(keys[1], value2));
 
   // Verify data
   uint32_t test2;
-  EXPECT_EQ(Status::Ok(), kvs_.Get(keys[1], &test2));
+  EXPECT_EQ(OkStatus(), kvs_.Get(keys[1], &test2));
   uint8_t test1;
-  ASSERT_EQ(Status::Ok(), kvs_.Get(keys[0], &test1));
+  ASSERT_EQ(OkStatus(), kvs_.Get(keys[0], &test1));
 
   EXPECT_EQ(test1, value1);
   EXPECT_EQ(test2, value2);
 
   // Delete a key
-  EXPECT_EQ(Status::Ok(), kvs_.Delete(keys[0]));
+  EXPECT_EQ(OkStatus(), kvs_.Delete(keys[0]));
 
   // Verify it was erased
   EXPECT_EQ(kvs_.Get(keys[0], &test1), Status::NotFound());
   test2 = 0;
-  ASSERT_EQ(Status::Ok(),
+  ASSERT_EQ(OkStatus(),
             kvs_.Get(keys[1],
                      std::span(reinterpret_cast<byte*>(&test2), sizeof(test2)))
                 .status());
diff --git a/pw_kvs/key_value_store_map_test.cc b/pw_kvs/key_value_store_map_test.cc
index 27b961c..0ae42f3 100644
--- a/pw_kvs/key_value_store_map_test.cc
+++ b/pw_kvs/key_value_store_map_test.cc
@@ -88,9 +88,9 @@
         // For KVS magic value always use a random 32 bit integer rather than a
         // human readable 4 bytes. See pw_kvs/format.h for more information.
         kvs_(&partition_, {.magic = 0xc857e51d, .checksum = nullptr}) {
-    EXPECT_EQ(Status::Ok(), partition_.Erase());
+    EXPECT_EQ(OkStatus(), partition_.Erase());
     Status result = kvs_.Init();
-    EXPECT_EQ(Status::Ok(), result);
+    EXPECT_EQ(OkStatus(), result);
 
     if (!result.ok()) {
       std::abort();
@@ -250,7 +250,7 @@
         EXPECT_EQ(map_entry->first, item.key());
 
         char value[kMaxValueLength + 1] = {};
-        EXPECT_EQ(Status::Ok(),
+        EXPECT_EQ(OkStatus(),
                   item.Get(std::as_writable_bytes(std::span(value))).status());
         EXPECT_EQ(map_entry->second, std::string(value));
       }
@@ -315,14 +315,14 @@
   void Init() {
     StartOperation("Init");
     Status status = kvs_.Init();
-    EXPECT_EQ(Status::Ok(), status);
+    EXPECT_EQ(OkStatus(), status);
     FinishOperation("Init", status);
   }
 
   void GCFull() {
     StartOperation("GCFull");
     Status status = kvs_.FullMaintenance();
-    EXPECT_EQ(Status::Ok(), status);
+    EXPECT_EQ(OkStatus(), status);
 
     KeyValueStore::StorageStats post_stats = kvs_.GetStorageStats();
     if (post_stats.in_use_bytes > ((partition_.size_bytes() * 70) / 100)) {
@@ -338,7 +338,7 @@
     Status status = kvs_.PartialMaintenance();
     KeyValueStore::StorageStats post_stats = kvs_.GetStorageStats();
     if (pre_stats.reclaimable_bytes != 0) {
-      EXPECT_EQ(Status::Ok(), status);
+      EXPECT_EQ(OkStatus(), status);
       EXPECT_LT(post_stats.reclaimable_bytes, pre_stats.reclaimable_bytes);
     } else {
       EXPECT_EQ(Status::NotFound(), status);
diff --git a/pw_kvs/key_value_store_test.cc b/pw_kvs/key_value_store_test.cc
index 73b1a12..967cf1e 100644
--- a/pw_kvs/key_value_store_test.cc
+++ b/pw_kvs/key_value_store_test.cc
@@ -69,7 +69,7 @@
     std::vector<std::byte> out_vec(memory.size_bytes());
     Status status =
         memory.Read(0, std::span<std::byte>(out_vec.data(), out_vec.size()));
-    if (status != Status::Ok()) {
+    if (status != OkStatus()) {
       fclose(out_file);
       return status;
     }
@@ -83,14 +83,14 @@
       status = Status::DataLoss();
     } else {
       PW_LOG_INFO("Dumped to %s", filename);
-      status = Status::Ok();
+      status = OkStatus();
     }
 
     fclose(out_file);
     return status;
   }
 #else
-  Status Dump(const char*) { return Status::Ok(); }
+  Status Dump(const char*) { return OkStatus(); }
 #endif  // DUMP_KVS_STATE_TO_FILE
 };
 
@@ -156,8 +156,8 @@
   EXPECT_EQ(kvs.Init(), Status::FailedPrecondition());
 }
 
-#define ASSERT_OK(expr) ASSERT_EQ(Status::Ok(), expr)
-#define EXPECT_OK(expr) EXPECT_EQ(Status::Ok(), expr)
+#define ASSERT_OK(expr) ASSERT_EQ(OkStatus(), expr)
+#define EXPECT_OK(expr) EXPECT_EQ(OkStatus(), expr)
 
 TEST(InMemoryKvs, WriteOneKeyMultipleTimes) {
   // Create and erase the fake flash. It will persist across reloads.
@@ -301,7 +301,7 @@
 
   // Create and erase the fake flash.
   Flash flash;
-  ASSERT_EQ(Status::Ok(), flash.partition.Erase());
+  ASSERT_EQ(OkStatus(), flash.partition.Erase());
 
   // Create and initialize the KVS.
   // For KVS magic value always use a random 32 bit integer rather than a
@@ -336,7 +336,7 @@
 TEST(InMemoryKvs, CallingEraseTwice_NothingWrittenToFlash) {
   // Create and erase the fake flash.
   Flash flash;
-  ASSERT_EQ(Status::Ok(), flash.partition.Erase());
+  ASSERT_EQ(OkStatus(), flash.partition.Erase());
 
   // Create and initialize the KVS.
   KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs(&flash.partition,
@@ -344,8 +344,8 @@
   ASSERT_OK(kvs.Init());
 
   const uint8_t kValue = 0xDA;
-  ASSERT_EQ(Status::Ok(), kvs.Put(keys[0], kValue));
-  ASSERT_EQ(Status::Ok(), kvs.Delete(keys[0]));
+  ASSERT_EQ(OkStatus(), kvs.Put(keys[0], kValue));
+  ASSERT_EQ(OkStatus(), kvs.Delete(keys[0]));
 
   // Compare before / after checksums to verify that nothing was written.
   const uint16_t crc = checksum::Crc16Ccitt::Calculate(flash.memory.buffer());
@@ -358,8 +358,8 @@
 class LargeEmptyInitializedKvs : public ::testing::Test {
  protected:
   LargeEmptyInitializedKvs() : kvs_(&large_test_partition, default_format) {
-    ASSERT_EQ(Status::Ok(), large_test_partition.Erase());
-    ASSERT_EQ(Status::Ok(), kvs_.Init());
+    ASSERT_EQ(OkStatus(), large_test_partition.Erase());
+    ASSERT_EQ(OkStatus(), kvs_.Init());
   }
 
   KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs_;
@@ -369,14 +369,14 @@
   const uint8_t kValue1 = 0xDA;
   const uint8_t kValue2 = 0x12;
   uint8_t value;
-  ASSERT_EQ(Status::Ok(), kvs_.Put(keys[0], kValue1));
+  ASSERT_EQ(OkStatus(), kvs_.Put(keys[0], kValue1));
   EXPECT_EQ(kvs_.size(), 1u);
-  ASSERT_EQ(Status::Ok(), kvs_.Delete(keys[0]));
+  ASSERT_EQ(OkStatus(), kvs_.Delete(keys[0]));
   EXPECT_EQ(kvs_.Get(keys[0], &value), Status::NotFound());
-  ASSERT_EQ(Status::Ok(), kvs_.Put(keys[1], kValue1));
-  ASSERT_EQ(Status::Ok(), kvs_.Put(keys[2], kValue2));
-  ASSERT_EQ(Status::Ok(), kvs_.Delete(keys[1]));
-  EXPECT_EQ(Status::Ok(), kvs_.Get(keys[2], &value));
+  ASSERT_EQ(OkStatus(), kvs_.Put(keys[1], kValue1));
+  ASSERT_EQ(OkStatus(), kvs_.Put(keys[2], kValue2));
+  ASSERT_EQ(OkStatus(), kvs_.Delete(keys[1]));
+  EXPECT_EQ(OkStatus(), kvs_.Get(keys[2], &value));
   EXPECT_EQ(kValue2, value);
   ASSERT_EQ(kvs_.Get(keys[1], &value), Status::NotFound());
   EXPECT_EQ(kvs_.size(), 1u);
@@ -388,8 +388,8 @@
 
   // Write a key and write again with a different value, resulting in a stale
   // entry from the first write.
-  ASSERT_EQ(Status::Ok(), kvs_.Put(keys[0], kValue1));
-  ASSERT_EQ(Status::Ok(), kvs_.Put(keys[0], kValue2));
+  ASSERT_EQ(OkStatus(), kvs_.Put(keys[0], kValue1));
+  ASSERT_EQ(OkStatus(), kvs_.Put(keys[0], kValue2));
   EXPECT_EQ(kvs_.size(), 1u);
 
   KeyValueStore::StorageStats stats = kvs_.GetStorageStats();
@@ -398,14 +398,14 @@
 
   // Do regular FullMaintenance, which should not touch the sector with valid
   // data.
-  EXPECT_EQ(Status::Ok(), kvs_.FullMaintenance());
+  EXPECT_EQ(OkStatus(), kvs_.FullMaintenance());
   stats = kvs_.GetStorageStats();
   EXPECT_EQ(stats.sector_erase_count, 0u);
   EXPECT_GT(stats.reclaimable_bytes, 0u);
 
   // Do aggressive FullMaintenance, which should GC the sector with valid data,
   // resulting in no reclaimable bytes and an erased sector.
-  EXPECT_EQ(Status::Ok(), kvs_.HeavyMaintenance());
+  EXPECT_EQ(OkStatus(), kvs_.HeavyMaintenance());
   stats = kvs_.GetStorageStats();
   EXPECT_EQ(stats.sector_erase_count, 1u);
   EXPECT_EQ(stats.reclaimable_bytes, 0u);
@@ -414,7 +414,7 @@
 TEST(InMemoryKvs, Put_MaxValueSize) {
   // Create and erase the fake flash.
   Flash flash;
-  ASSERT_EQ(Status::Ok(), flash.partition.Erase());
+  ASSERT_EQ(OkStatus(), flash.partition.Erase());
 
   // Create and initialize the KVS.
   KeyValueStoreBuffer<kMaxEntries, kMaxUsableSectors> kvs(&flash.partition,
@@ -434,7 +434,7 @@
   ASSERT_GT(sizeof(large_test_flash), max_value_size + 2 * sizeof(EntryHeader));
   auto big_data = std::as_bytes(std::span(&large_test_flash, 1));
 
-  EXPECT_EQ(Status::Ok(), kvs.Put("K", big_data.subspan(0, max_value_size)));
+  EXPECT_EQ(OkStatus(), kvs.Put("K", big_data.subspan(0, max_value_size)));
 
   // Larger than maximum is rejected.
   EXPECT_EQ(Status::InvalidArgument(),
diff --git a/pw_kvs/key_value_store_wear_test.cc b/pw_kvs/key_value_store_wear_test.cc
index d272535..4110c16 100644
--- a/pw_kvs/key_value_store_wear_test.cc
+++ b/pw_kvs/key_value_store_wear_test.cc
@@ -35,7 +35,7 @@
       : flash_(internal::Entry::kMinAlignmentBytes),
         partition_(&flash_, 0, flash_.sector_count()),
         kvs_(&partition_, format) {
-    EXPECT_EQ(Status::Ok(), kvs_.Init());
+    EXPECT_EQ(OkStatus(), kvs_.Init());
   }
 
   static constexpr size_t kSectors = 16;
@@ -92,7 +92,7 @@
     test_data[0]++;
 
     EXPECT_EQ(
-        Status::Ok(),
+        OkStatus(),
         kvs_.Put("key",
                  std::as_bytes(std::span(test_data, sizeof(test_data) - 70))));
   }
@@ -105,7 +105,7 @@
     test_data[0]++;
 
     printf("Add entry %zu\n", i);
-    EXPECT_EQ(Status::Ok(), kvs_.Put("big_key", test_data));
+    EXPECT_EQ(OkStatus(), kvs_.Put("big_key", test_data));
   }
 
   EXPECT_EQ(2u, kvs_.size());
diff --git a/pw_kvs/public/pw_kvs/fake_flash_memory.h b/pw_kvs/public/pw_kvs/fake_flash_memory.h
index 9795e01..e892d92 100644
--- a/pw_kvs/public/pw_kvs/fake_flash_memory.h
+++ b/pw_kvs/public/pw_kvs/fake_flash_memory.h
@@ -97,9 +97,9 @@
         write_errors_(write_errors) {}
 
   // The fake flash is always enabled.
-  Status Enable() override { return Status::Ok(); }
+  Status Enable() override { return OkStatus(); }
 
-  Status Disable() override { return Status::Ok(); }
+  Status Disable() override { return OkStatus(); }
 
   bool IsEnabled() const override { return true; }
 
diff --git a/pw_kvs/public/pw_kvs/flash_memory.h b/pw_kvs/public/pw_kvs/flash_memory.h
index 3b25d88..28fd043 100644
--- a/pw_kvs/public/pw_kvs/flash_memory.h
+++ b/pw_kvs/public/pw_kvs/flash_memory.h
@@ -187,7 +187,7 @@
   virtual ~FlashPartition() = default;
 
   // Performs any required partition or flash-level initialization.
-  virtual Status Init() { return Status::Ok(); }
+  virtual Status Init() { return OkStatus(); }
 
   // Erase num_sectors starting at a given address. Blocking call.
   // Address must be on a sector boundary. Returns:
diff --git a/pw_kvs/public/pw_kvs/io.h b/pw_kvs/public/pw_kvs/io.h
index 341b80a..193427c 100644
--- a/pw_kvs/public/pw_kvs/io.h
+++ b/pw_kvs/public/pw_kvs/io.h
@@ -73,7 +73,7 @@
 
 // Output adapter that calls a method on a class with a std::span of bytes. If
 // the method returns void instead of the expected Status, Write always returns
-// Status::Ok().
+// OkStatus().
 template <typename T, T kMethod>
 class OutputToMethod final : public Output {
   using Class = typename internal::FunctionTraits<decltype(kMethod)>::Class;
diff --git a/pw_kvs/sectors.cc b/pw_kvs/sectors.cc
index e8d91b7..67ede37 100644
--- a/pw_kvs/sectors.cc
+++ b/pw_kvs/sectors.cc
@@ -111,7 +111,7 @@
       if ((find_mode == kAppendEntry) ||
           (sector->RecoverableBytes(sector_size_bytes) == 0)) {
         *found_sector = sector;
-        return Status::Ok();
+        return OkStatus();
       } else {
         if ((non_empty_least_reclaimable_sector == nullptr) ||
             (non_empty_least_reclaimable_sector->RecoverableBytes(
@@ -140,7 +140,7 @@
         Index(first_empty_sector));
     last_new_ = first_empty_sector;
     *found_sector = first_empty_sector;
-    return Status::Ok();
+    return OkStatus();
   }
 
   // Tier 3 check: If we got this far, use the sector with least recoverable
@@ -150,7 +150,7 @@
     DBG("  Found a usable sector %u, with %u B recoverable, in GC",
         Index(*found_sector),
         unsigned((*found_sector)->RecoverableBytes(sector_size_bytes)));
-    return Status::Ok();
+    return OkStatus();
   }
 
   // No sector was found.
diff --git a/pw_kvs/test_key_value_store_test.cc b/pw_kvs/test_key_value_store_test.cc
index af6d4a9..97ececd 100644
--- a/pw_kvs/test_key_value_store_test.cc
+++ b/pw_kvs/test_key_value_store_test.cc
@@ -24,10 +24,10 @@
 // Simple test to verify that the TestKvs() does basic function.
 TEST(TestKvs, PutGetValue) {
   KeyValueStore& kvs = TestKvs();
-  ASSERT_EQ(Status::Ok(), kvs.Put("key", uint32_t(0xfeedbeef)));
+  ASSERT_EQ(OkStatus(), kvs.Put("key", uint32_t(0xfeedbeef)));
 
   uint32_t value = 0;
-  EXPECT_EQ(Status::Ok(), kvs.Get("key", &value));
+  EXPECT_EQ(OkStatus(), kvs.Get("key", &value));
   EXPECT_EQ(uint32_t(0xfeedbeef), value);
 }
 
diff --git a/pw_log_multisink/log_queue.cc b/pw_log_multisink/log_queue.cc
index 65411eb..6a528ea 100644
--- a/pw_log_multisink/log_queue.cc
+++ b/pw_log_multisink/log_queue.cc
@@ -79,7 +79,7 @@
   }
 
   dropped_entries_ = 0;
-  return Status::Ok();
+  return OkStatus();
 }
 
 Result<LogEntries> LogQueue::Pop(LogEntriesBuffer entry_buffer) {
diff --git a/pw_log_multisink/log_queue_test.cc b/pw_log_multisink/log_queue_test.cc
index 7fe3fd6..b9243b5 100644
--- a/pw_log_multisink/log_queue_test.cc
+++ b/pw_log_multisink/log_queue_test.cc
@@ -87,7 +87,7 @@
   std::byte log_buffer[kLogBufferSize];
   LogQueueWithEncodeBuffer<kEncodeBufferSize> log_queue(log_buffer);
 
-  EXPECT_EQ(Status::OK,
+  EXPECT_EQ(OkStatus(),
             log_queue.PushTokenizedMessage(
                 std::as_bytes(std::span(kTokenizedMessage)),
                 kFlags,
@@ -118,7 +118,7 @@
   LogQueueWithEncodeBuffer<kEncodeBufferSize> log_queue(log_buffer);
 
   for (size_t i = 0; i < kEntryCount; i++) {
-    EXPECT_EQ(Status::OK,
+    EXPECT_EQ(OkStatus(),
               log_queue.PushTokenizedMessage(
                   std::as_bytes(std::span(kTokenizedMessage)),
                   kFlags,
@@ -152,7 +152,7 @@
   LogQueueWithEncodeBuffer<kEncodeBufferSize> log_queue(log_buffer);
 
   for (size_t i = 0; i < kEntryCount; i++) {
-    EXPECT_EQ(Status::OK,
+    EXPECT_EQ(OkStatus(),
               log_queue.PushTokenizedMessage(
                   std::as_bytes(std::span(kTokenizedMessage)),
                   kFlags,
diff --git a/pw_log_multisink/public/pw_log_multisink/log_queue.h b/pw_log_multisink/public/pw_log_multisink/log_queue.h
index 450d0fa..f358abb 100644
--- a/pw_log_multisink/public/pw_log_multisink/log_queue.h
+++ b/pw_log_multisink/public/pw_log_multisink/log_queue.h
@@ -58,7 +58,7 @@
   LogQueue(ByteSpan log_buffer,
            ByteSpan encode_buffer,
            size_t max_log_entry_size = kLogEntryMaxSize)
-      : pop_status_for_test_(Status::Ok()),
+      : pop_status_for_test_(OkStatus()),
         max_log_entry_size_(max_log_entry_size),
         encode_buffer_(encode_buffer),
         ring_buffer_(true) {
diff --git a/pw_log_rpc/logs_rpc.cc b/pw_log_rpc/logs_rpc.cc
index ada5470..c790b222 100644
--- a/pw_log_rpc/logs_rpc.cc
+++ b/pw_log_rpc/logs_rpc.cc
@@ -39,7 +39,7 @@
   // If the response writer was not initialized or has since been closed,
   // ignore the flush operation.
   if (!response_writer_.open()) {
-    return Status::Ok();
+    return OkStatus();
   }
 
   // If previous calls to flush resulted in dropped entries, generate a
@@ -59,7 +59,7 @@
   Result possible_logs = log_queue_.PopMultiple(payload);
   PW_TRY(possible_logs.status());
   if (possible_logs.value().entry_count == 0) {
-    return Status::Ok();
+    return OkStatus();
   }
 
   Status status = response_writer_.Write(possible_logs.value().entries);
@@ -69,7 +69,7 @@
     return status;
   }
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 }  // namespace pw::log_rpc
diff --git a/pw_log_rpc/logs_rpc_test.cc b/pw_log_rpc/logs_rpc_test.cc
index 50541bb..88a3f50 100644
--- a/pw_log_rpc/logs_rpc_test.cc
+++ b/pw_log_rpc/logs_rpc_test.cc
@@ -45,7 +45,7 @@
     constexpr char kTokenizedMessage[] = "message";
     for (size_t i = 0; i < log_count; i++) {
       EXPECT_EQ(
-          Status::Ok(),
+          OkStatus(),
           log_queue_.PushTokenizedMessage(
               std::as_bytes(std::span(kTokenizedMessage)), 0, 0, 0, 0, 0));
     }
@@ -72,7 +72,7 @@
   GetLogs(context).Finish();
 
   EXPECT_TRUE(context.done());
-  EXPECT_EQ(Status::Ok(), context.status());
+  EXPECT_EQ(OkStatus(), context.status());
 
   // Although |kLogEntryCount| messages were in the queue, they are batched
   // before being written to the client, so there is only one response.
@@ -94,7 +94,7 @@
   GetLogs(context).Finish();
 
   EXPECT_TRUE(context.done());
-  EXPECT_EQ(Status::Ok(), context.status());
+  EXPECT_EQ(OkStatus(), context.status());
   EXPECT_EQ(kFlushCount, context.total_responses());
 }
 
@@ -108,7 +108,7 @@
   GetLogs(context).Finish();
 
   EXPECT_TRUE(context.done());
-  EXPECT_EQ(Status::Ok(), context.status());
+  EXPECT_EQ(OkStatus(), context.status());
   EXPECT_EQ(0U, context.total_responses());
 }
 
@@ -124,7 +124,7 @@
   GetLogs(context).Finish();
 
   EXPECT_TRUE(context.done());
-  EXPECT_EQ(Status::Ok(), context.status());
+  EXPECT_EQ(OkStatus(), context.status());
   EXPECT_EQ(0U, context.total_responses());
 }
 
diff --git a/pw_metric/metric_service_nanopb_test.cc b/pw_metric/metric_service_nanopb_test.cc
index b2c3966..5810982 100644
--- a/pw_metric/metric_service_nanopb_test.cc
+++ b/pw_metric/metric_service_nanopb_test.cc
@@ -33,7 +33,7 @@
   MetricMethodContext context(root.metrics(), root.children());
   context.call({});
   EXPECT_TRUE(context.done());
-  EXPECT_EQ(Status::Ok(), context.status());
+  EXPECT_EQ(OkStatus(), context.status());
 
   // No metrics should be in the response.
   EXPECT_EQ(0u, context.responses().size());
@@ -52,7 +52,7 @@
   MetricMethodContext context(root.metrics(), root.children());
   context.call({});
   EXPECT_TRUE(context.done());
-  EXPECT_EQ(Status::Ok(), context.status());
+  EXPECT_EQ(OkStatus(), context.status());
 
   // All of the responses should have fit in one proto.
   EXPECT_EQ(1u, context.responses().size());
@@ -77,7 +77,7 @@
   MetricMethodContext context(root.metrics(), root.children());
   context.call({});
   EXPECT_TRUE(context.done());
-  EXPECT_EQ(Status::Ok(), context.status());
+  EXPECT_EQ(OkStatus(), context.status());
 
   // All of the responses should fit in one proto.
   EXPECT_EQ(1u, context.responses().size());
@@ -111,7 +111,7 @@
   MetricMethodContext context(root.metrics(), root.children());
   context.call({});
   EXPECT_TRUE(context.done());
-  EXPECT_EQ(Status::Ok(), context.status());
+  EXPECT_EQ(OkStatus(), context.status());
 
   // The response had to be split into two parts; check that they have the
   // appropriate sizes.
@@ -171,7 +171,7 @@
   MetricMethodContext context(root.metrics(), root.children());
   context.call({});
   EXPECT_TRUE(context.done());
-  EXPECT_EQ(Status::Ok(), context.status());
+  EXPECT_EQ(OkStatus(), context.status());
 
   // The metrics should fit in one batch.
   EXPECT_EQ(1u, context.responses().size());
diff --git a/pw_protobuf/codegen_test.cc b/pw_protobuf/codegen_test.cc
index 72e11a7..385de2f 100644
--- a/pw_protobuf/codegen_test.cc
+++ b/pw_protobuf/codegen_test.cc
@@ -167,7 +167,7 @@
   // clang-format on
 
   Result result = encoder.Encode();
-  ASSERT_EQ(result.status(), Status::Ok());
+  ASSERT_EQ(result.status(), OkStatus());
   EXPECT_EQ(result.value().size(), sizeof(expected_proto));
   EXPECT_EQ(std::memcmp(
                 result.value().data(), expected_proto, sizeof(expected_proto)),
@@ -187,7 +187,7 @@
       0x08, 0x00, 0x08, 0x10, 0x08, 0x20, 0x08, 0x30};
 
   Result result = encoder.Encode();
-  ASSERT_EQ(result.status(), Status::Ok());
+  ASSERT_EQ(result.status(), OkStatus());
   EXPECT_EQ(result.value().size(), sizeof(expected_proto));
   EXPECT_EQ(std::memcmp(
                 result.value().data(), expected_proto, sizeof(expected_proto)),
@@ -204,7 +204,7 @@
 
   constexpr uint8_t expected_proto[] = {0x0a, 0x04, 0x00, 0x10, 0x20, 0x30};
   Result result = encoder.Encode();
-  ASSERT_EQ(result.status(), Status::Ok());
+  ASSERT_EQ(result.status(), OkStatus());
   EXPECT_EQ(result.value().size(), sizeof(expected_proto));
   EXPECT_EQ(std::memcmp(
                 result.value().data(), expected_proto, sizeof(expected_proto)),
@@ -225,7 +225,7 @@
       0x1a, 0x03, 't', 'h', 'e', 0x1a, 0x5, 'q',  'u', 'i', 'c', 'k',
       0x1a, 0x5,  'b', 'r', 'o', 'w',  'n', 0x1a, 0x3, 'f', 'o', 'x'};
   Result result = encoder.Encode();
-  ASSERT_EQ(result.status(), Status::Ok());
+  ASSERT_EQ(result.status(), OkStatus());
   EXPECT_EQ(result.value().size(), sizeof(expected_proto));
   EXPECT_EQ(std::memcmp(
                 result.value().data(), expected_proto, sizeof(expected_proto)),
@@ -250,7 +250,7 @@
   // clang-format on
 
   Result result = encoder.Encode();
-  ASSERT_EQ(result.status(), Status::Ok());
+  ASSERT_EQ(result.status(), OkStatus());
   EXPECT_EQ(result.value().size(), sizeof(expected_proto));
   EXPECT_EQ(std::memcmp(
                 result.value().data(), expected_proto, sizeof(expected_proto)),
@@ -275,7 +275,7 @@
       0x08, 0x03, 0x1a, 0x06, 0x0a, 0x04, 0xde, 0xad, 0xbe, 0xef};
 
   Result result = encoder.Encode();
-  ASSERT_EQ(result.status(), Status::Ok());
+  ASSERT_EQ(result.status(), OkStatus());
   EXPECT_EQ(result.value().size(), sizeof(expected_proto));
   EXPECT_EQ(std::memcmp(
                 result.value().data(), expected_proto, sizeof(expected_proto)),
@@ -299,7 +299,7 @@
     end.WriteNanoseconds(490367432);
   }
 
-  EXPECT_EQ(encoder.Encode().status(), Status::Ok());
+  EXPECT_EQ(encoder.Encode().status(), OkStatus());
 }
 
 TEST(Codegen, NonPigweedPackage) {
@@ -311,7 +311,7 @@
   packed.WriteRep(std::span<const int64_t>(repeated));
   packed.WritePacked("packed");
 
-  EXPECT_EQ(encoder.Encode().status(), Status::Ok());
+  EXPECT_EQ(encoder.Encode().status(), OkStatus());
 }
 
 }  // namespace
diff --git a/pw_protobuf/decoder.cc b/pw_protobuf/decoder.cc
index 70880ad..332f49a 100644
--- a/pw_protobuf/decoder.cc
+++ b/pw_protobuf/decoder.cc
@@ -30,7 +30,7 @@
     return Status::OutOfRange();
   }
   previous_field_consumed_ = false;
-  return FieldSize() == 0 ? Status::DataLoss() : Status::Ok();
+  return FieldSize() == 0 ? Status::DataLoss() : OkStatus();
 }
 
 Status Decoder::SkipField() {
@@ -44,7 +44,7 @@
   }
 
   proto_ = proto_.subspan(bytes_to_skip);
-  return proto_.empty() ? Status::OutOfRange() : Status::Ok();
+  return proto_.empty() ? Status::OutOfRange() : OkStatus();
 }
 
 uint32_t Decoder::FieldNumber() const {
@@ -63,7 +63,7 @@
     return Status::OutOfRange();
   }
   *out = value;
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status Decoder::ReadSint32(int32_t* out) {
@@ -76,7 +76,7 @@
     return Status::OutOfRange();
   }
   *out = value;
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status Decoder::ReadSint64(int64_t* out) {
@@ -86,7 +86,7 @@
     return status;
   }
   *out = varint::ZigZagDecode(value);
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status Decoder::ReadBool(bool* out) {
@@ -96,7 +96,7 @@
     return status;
   }
   *out = value;
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status Decoder::ReadString(std::string_view* out) {
@@ -107,7 +107,7 @@
   }
   *out = std::string_view(reinterpret_cast<const char*>(bytes.data()),
                           bytes.size());
-  return Status::Ok();
+  return OkStatus();
 }
 
 size_t Decoder::FieldSize() const {
@@ -169,7 +169,7 @@
 
   // Advance past the key.
   proto_ = proto_.subspan(bytes_read);
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status Decoder::ReadVarint(uint64_t* out) {
@@ -185,7 +185,7 @@
   // Advance to the next field.
   proto_ = proto_.subspan(bytes_read);
   previous_field_consumed_ = true;
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status Decoder::ReadFixed(std::byte* out, size_t size) {
@@ -204,7 +204,7 @@
   proto_ = proto_.subspan(size);
   previous_field_consumed_ = true;
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status Decoder::ReadDelimited(std::span<const std::byte>* out) {
@@ -228,7 +228,7 @@
   proto_ = proto_.subspan(length);
   previous_field_consumed_ = true;
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status CallbackDecoder::Decode(std::span<const std::byte> proto) {
@@ -269,7 +269,7 @@
   }
 
   state_ = kReady;
-  return Status::Ok();
+  return OkStatus();
 }
 
 }  // namespace pw::protobuf
diff --git a/pw_protobuf/decoder_test.cc b/pw_protobuf/decoder_test.cc
index 0b4f6ff..c77e990 100644
--- a/pw_protobuf/decoder_test.cc
+++ b/pw_protobuf/decoder_test.cc
@@ -50,7 +50,7 @@
     }
 
     called = true;
-    return Status::Ok();
+    return OkStatus();
   }
 
   bool called = false;
@@ -83,40 +83,40 @@
   Decoder decoder(std::as_bytes(std::span(encoded_proto)));
 
   int32_t v1 = 0;
-  EXPECT_EQ(decoder.Next(), Status::Ok());
+  EXPECT_EQ(decoder.Next(), OkStatus());
   ASSERT_EQ(decoder.FieldNumber(), 1u);
-  EXPECT_EQ(decoder.ReadInt32(&v1), Status::Ok());
+  EXPECT_EQ(decoder.ReadInt32(&v1), OkStatus());
   EXPECT_EQ(v1, 42);
 
   int32_t v2 = 0;
-  EXPECT_EQ(decoder.Next(), Status::Ok());
+  EXPECT_EQ(decoder.Next(), OkStatus());
   ASSERT_EQ(decoder.FieldNumber(), 2u);
-  EXPECT_EQ(decoder.ReadSint32(&v2), Status::Ok());
+  EXPECT_EQ(decoder.ReadSint32(&v2), OkStatus());
   EXPECT_EQ(v2, -13);
 
   bool v3 = true;
-  EXPECT_EQ(decoder.Next(), Status::Ok());
+  EXPECT_EQ(decoder.Next(), OkStatus());
   ASSERT_EQ(decoder.FieldNumber(), 3u);
-  EXPECT_EQ(decoder.ReadBool(&v3), Status::Ok());
+  EXPECT_EQ(decoder.ReadBool(&v3), OkStatus());
   EXPECT_FALSE(v3);
 
   double v4 = 0;
-  EXPECT_EQ(decoder.Next(), Status::Ok());
+  EXPECT_EQ(decoder.Next(), OkStatus());
   ASSERT_EQ(decoder.FieldNumber(), 4u);
-  EXPECT_EQ(decoder.ReadDouble(&v4), Status::Ok());
+  EXPECT_EQ(decoder.ReadDouble(&v4), OkStatus());
   EXPECT_EQ(v4, 3.14159);
 
   uint32_t v5 = 0;
-  EXPECT_EQ(decoder.Next(), Status::Ok());
+  EXPECT_EQ(decoder.Next(), OkStatus());
   ASSERT_EQ(decoder.FieldNumber(), 5u);
-  EXPECT_EQ(decoder.ReadFixed32(&v5), Status::Ok());
+  EXPECT_EQ(decoder.ReadFixed32(&v5), OkStatus());
   EXPECT_EQ(v5, 0xdeadbeef);
 
   std::string_view v6;
   char buffer[16];
-  EXPECT_EQ(decoder.Next(), Status::Ok());
+  EXPECT_EQ(decoder.Next(), OkStatus());
   ASSERT_EQ(decoder.FieldNumber(), 6u);
-  EXPECT_EQ(decoder.ReadString(&v6), Status::Ok());
+  EXPECT_EQ(decoder.ReadString(&v6), OkStatus());
   std::memcpy(buffer, v6.data(), v6.size());
   buffer[v6.size()] = '\0';
   EXPECT_STREQ(buffer, "Hello world");
@@ -146,13 +146,13 @@
 
   // Don't process any fields except for the fourth. Next should still iterate
   // correctly despite field values not being consumed.
-  EXPECT_EQ(decoder.Next(), Status::Ok());
-  EXPECT_EQ(decoder.Next(), Status::Ok());
-  EXPECT_EQ(decoder.Next(), Status::Ok());
-  EXPECT_EQ(decoder.Next(), Status::Ok());
+  EXPECT_EQ(decoder.Next(), OkStatus());
+  EXPECT_EQ(decoder.Next(), OkStatus());
+  EXPECT_EQ(decoder.Next(), OkStatus());
+  EXPECT_EQ(decoder.Next(), OkStatus());
   ASSERT_EQ(decoder.FieldNumber(), 4u);
-  EXPECT_EQ(decoder.Next(), Status::Ok());
-  EXPECT_EQ(decoder.Next(), Status::Ok());
+  EXPECT_EQ(decoder.Next(), OkStatus());
+  EXPECT_EQ(decoder.Next(), OkStatus());
   EXPECT_EQ(decoder.Next(), Status::OutOfRange());
 }
 
@@ -179,7 +179,7 @@
 
   decoder.set_handler(&handler);
   EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
-            Status::Ok());
+            OkStatus());
   EXPECT_TRUE(handler.called);
   EXPECT_EQ(handler.test_int32, 42);
   EXPECT_EQ(handler.test_sint32, -13);
@@ -206,7 +206,7 @@
 
   decoder.set_handler(&handler);
   EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
-            Status::Ok());
+            OkStatus());
   EXPECT_TRUE(handler.called);
   EXPECT_EQ(handler.test_int32, 44);
 }
@@ -216,7 +216,7 @@
   TestDecodeHandler handler;
 
   decoder.set_handler(&handler);
-  EXPECT_EQ(decoder.Decode(std::span<std::byte>()), Status::Ok());
+  EXPECT_EQ(decoder.Decode(std::span<std::byte>()), OkStatus());
   EXPECT_FALSE(handler.called);
   EXPECT_EQ(handler.test_int32, 0);
   EXPECT_EQ(handler.test_sint32, 0);
@@ -241,10 +241,10 @@
                       uint32_t field_number) override {
     switch (field_number) {
       case 1:
-        EXPECT_EQ(decoder.ReadInt32(&field_one), Status::Ok());
+        EXPECT_EQ(decoder.ReadInt32(&field_one), OkStatus());
         break;
       case 3:
-        EXPECT_EQ(decoder.ReadInt32(&field_three), Status::Ok());
+        EXPECT_EQ(decoder.ReadInt32(&field_three), OkStatus());
         break;
       default:
         // Do nothing.
@@ -252,7 +252,7 @@
     }
 
     called = true;
-    return Status::Ok();
+    return OkStatus();
   }
 
   bool called = false;
@@ -286,7 +286,7 @@
 
   decoder.set_handler(&handler);
   EXPECT_EQ(decoder.Decode(std::as_bytes(std::span(encoded_proto))),
-            Status::Ok());
+            OkStatus());
   EXPECT_TRUE(handler.called);
   EXPECT_EQ(handler.field_one, 42);
   EXPECT_EQ(handler.field_three, 99);
@@ -299,17 +299,17 @@
                       uint32_t field_number) override {
     switch (field_number) {
       case 1:
-        EXPECT_EQ(decoder.ReadInt32(&field_one), Status::Ok());
+        EXPECT_EQ(decoder.ReadInt32(&field_one), OkStatus());
         return Status::Cancelled();
       case 3:
-        EXPECT_EQ(decoder.ReadInt32(&field_three), Status::Ok());
+        EXPECT_EQ(decoder.ReadInt32(&field_three), OkStatus());
         break;
       default:
         // Do nothing.
         break;
     }
 
-    return Status::Ok();
+    return OkStatus();
   }
 
   int32_t field_one = 0;
diff --git a/pw_protobuf/encoder.cc b/pw_protobuf/encoder.cc
index 6ff8c7c..807a78b 100644
--- a/pw_protobuf/encoder.cc
+++ b/pw_protobuf/encoder.cc
@@ -43,7 +43,7 @@
   }
 
   cursor_ += written;
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status Encoder::WriteRawBytes(const std::byte* ptr, size_t size) {
@@ -61,7 +61,7 @@
   std::memmove(cursor_, ptr, size);
 
   cursor_ += size;
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status Encoder::Push(uint32_t field_number) {
@@ -105,7 +105,7 @@
   blob_stack_[depth_++] = size_cursor;
 
   cursor_ += sizeof(*size_cursor);
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status Encoder::Pop() {
@@ -130,7 +130,7 @@
   }
   blob_count_--;
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 Result<ConstByteSpan> Encoder::Encode() { return EncodeFrom(0); }
diff --git a/pw_protobuf/encoder_test.cc b/pw_protobuf/encoder_test.cc
index a7d04b6..bb41875 100644
--- a/pw_protobuf/encoder_test.cc
+++ b/pw_protobuf/encoder_test.cc
@@ -85,16 +85,16 @@
   std::byte encode_buffer[32];
   NestedEncoder encoder(encode_buffer);
 
-  EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::Ok());
-  EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), Status::Ok());
+  EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), OkStatus());
+  EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), OkStatus());
   EXPECT_EQ(encoder.WriteFixed64(kTestProtoCyclesField, 0xdeadbeef8badf00d),
-            Status::Ok());
-  EXPECT_EQ(encoder.WriteFloat(kTestProtoRatioField, 1.618034), Status::Ok());
+            OkStatus());
+  EXPECT_EQ(encoder.WriteFloat(kTestProtoRatioField, 1.618034), OkStatus());
   EXPECT_EQ(encoder.WriteString(kTestProtoErrorMessageField, "broken 💩"),
-            Status::Ok());
+            OkStatus());
 
   Result result = encoder.Encode();
-  ASSERT_EQ(result.status(), Status::Ok());
+  ASSERT_EQ(result.status(), OkStatus());
   EXPECT_EQ(result.value().size(), sizeof(encoded_proto));
   EXPECT_EQ(
       std::memcmp(result.value().data(), encoded_proto, sizeof(encoded_proto)),
@@ -106,9 +106,9 @@
   NestedEncoder encoder(encode_buffer);
 
   // 2 bytes.
-  EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::Ok());
+  EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), OkStatus());
   // 2 bytes.
-  EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), Status::Ok());
+  EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), OkStatus());
   // 9 bytes; not enough space! The encoder will start writing the field but
   // should rollback when it realizes it doesn't have enough space.
   EXPECT_EQ(encoder.WriteFixed64(kTestProtoCyclesField, 0xdeadbeef8badf00d),
@@ -124,7 +124,7 @@
   std::byte encode_buffer[12];
   NestedEncoder encoder(encode_buffer);
 
-  EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::Ok());
+  EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), OkStatus());
   // Invalid proto field numbers.
   EXPECT_EQ(encoder.WriteUint32(0, 1337), Status::InvalidArgument());
   encoder.Clear();
@@ -142,48 +142,47 @@
 
   // TestProto test_proto;
   // test_proto.magic_number = 42;
-  EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), Status::Ok());
+  EXPECT_EQ(encoder.WriteUint32(kTestProtoMagicNumberField, 42), OkStatus());
 
   {
     // NestedProto& nested_proto = test_proto.nested;
-    EXPECT_EQ(encoder.Push(kTestProtoNestedField), Status::Ok());
+    EXPECT_EQ(encoder.Push(kTestProtoNestedField), OkStatus());
     // nested_proto.hello = "world";
-    EXPECT_EQ(encoder.WriteString(kNestedProtoHelloField, "world"),
-              Status::Ok());
+    EXPECT_EQ(encoder.WriteString(kNestedProtoHelloField, "world"), OkStatus());
     // nested_proto.id = 999;
-    EXPECT_EQ(encoder.WriteUint32(kNestedProtoIdField, 999), Status::Ok());
+    EXPECT_EQ(encoder.WriteUint32(kNestedProtoIdField, 999), OkStatus());
 
     {
       // DoubleNestedProto& double_nested_proto = nested_proto.append_pair();
-      EXPECT_EQ(encoder.Push(kNestedProtoPairField), Status::Ok());
+      EXPECT_EQ(encoder.Push(kNestedProtoPairField), OkStatus());
       // double_nested_proto.key = "version";
       EXPECT_EQ(encoder.WriteString(kDoubleNestedProtoKeyField, "version"),
-                Status::Ok());
+                OkStatus());
       // double_nested_proto.value = "2.9.1";
       EXPECT_EQ(encoder.WriteString(kDoubleNestedProtoValueField, "2.9.1"),
-                Status::Ok());
+                OkStatus());
 
-      EXPECT_EQ(encoder.Pop(), Status::Ok());
+      EXPECT_EQ(encoder.Pop(), OkStatus());
     }  // end DoubleNestedProto
 
     {
       // DoubleNestedProto& double_nested_proto = nested_proto.append_pair();
-      EXPECT_EQ(encoder.Push(kNestedProtoPairField), Status::Ok());
+      EXPECT_EQ(encoder.Push(kNestedProtoPairField), OkStatus());
       // double_nested_proto.key = "device";
       EXPECT_EQ(encoder.WriteString(kDoubleNestedProtoKeyField, "device"),
-                Status::Ok());
+                OkStatus());
       // double_nested_proto.value = "left-soc";
       EXPECT_EQ(encoder.WriteString(kDoubleNestedProtoValueField, "left-soc"),
-                Status::Ok());
+                OkStatus());
 
-      EXPECT_EQ(encoder.Pop(), Status::Ok());
+      EXPECT_EQ(encoder.Pop(), OkStatus());
     }  // end DoubleNestedProto
 
-    EXPECT_EQ(encoder.Pop(), Status::Ok());
+    EXPECT_EQ(encoder.Pop(), OkStatus());
   }  // end NestedProto
 
   // test_proto.ziggy = -13;
-  EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), Status::Ok());
+  EXPECT_EQ(encoder.WriteSint32(kTestProtoZiggyField, -13), OkStatus());
 
   // clang-format off
   constexpr uint8_t encoded_proto[] = {
@@ -213,7 +212,7 @@
   // clang-format on
 
   Result result = encoder.Encode();
-  ASSERT_EQ(result.status(), Status::Ok());
+  ASSERT_EQ(result.status(), OkStatus());
   EXPECT_EQ(result.value().size(), sizeof(encoded_proto));
   EXPECT_EQ(
       std::memcmp(result.value().data(), encoded_proto, sizeof(encoded_proto)),
@@ -225,9 +224,9 @@
   NestedEncoder<2, 2> encoder(encode_buffer);
 
   // One level of nesting.
-  EXPECT_EQ(encoder.Push(2), Status::Ok());
+  EXPECT_EQ(encoder.Push(2), OkStatus());
   // Two levels of nesting.
-  EXPECT_EQ(encoder.Push(1), Status::Ok());
+  EXPECT_EQ(encoder.Push(1), OkStatus());
   // Three levels of nesting: error!
   EXPECT_EQ(encoder.Push(1), Status::ResourceExhausted());
 
@@ -242,22 +241,22 @@
   NestedEncoder<3, 3> encoder(encode_buffer);
 
   // Write first blob.
-  EXPECT_EQ(encoder.Push(1), Status::Ok());
-  EXPECT_EQ(encoder.Pop(), Status::Ok());
+  EXPECT_EQ(encoder.Push(1), OkStatus());
+  EXPECT_EQ(encoder.Pop(), OkStatus());
 
   // Write second blob.
-  EXPECT_EQ(encoder.Push(2), Status::Ok());
+  EXPECT_EQ(encoder.Push(2), OkStatus());
 
   // Write nested third blob.
-  EXPECT_EQ(encoder.Push(3), Status::Ok());
-  EXPECT_EQ(encoder.Pop(), Status::Ok());
+  EXPECT_EQ(encoder.Push(3), OkStatus());
+  EXPECT_EQ(encoder.Pop(), OkStatus());
 
   // End second blob.
-  EXPECT_EQ(encoder.Pop(), Status::Ok());
+  EXPECT_EQ(encoder.Pop(), OkStatus());
 
   // Write fourth blob: OK
-  EXPECT_EQ(encoder.Push(4), Status::Ok());
-  EXPECT_EQ(encoder.Pop(), Status::Ok());
+  EXPECT_EQ(encoder.Push(4), OkStatus());
+  EXPECT_EQ(encoder.Pop(), OkStatus());
 }
 
 TEST(Encoder, RepeatedField) {
@@ -274,7 +273,7 @@
       0x08, 0x00, 0x08, 0x32, 0x08, 0x64, 0x08, 0x96, 0x01, 0x08, 0xc8, 0x01};
 
   Result result = encoder.Encode();
-  ASSERT_EQ(result.status(), Status::Ok());
+  ASSERT_EQ(result.status(), OkStatus());
   EXPECT_EQ(result.value().size(), sizeof(encoded_proto));
   EXPECT_EQ(
       std::memcmp(result.value().data(), encoded_proto, sizeof(encoded_proto)),
@@ -294,7 +293,7 @@
   //  key   size  v[0]  v[1]  v[2]  v[3]        v[4]
 
   Result result = encoder.Encode();
-  ASSERT_EQ(result.status(), Status::Ok());
+  ASSERT_EQ(result.status(), OkStatus());
   EXPECT_EQ(result.value().size(), sizeof(encoded_proto));
   EXPECT_EQ(
       std::memcmp(result.value().data(), encoded_proto, sizeof(encoded_proto)),
@@ -329,7 +328,7 @@
       0x12, 0x08, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01};
 
   Result result = encoder.Encode();
-  ASSERT_EQ(result.status(), Status::Ok());
+  ASSERT_EQ(result.status(), OkStatus());
   EXPECT_EQ(result.value().size(), sizeof(encoded_proto));
   EXPECT_EQ(
       std::memcmp(result.value().data(), encoded_proto, sizeof(encoded_proto)),
@@ -348,7 +347,7 @@
       0x0a, 0x09, 0xc7, 0x01, 0x31, 0x01, 0x00, 0x02, 0x32, 0xc8, 0x01};
 
   Result result = encoder.Encode();
-  ASSERT_EQ(result.status(), Status::Ok());
+  ASSERT_EQ(result.status(), OkStatus());
   EXPECT_EQ(result.value().size(), sizeof(encoded_proto));
   EXPECT_EQ(
       std::memcmp(result.value().data(), encoded_proto, sizeof(encoded_proto)),
diff --git a/pw_protobuf/find.cc b/pw_protobuf/find.cc
index 635f50b..0082726 100644
--- a/pw_protobuf/find.cc
+++ b/pw_protobuf/find.cc
@@ -20,7 +20,7 @@
                                        uint32_t field_number) {
   if (field_number != field_number_) {
     // Continue to the next field.
-    return Status::Ok();
+    return OkStatus();
   }
 
   found_ = true;
diff --git a/pw_protobuf/public/pw_protobuf/decoder.h b/pw_protobuf/public/pw_protobuf/decoder.h
index 6cb402e..baa076c 100644
--- a/pw_protobuf/public/pw_protobuf/decoder.h
+++ b/pw_protobuf/public/pw_protobuf/decoder.h
@@ -192,7 +192,7 @@
 //           break;
 //       }
 //
-//       return Status::Ok();
+//       return OkStatus();
 //     }
 //
 //     int bar;
@@ -303,7 +303,7 @@
   // Receives a pointer to the decoder object, allowing the handler to call
   // the appropriate method to extract the field's data.
   //
-  // If the status returned is not Status::Ok(), the decode operation is exited
+  // If the status returned is not OkStatus(), the decode operation is exited
   // with the provided status. Returning Status::Cancelled() allows a convenient
   // way of stopping a decode early (for example, if a desired field is found).
   virtual Status ProcessField(CallbackDecoder& decoder,
diff --git a/pw_protobuf/public/pw_protobuf/encoder.h b/pw_protobuf/public/pw_protobuf/encoder.h
index 4277672..51c335d 100644
--- a/pw_protobuf/public/pw_protobuf/encoder.h
+++ b/pw_protobuf/public/pw_protobuf/encoder.h
@@ -42,7 +42,7 @@
         blob_count_(0),
         blob_stack_(stack),
         depth_(0),
-        encode_status_(Status::Ok()) {}
+        encode_status_(OkStatus()) {}
 
   // Disallow copy/assign to avoid confusion about who owns the buffer.
   Encoder(const Encoder& other) = delete;
@@ -261,7 +261,7 @@
   // obtained from Encode().
   void Clear() {
     cursor_ = buffer_.data();
-    encode_status_ = Status::Ok();
+    encode_status_ = OkStatus();
     blob_count_ = 0;
     depth_ = 0;
   }
@@ -278,7 +278,7 @@
       return result.status();
     }
     *out = result.value();
-    return Status::Ok();
+    return OkStatus();
   }
 
  private:
diff --git a/pw_random/xor_shift_test.cc b/pw_random/xor_shift_test.cc
index 6b7e379..a653584 100644
--- a/pw_random/xor_shift_test.cc
+++ b/pw_random/xor_shift_test.cc
@@ -44,7 +44,7 @@
   XorShiftStarRng64 rng(seed1);
   for (size_t i = 0; i < result1_count; ++i) {
     uint64_t val = 0;
-    EXPECT_EQ(rng.GetInt(val).status(), Status::Ok());
+    EXPECT_EQ(rng.GetInt(val).status(), OkStatus());
     EXPECT_EQ(val, result1[i]);
   }
 }
@@ -53,7 +53,7 @@
   XorShiftStarRng64 rng(seed2);
   for (size_t i = 0; i < result2_count; ++i) {
     uint64_t val = 0;
-    EXPECT_EQ(rng.GetInt(val).status(), Status::Ok());
+    EXPECT_EQ(rng.GetInt(val).status(), OkStatus());
     EXPECT_EQ(val, result2[i]);
   }
 }
@@ -62,7 +62,7 @@
   XorShiftStarRng64 rng(seed1);
   uint64_t val = 0;
   rng.InjectEntropyBits(0x1, 1);
-  EXPECT_EQ(rng.GetInt(val).status(), Status::Ok());
+  EXPECT_EQ(rng.GetInt(val).status(), OkStatus());
   EXPECT_NE(val, result1[0]);
 }
 
@@ -72,14 +72,14 @@
   XorShiftStarRng64 rng_1(seed1);
   uint64_t first_val = 0;
   rng_1.InjectEntropyBits(0x1, 1);
-  EXPECT_EQ(rng_1.GetInt(first_val).status(), Status::Ok());
+  EXPECT_EQ(rng_1.GetInt(first_val).status(), OkStatus());
 
   // Use the same starting seed.
   XorShiftStarRng64 rng_2(seed1);
   uint64_t second_val = 0;
   // Use a different number of entropy bits.
   rng_2.InjectEntropyBits(0x1, 2);
-  EXPECT_EQ(rng_2.GetInt(second_val).status(), Status::Ok());
+  EXPECT_EQ(rng_2.GetInt(second_val).status(), OkStatus());
 
   EXPECT_NE(first_val, second_val);
 }
@@ -91,7 +91,7 @@
   XorShiftStarRng64 rng_1(seed1);
   uint64_t first_val = 0;
   rng_1.InjectEntropyBits(0x6, 3);
-  EXPECT_EQ(rng_1.GetInt(first_val).status(), Status::Ok());
+  EXPECT_EQ(rng_1.GetInt(first_val).status(), OkStatus());
 
   // Use the same starting seed.
   XorShiftStarRng64 rng_2(seed1);
@@ -100,7 +100,7 @@
   rng_2.InjectEntropyBits(0x1, 1);
   rng_2.InjectEntropyBits(0x1, 1);
   rng_2.InjectEntropyBits(0x0, 1);
-  EXPECT_EQ(rng_2.GetInt(second_val).status(), Status::Ok());
+  EXPECT_EQ(rng_2.GetInt(second_val).status(), OkStatus());
 
   EXPECT_EQ(first_val, second_val);
 }
@@ -114,7 +114,7 @@
                                                    std::byte(0x17),
                                                    std::byte(0x02)};
   rng.InjectEntropy(entropy);
-  EXPECT_EQ(rng.GetInt(val).status(), Status::Ok());
+  EXPECT_EQ(rng.GetInt(val).status(), OkStatus());
   EXPECT_NE(val, result1[0]);
 }
 
diff --git a/pw_result/public/pw_result/result.h b/pw_result/public/pw_result/result.h
index 7093551..a55c2b4 100644
--- a/pw_result/public/pw_result/result.h
+++ b/pw_result/public/pw_result/result.h
@@ -26,20 +26,17 @@
 template <typename T>
 class Result {
  public:
-  constexpr Result(T&& value)
-      : value_(std::move(value)), status_(Status::Ok()) {}
-  constexpr Result(const T& value) : value_(value), status_(Status::Ok()) {}
+  constexpr Result(T&& value) : value_(std::move(value)), status_(OkStatus()) {}
+  constexpr Result(const T& value) : value_(value), status_(OkStatus()) {}
 
   template <typename... Args>
   constexpr Result(std::in_place_t, Args&&... args)
-      : value_(std::forward<Args>(args)...), status_(Status::Ok()) {}
+      : value_(std::forward<Args>(args)...), status_(OkStatus()) {}
 
   // TODO(pwbug/246): This can be constexpr when tokenized asserts are fixed.
-  Result(Status status) : status_(status) { PW_CHECK(status_ != Status::Ok()); }
+  Result(Status status) : status_(status) { PW_CHECK(status_ != OkStatus()); }
   // TODO(pwbug/246): This can be constexpr when tokenized asserts are fixed.
-  Result(Status::Code code) : status_(code) {
-    PW_CHECK(status_ != Status::Ok());
-  }
+  Result(Status::Code code) : status_(code) { PW_CHECK(status_ != OkStatus()); }
 
   constexpr Result(const Result&) = default;
   constexpr Result& operator=(const Result&) = default;
diff --git a/pw_result/result_test.cc b/pw_result/result_test.cc
index ef913fd..e9095f5 100644
--- a/pw_result/result_test.cc
+++ b/pw_result/result_test.cc
@@ -22,7 +22,7 @@
 TEST(Result, CreateOk) {
   Result<const char*> res("hello");
   EXPECT_TRUE(res.ok());
-  EXPECT_EQ(res.status(), Status::Ok());
+  EXPECT_EQ(res.status(), OkStatus());
   EXPECT_EQ(res.value(), "hello");
 }
 
diff --git a/pw_result/size_report/pointer_noinline.cc b/pw_result/size_report/pointer_noinline.cc
index 522c9fe..1318fec 100644
--- a/pw_result/size_report/pointer_noinline.cc
+++ b/pw_result/size_report/pointer_noinline.cc
@@ -21,7 +21,7 @@
     return pw::Status::InvalidArgument();
   }
   *out = a / b;
-  return pw::Status::Ok();
+  return pw::OkStatus();
 }
 
 int volatile* unoptimizable;
diff --git a/pw_result/size_report/pointer_read.cc b/pw_result/size_report/pointer_read.cc
index fb4f948..130cb56 100644
--- a/pw_result/size_report/pointer_read.cc
+++ b/pw_result/size_report/pointer_read.cc
@@ -38,7 +38,7 @@
   }
 
   *out = std::span<const std::byte>(std::data(kArray) + offset, size);
-  return pw::Status::Ok();
+  return pw::OkStatus();
 }
 
 }  // namespace
diff --git a/pw_result/size_report/pointer_simple.cc b/pw_result/size_report/pointer_simple.cc
index 7c1440e..599ca77 100644
--- a/pw_result/size_report/pointer_simple.cc
+++ b/pw_result/size_report/pointer_simple.cc
@@ -20,7 +20,7 @@
     return pw::Status::InvalidArgument();
   }
   *out = a / b;
-  return pw::Status::Ok();
+  return pw::OkStatus();
 }
 
 int volatile* unoptimizable;
diff --git a/pw_ring_buffer/prefixed_entry_ring_buffer.cc b/pw_ring_buffer/prefixed_entry_ring_buffer.cc
index d122162..82f76d0 100644
--- a/pw_ring_buffer/prefixed_entry_ring_buffer.cc
+++ b/pw_ring_buffer/prefixed_entry_ring_buffer.cc
@@ -40,7 +40,7 @@
   buffer_bytes_ = buffer.size_bytes();
 
   Clear();
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status PrefixedEntryRingBuffer::InternalPushBack(std::span<const byte> data,
@@ -80,7 +80,7 @@
   RawWrite(std::span(varint_buf, varint_bytes));
   RawWrite(data);
   entry_count_++;
-  return Status::Ok();
+  return OkStatus();
 }
 
 auto GetOutput(std::span<byte> data_out, size_t* write_index) {
@@ -90,7 +90,7 @@
     memcpy(data_out.data() + *write_index, src.data(), copy_size);
     *write_index += copy_size;
 
-    return (copy_size == src.size_bytes()) ? Status::Ok()
+    return (copy_size == src.size_bytes()) ? OkStatus()
                                            : Status::ResourceExhausted();
   };
 }
@@ -161,7 +161,7 @@
   size_t entry_bytes = info.preamble_bytes + info.data_bytes;
   read_idx_ = IncrementIndex(read_idx_, entry_bytes);
   entry_count_--;
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status PrefixedEntryRingBuffer::Dering() {
@@ -170,7 +170,7 @@
   }
   // Check if by luck we're already deringed.
   if (read_idx_ == 0) {
-    return Status::Ok();
+    return OkStatus();
   }
 
   auto buffer_span = std::span(buffer_, buffer_bytes_);
@@ -184,7 +184,7 @@
   }
   write_idx_ -= read_idx_;
   read_idx_ = 0;
-  return Status::Ok();
+  return OkStatus();
 }
 
 size_t PrefixedEntryRingBuffer::FrontEntryDataSizeBytes() {
diff --git a/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc b/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc
index 6469f42..18382d3 100644
--- a/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc
+++ b/pw_ring_buffer/prefixed_entry_ring_buffer_test.cc
@@ -83,7 +83,7 @@
   // out and happen to see a previous value.
   size_t read_size = 500U;
 
-  EXPECT_EQ(ring.SetBuffer(test_buffer), Status::Ok());
+  EXPECT_EQ(ring.SetBuffer(test_buffer), OkStatus());
 
   EXPECT_EQ(ring.EntryCount(), 0u);
   EXPECT_EQ(ring.PopFront(), Status::OutOfRange());
@@ -115,12 +115,12 @@
     ASSERT_EQ(ring.FrontEntryTotalSizeBytes(), 0u);
 
     ASSERT_EQ(ring.PushBack(std::span(single_entry_data, data_size), byte(i)),
-              Status::Ok());
+              OkStatus());
     ASSERT_EQ(ring.FrontEntryDataSizeBytes(), data_size);
     ASSERT_EQ(ring.FrontEntryTotalSizeBytes(), single_entry_total_size);
 
     read_size = 500U;
-    ASSERT_EQ(ring.PeekFront(read_buffer, &read_size), Status::Ok());
+    ASSERT_EQ(ring.PeekFront(read_buffer, &read_size), OkStatus());
     ASSERT_EQ(read_size, data_size);
 
     // ASSERT_THAT(std::span(expect_buffer).last(data_size),
@@ -131,10 +131,9 @@
               0);
 
     read_size = 500U;
-    ASSERT_EQ(ring.PeekFrontWithPreamble(read_buffer, &read_size),
-              Status::Ok());
+    ASSERT_EQ(ring.PeekFrontWithPreamble(read_buffer, &read_size), OkStatus());
     ASSERT_EQ(read_size, single_entry_total_size);
-    ASSERT_EQ(ring.PopFront(), Status::Ok());
+    ASSERT_EQ(ring.PopFront(), OkStatus());
 
     if (user_data) {
       expect_buffer[0] = byte(i);
@@ -168,7 +167,7 @@
   PrefixedEntryRingBuffer ring(user_data);
   byte test_buffer[single_entry_test_buffer_size];
 
-  EXPECT_EQ(ring.SetBuffer(test_buffer), Status::Ok());
+  EXPECT_EQ(ring.SetBuffer(test_buffer), OkStatus());
   EXPECT_EQ(ring.EntryCount(), 0u);
 
   constexpr size_t data_size = sizeof(single_entry_data) - (user_data ? 1 : 0);
@@ -182,7 +181,7 @@
     for (j = 0; j < kSingleEntryCycles; j++) {
       memset(write_buffer, j + seed, sizeof(write_buffer));
 
-      ASSERT_EQ(ring.PushBack(write_buffer), Status::Ok());
+      ASSERT_EQ(ring.PushBack(write_buffer), OkStatus());
 
       size_t expected_count = (j < kCountingUpMaxExpectedEntries)
                                   ? j + 1
@@ -196,11 +195,11 @@
       byte read_buffer[sizeof(write_buffer)];
       size_t read_size;
       memset(write_buffer, fill_val + j, sizeof(write_buffer));
-      ASSERT_EQ(ring.PeekFront(read_buffer, &read_size), Status::Ok());
+      ASSERT_EQ(ring.PeekFront(read_buffer, &read_size), OkStatus());
 
       ASSERT_EQ(memcmp(write_buffer, read_buffer, data_size), 0);
 
-      ASSERT_EQ(ring.PopFront(), Status::Ok());
+      ASSERT_EQ(ring.PopFront(), OkStatus());
     }
   }
 }
@@ -222,13 +221,13 @@
   PrefixedEntryRingBuffer ring(user_data);
   byte test_buffer[single_entry_test_buffer_size];
 
-  EXPECT_EQ(ring.SetBuffer(test_buffer), Status::Ok());
+  EXPECT_EQ(ring.SetBuffer(test_buffer), OkStatus());
 
   auto output = [](std::span<const byte> src) -> Status {
     for (byte b : src) {
       read_buffer.push_back(b);
     }
-    return Status::Ok();
+    return OkStatus();
   };
 
   size_t user_preamble_bytes = (user_data ? 1 : 0);
@@ -244,12 +243,12 @@
     ASSERT_EQ(ring.FrontEntryTotalSizeBytes(), 0u);
 
     ASSERT_EQ(ring.PushBack(std::span(single_entry_data, data_size), byte(i)),
-              Status::Ok());
+              OkStatus());
     ASSERT_EQ(ring.FrontEntryDataSizeBytes(), data_size);
     ASSERT_EQ(ring.FrontEntryTotalSizeBytes(), single_entry_total_size);
 
     read_buffer.clear();
-    ASSERT_EQ(ring.PeekFront(output), Status::Ok());
+    ASSERT_EQ(ring.PeekFront(output), OkStatus());
     ASSERT_EQ(read_buffer.size(), data_size);
 
     ASSERT_EQ(memcmp(std::span(expect_buffer).last(data_size).data(),
@@ -258,9 +257,9 @@
               0);
 
     read_buffer.clear();
-    ASSERT_EQ(ring.PeekFrontWithPreamble(output), Status::Ok());
+    ASSERT_EQ(ring.PeekFrontWithPreamble(output), OkStatus());
     ASSERT_EQ(read_buffer.size(), single_entry_total_size);
-    ASSERT_EQ(ring.PopFront(), Status::Ok());
+    ASSERT_EQ(ring.PopFront(), OkStatus());
 
     if (user_data) {
       expect_buffer[0] = byte(i);
@@ -293,7 +292,7 @@
   PrefixedEntryRingBuffer ring;
 
   byte test_buffer[kTestBufferSize];
-  EXPECT_EQ(ring.SetBuffer(test_buffer), Status::Ok());
+  EXPECT_EQ(ring.SetBuffer(test_buffer), OkStatus());
 
   // Entry data is entry size - preamble (single byte in this case).
   byte single_entry_buffer[kEntrySizeBytes - 1u];
@@ -336,7 +335,7 @@
     EXPECT_EQ(ring.EntryCount(), kTotalEntryCount);
     EXPECT_EQ(expected_result.size(), ring.TotalUsedBytes());
 
-    ASSERT_EQ(ring.Dering(), Status::Ok());
+    ASSERT_EQ(ring.Dering(), OkStatus());
 
     // Check values after doing the dering.
     EXPECT_EQ(ring.EntryCount(), kTotalEntryCount);
@@ -348,11 +347,11 @@
       for (byte b : src) {
         actual_result.push_back(b);
       }
-      return Status::Ok();
+      return OkStatus();
     };
     while (ring.EntryCount()) {
-      ASSERT_EQ(ring.PeekFrontWithPreamble(output), Status::Ok());
-      ASSERT_EQ(ring.PopFront(), Status::Ok());
+      ASSERT_EQ(ring.PeekFrontWithPreamble(output), OkStatus());
+      ASSERT_EQ(ring.PopFront(), OkStatus());
     }
 
     // Ensure the actual result out of the ring buffer matches our manually
@@ -405,7 +404,7 @@
 TEST(PrefixedEntryRingBuffer, TryPushBack) {
   PrefixedEntryRingBuffer ring;
   byte test_buffer[kTestBufferSize];
-  EXPECT_EQ(ring.SetBuffer(test_buffer), Status::Ok());
+  EXPECT_EQ(ring.SetBuffer(test_buffer), OkStatus());
 
   // Fill up the ring buffer with a constant.
   int total_items = 0;
@@ -428,7 +427,7 @@
 
   // Fill up the ring buffer with a constant.
   for (int i = 0; i < total_items; ++i) {
-    EXPECT_EQ(PushBack<int>(ring, 100), Status::Ok());
+    EXPECT_EQ(PushBack<int>(ring, 100), OkStatus());
   }
   EXPECT_EQ(PeekFront<int>(ring), 100);
 }
diff --git a/pw_rpc/base_server_writer.cc b/pw_rpc/base_server_writer.cc
index 1d9ea4d..478c67a 100644
--- a/pw_rpc/base_server_writer.cc
+++ b/pw_rpc/base_server_writer.cc
@@ -94,7 +94,7 @@
   }
 
   call_.channel().Release(response_);
-  return Status::Ok();
+  return OkStatus();
 }
 
 void BaseServerWriter::Close() {
diff --git a/pw_rpc/base_server_writer_test.cc b/pw_rpc/base_server_writer_test.cc
index d5767df..4314cff 100644
--- a/pw_rpc/base_server_writer_test.cc
+++ b/pw_rpc/base_server_writer_test.cc
@@ -122,7 +122,7 @@
   EXPECT_EQ(packet.service_id(), context.kServiceId);
   EXPECT_EQ(packet.method_id(), context.get().method().id());
   EXPECT_TRUE(packet.payload().empty());
-  EXPECT_EQ(packet.status(), Status::Ok());
+  EXPECT_EQ(packet.status(), OkStatus());
 }
 
 TEST(ServerWriter, Close) {
@@ -152,11 +152,11 @@
   FakeServerWriter writer(context.get());
 
   constexpr byte data[] = {byte{0xf0}, byte{0x0d}};
-  ASSERT_EQ(Status::Ok(), writer.Write(data));
+  ASSERT_EQ(OkStatus(), writer.Write(data));
 
   byte encoded[64];
   auto result = context.packet(data).Encode(encoded);
-  ASSERT_EQ(Status::Ok(), result.status());
+  ASSERT_EQ(OkStatus(), result.status());
 
   EXPECT_EQ(result.value().size(), context.output().sent_data().size());
   EXPECT_EQ(
diff --git a/pw_rpc/channel_test.cc b/pw_rpc/channel_test.cc
index a40e591..5e16ee6 100644
--- a/pw_rpc/channel_test.cc
+++ b/pw_rpc/channel_test.cc
@@ -29,7 +29,7 @@
     NameTester(const char* name) : ChannelOutput(name) {}
     std::span<std::byte> AcquireBuffer() override { return {}; }
     Status SendAndReleaseBuffer(std::span<const std::byte>) override {
-      return Status::Ok();
+      return OkStatus();
     }
   };
 
@@ -74,7 +74,7 @@
   EXPECT_EQ(payload.size(), output.buffer().size() - kReservedSize);
   EXPECT_EQ(output.buffer().data() + kReservedSize, payload.data());
 
-  EXPECT_EQ(Status::Ok(), channel.Send(output_buffer, kTestPacket));
+  EXPECT_EQ(OkStatus(), channel.Send(output_buffer, kTestPacket));
 }
 
 TEST(Channel, OutputBuffer_PayloadDoesNotFit_ReportsError) {
@@ -98,7 +98,7 @@
   EXPECT_EQ(payload.size(), output.buffer().size() - kReservedSize);
   EXPECT_EQ(output.buffer().data() + kReservedSize, payload.data());
 
-  EXPECT_EQ(Status::Ok(), channel.Send(output_buffer, kTestPacket));
+  EXPECT_EQ(OkStatus(), channel.Send(output_buffer, kTestPacket));
 }
 
 TEST(Channel, OutputBuffer_ReturnsStatusFromChannelOutputSend) {
diff --git a/pw_rpc/client.cc b/pw_rpc/client.cc
index 07c26ee..b5f3f5d 100644
--- a/pw_rpc/client.cc
+++ b/pw_rpc/client.cc
@@ -79,7 +79,7 @@
       return Status::Unimplemented();
   }
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status Client::RegisterCall(BaseClientCall& call) {
@@ -95,7 +95,7 @@
   }
 
   calls_.push_front(call);
-  return Status::Ok();
+  return OkStatus();
 }
 
 }  // namespace pw::rpc
diff --git a/pw_rpc/client_test.cc b/pw_rpc/client_test.cc
index 3174cfc..9249877 100644
--- a/pw_rpc/client_test.cc
+++ b/pw_rpc/client_test.cc
@@ -49,7 +49,7 @@
 
   TestClientCall call(
       &context.channel(), context.kServiceId, context.kMethodId);
-  EXPECT_EQ(context.SendResponse(Status::Ok(), {}), Status::Ok());
+  EXPECT_EQ(context.SendResponse(OkStatus(), {}), OkStatus());
 
   EXPECT_TRUE(call.invoked());
 }
@@ -57,7 +57,7 @@
 TEST(Client, ProcessPacket_SendsClientErrorOnUnregisteredCall) {
   ClientContextForTest context;
 
-  EXPECT_EQ(context.SendResponse(Status::OK, {}), Status::NotFound());
+  EXPECT_EQ(context.SendResponse(OkStatus(), {}), Status::NotFound());
 
   ASSERT_EQ(context.output().packet_count(), 1u);
   const Packet& packet = context.output().sent_packet();
diff --git a/pw_rpc/docs.rst b/pw_rpc/docs.rst
index 47eb235..c44b017 100644
--- a/pw_rpc/docs.rst
+++ b/pw_rpc/docs.rst
@@ -109,7 +109,7 @@
                          const foo_bar_Request& request,
                          foo_bar_Response& response) {
       // implementation
-      return pw::Status::Ok();
+      return pw::OkStatus();
     }
 
     void MethodTwo(ServerContext& ctx,
diff --git a/pw_rpc/nanopb/codegen_test.cc b/pw_rpc/nanopb/codegen_test.cc
index c43ccef..5b7241a 100644
--- a/pw_rpc/nanopb/codegen_test.cc
+++ b/pw_rpc/nanopb/codegen_test.cc
@@ -56,8 +56,8 @@
 TEST(NanopbCodegen, Server_InvokeUnaryRpc) {
   PW_NANOPB_TEST_METHOD_CONTEXT(test::TestService, TestRpc) context;
 
-  EXPECT_EQ(Status::Ok(),
-            context.call({.integer = 123, .status_code = Status::Ok().code()}));
+  EXPECT_EQ(OkStatus(),
+            context.call({.integer = 123, .status_code = OkStatus().code()}));
 
   EXPECT_EQ(124, context.response().value);
 
@@ -77,7 +77,7 @@
   EXPECT_TRUE(context.responses().empty());
   EXPECT_EQ(0u, context.total_responses());
 
-  context.call({.integer = 4, .status_code = Status::Ok().code()});
+  context.call({.integer = 4, .status_code = OkStatus().code()});
 
   ASSERT_EQ(4u, context.responses().size());
   ASSERT_EQ(4u, context.total_responses());
@@ -86,7 +86,7 @@
     EXPECT_EQ(context.responses()[i].number, i);
   }
 
-  EXPECT_EQ(Status::Ok().code(), context.status());
+  EXPECT_EQ(OkStatus().code(), context.status());
 }
 
 TEST(NanopbCodegen,
@@ -152,9 +152,9 @@
   EXPECT_EQ(sent_proto.integer, 123);
 
   PW_ENCODE_PB(pw_rpc_test_TestResponse, response, .value = 42);
-  context.SendResponse(Status::Ok(), response);
+  context.SendResponse(OkStatus(), response);
   ASSERT_EQ(handler.responses_received(), 1u);
-  EXPECT_EQ(handler.last_status(), Status::Ok());
+  EXPECT_EQ(handler.last_status(), OkStatus());
   EXPECT_EQ(handler.last_response().value, 42);
 }
 
@@ -177,7 +177,7 @@
 
   PW_ENCODE_PB(
       pw_rpc_test_TestStreamResponse, response, .chunk = {}, .number = 11u);
-  context.SendResponse(Status::Ok(), response);
+  context.SendResponse(OkStatus(), response);
   ASSERT_EQ(handler.responses_received(), 1u);
   EXPECT_EQ(handler.last_response().number, 11u);
 
diff --git a/pw_rpc/nanopb/docs.rst b/pw_rpc/nanopb/docs.rst
index 5e3b0d2..0d61766 100644
--- a/pw_rpc/nanopb/docs.rst
+++ b/pw_rpc/nanopb/docs.rst
@@ -114,7 +114,7 @@
   Writes a single response message to the stream. The returned status indicates
   whether the write was successful.
 
-.. cpp:function:: void ServerWriter::Finish(Status status = Status::OK)
+.. cpp:function:: void ServerWriter::Finish(Status status = OkStatus())
 
   Closes the stream and sends back the RPC's overall status to the client.
 
diff --git a/pw_rpc/nanopb/echo_service_test.cc b/pw_rpc/nanopb/echo_service_test.cc
index 31fbb7f..11a0608 100644
--- a/pw_rpc/nanopb/echo_service_test.cc
+++ b/pw_rpc/nanopb/echo_service_test.cc
@@ -21,13 +21,13 @@
 
 TEST(EchoService, Echo_EchoesRequestMessage) {
   PW_NANOPB_TEST_METHOD_CONTEXT(EchoService, Echo) context;
-  ASSERT_EQ(context.call(_pw_rpc_EchoMessage{"Hello, world"}), Status::Ok());
+  ASSERT_EQ(context.call(_pw_rpc_EchoMessage{"Hello, world"}), OkStatus());
   EXPECT_STREQ(context.response().msg, "Hello, world");
 }
 
 TEST(EchoService, Echo_EmptyRequest) {
   PW_NANOPB_TEST_METHOD_CONTEXT(EchoService, Echo) context;
-  ASSERT_EQ(context.call({.msg = {}}), Status::Ok());
+  ASSERT_EQ(context.call({.msg = {}}), OkStatus());
   EXPECT_STREQ(context.response().msg, "");
 }
 
diff --git a/pw_rpc/nanopb/nanopb_client_call_test.cc b/pw_rpc/nanopb/nanopb_client_call_test.cc
index 4659b95..171ae28 100644
--- a/pw_rpc/nanopb/nanopb_client_call_test.cc
+++ b/pw_rpc/nanopb/nanopb_client_call_test.cc
@@ -87,10 +87,10 @@
       context.channel(), {.integer = 123, .status_code = 0}, handler);
 
   PW_ENCODE_PB(pw_rpc_test_TestResponse, response, .value = 42);
-  context.SendResponse(Status::Ok(), response);
+  context.SendResponse(OkStatus(), response);
 
   ASSERT_EQ(handler.responses_received(), 1u);
-  EXPECT_EQ(handler.last_status(), Status::Ok());
+  EXPECT_EQ(handler.last_status(), OkStatus());
   EXPECT_EQ(handler.last_response().value, 42);
 }
 
@@ -103,7 +103,7 @@
 
   constexpr std::byte bad_payload[]{
       std::byte{0xab}, std::byte{0xcd}, std::byte{0xef}};
-  context.SendResponse(Status::Ok(), bad_payload);
+  context.SendResponse(OkStatus(), bad_payload);
 
   EXPECT_EQ(handler.responses_received(), 0u);
   EXPECT_EQ(handler.rpc_error(), Status::DataLoss());
@@ -168,19 +168,19 @@
       context.channel(), {.integer = 71, .status_code = 0}, handler);
 
   PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r1, .chunk = {}, .number = 11u);
-  context.SendResponse(Status::Ok(), r1);
+  context.SendResponse(OkStatus(), r1);
   EXPECT_TRUE(handler.active());
   EXPECT_EQ(handler.responses_received(), 1u);
   EXPECT_EQ(handler.last_response().number, 11u);
 
   PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r2, .chunk = {}, .number = 22u);
-  context.SendResponse(Status::Ok(), r2);
+  context.SendResponse(OkStatus(), r2);
   EXPECT_TRUE(handler.active());
   EXPECT_EQ(handler.responses_received(), 2u);
   EXPECT_EQ(handler.last_response().number, 22u);
 
   PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r3, .chunk = {}, .number = 33u);
-  context.SendResponse(Status::Ok(), r3);
+  context.SendResponse(OkStatus(), r3);
   EXPECT_TRUE(handler.active());
   EXPECT_EQ(handler.responses_received(), 3u);
   EXPECT_EQ(handler.last_response().number, 33u);
@@ -195,11 +195,11 @@
       context.channel(), {.integer = 71, .status_code = 0}, handler);
 
   PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r1, .chunk = {}, .number = 11u);
-  context.SendResponse(Status::Ok(), r1);
+  context.SendResponse(OkStatus(), r1);
   EXPECT_TRUE(handler.active());
 
   PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r2, .chunk = {}, .number = 22u);
-  context.SendResponse(Status::Ok(), r2);
+  context.SendResponse(OkStatus(), r2);
   EXPECT_TRUE(handler.active());
 
   // Close the stream.
@@ -207,7 +207,7 @@
                      Status::NotFound());
 
   PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r3, .chunk = {}, .number = 33u);
-  context.SendResponse(Status::Ok(), r3);
+  context.SendResponse(OkStatus(), r3);
   EXPECT_FALSE(handler.active());
 
   EXPECT_EQ(handler.responses_received(), 2u);
@@ -222,19 +222,19 @@
       context.channel(), {.integer = 71, .status_code = 0}, handler);
 
   PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r1, .chunk = {}, .number = 11u);
-  context.SendResponse(Status::Ok(), r1);
+  context.SendResponse(OkStatus(), r1);
   EXPECT_TRUE(handler.active());
   EXPECT_EQ(handler.responses_received(), 1u);
   EXPECT_EQ(handler.last_response().number, 11u);
 
   constexpr std::byte bad_payload[]{
       std::byte{0xab}, std::byte{0xcd}, std::byte{0xef}};
-  context.SendResponse(Status::Ok(), bad_payload);
+  context.SendResponse(OkStatus(), bad_payload);
   EXPECT_EQ(handler.responses_received(), 1u);
   EXPECT_EQ(handler.rpc_error(), Status::DataLoss());
 
   PW_ENCODE_PB(pw_rpc_test_TestStreamResponse, r2, .chunk = {}, .number = 22u);
-  context.SendResponse(Status::Ok(), r2);
+  context.SendResponse(OkStatus(), r2);
   EXPECT_TRUE(handler.active());
   EXPECT_EQ(handler.responses_received(), 2u);
   EXPECT_EQ(handler.last_response().number, 22u);
diff --git a/pw_rpc/nanopb/nanopb_common.cc b/pw_rpc/nanopb/nanopb_common.cc
index d3339c6..4f90e1b 100644
--- a/pw_rpc/nanopb/nanopb_common.cc
+++ b/pw_rpc/nanopb/nanopb_common.cc
@@ -41,7 +41,7 @@
     return StatusWithSize::Internal();
   }
 
-  return StatusWithSize::Ok(output.bytes_written);
+  return StatusWithSize(output.bytes_written);
 }
 
 bool NanopbMethodSerde::Decode(NanopbMessageDescriptor fields,
diff --git a/pw_rpc/nanopb/nanopb_method_test.cc b/pw_rpc/nanopb/nanopb_method_test.cc
index 98e3d54..e0e4a76 100644
--- a/pw_rpc/nanopb/nanopb_method_test.cc
+++ b/pw_rpc/nanopb/nanopb_method_test.cc
@@ -185,12 +185,12 @@
 
   method.Invoke(context.get(), context.packet({}));
 
-  EXPECT_EQ(Status::Ok(), last_writer.Write({.value = 100}));
+  EXPECT_EQ(OkStatus(), last_writer.Write({.value = 100}));
 
   PW_ENCODE_PB(pw_rpc_test_TestResponse, payload, .value = 100);
   std::array<byte, 128> encoded_response = {};
   auto encoded = context.packet(payload).Encode(encoded_response);
-  ASSERT_EQ(Status::Ok(), encoded.status());
+  ASSERT_EQ(OkStatus(), encoded.status());
 
   ASSERT_EQ(encoded.value().size(), context.output().sent_data().size());
   EXPECT_EQ(0,
@@ -225,12 +225,12 @@
   // Verify that the encoded size of a packet with an empty payload is correct.
   std::array<byte, 128> encoded_response = {};
   auto encoded = context.packet({}).Encode(encoded_response);
-  ASSERT_EQ(Status::Ok(), encoded.status());
+  ASSERT_EQ(OkStatus(), encoded.status());
   ASSERT_EQ(kNoPayloadPacketSize, encoded.value().size());
 
   method.Invoke(context.get(), context.packet({}));
 
-  EXPECT_EQ(Status::Ok(), last_writer.Write({}));  // Barely fits
+  EXPECT_EQ(OkStatus(), last_writer.Write({}));  // Barely fits
   EXPECT_EQ(Status::Internal(), last_writer.Write({.value = 1}));  // Too big
 }
 
diff --git a/pw_rpc/nanopb/public/pw_rpc/echo_service_nanopb.h b/pw_rpc/nanopb/public/pw_rpc/echo_service_nanopb.h
index 127c712..7e64895 100644
--- a/pw_rpc/nanopb/public/pw_rpc/echo_service_nanopb.h
+++ b/pw_rpc/nanopb/public/pw_rpc/echo_service_nanopb.h
@@ -25,7 +25,7 @@
               const pw_rpc_EchoMessage& request,
               pw_rpc_EchoMessage& response) {
     std::strncpy(response.msg, request.msg, sizeof(response.msg));
-    return Status::Ok();
+    return OkStatus();
   }
 };
 
diff --git a/pw_rpc/nanopb/public/pw_rpc/nanopb_test_method_context.h b/pw_rpc/nanopb/public/pw_rpc/nanopb_test_method_context.h
index 08572e6..ba2e482 100644
--- a/pw_rpc/nanopb/public/pw_rpc/nanopb_test_method_context.h
+++ b/pw_rpc/nanopb/public/pw_rpc/nanopb_test_method_context.h
@@ -36,7 +36,7 @@
 // struct can be accessed via context.response().
 //
 //   PW_NANOPB_TEST_METHOD_CONTEXT(my::CoolService, TheMethod) context;
-//   EXPECT_EQ(Status::Ok(), context.call({.some_arg = 123}));
+//   EXPECT_EQ(OkStatus(), context.call({.some_arg = 123}));
 //   EXPECT_EQ(500, context.response().some_response_value);
 //
 // For a server streaming RPC, context.call(request) invokes the method. As in a
@@ -47,7 +47,7 @@
 //   context.call({.some_arg = 123});
 //
 //   EXPECT_TRUE(context.done());  // Check that the RPC completed
-//   EXPECT_EQ(Status::Ok(), context.status());  // Check the status
+//   EXPECT_EQ(OkStatus(), context.status());  // Check the status
 //
 //   EXPECT_EQ(3u, context.responses().size());
 //   EXPECT_EQ(123, context.responses()[0].value); // check individual responses
@@ -278,7 +278,7 @@
   PW_ASSERT(buffer.data() == buffer_.data());
 
   if (buffer.empty()) {
-    return Status::Ok();
+    return OkStatus();
   }
 
   Result<internal::Packet> result = internal::Packet::FromBuffer(buffer);
@@ -301,7 +301,7 @@
     default:
       PW_CRASH("Unhandled PacketType");
   }
-  return Status::Ok();
+  return OkStatus();
 }
 
 }  // namespace internal::test::nanopb
diff --git a/pw_rpc/packet_test.cc b/pw_rpc/packet_test.cc
index 9f6d7ea..534fb87 100644
--- a/pw_rpc/packet_test.cc
+++ b/pw_rpc/packet_test.cc
@@ -76,7 +76,7 @@
   Packet packet(PacketType::RESPONSE, 1, 42, 100, kPayload);
 
   auto result = packet.Encode(buffer);
-  ASSERT_EQ(Status::Ok(), result.status());
+  ASSERT_EQ(OkStatus(), result.status());
   ASSERT_EQ(kEncoded.size(), result.value().size());
   EXPECT_EQ(std::memcmp(kEncoded.data(), buffer, kEncoded.size()), 0);
 }
@@ -122,7 +122,7 @@
 
   byte buffer[128];
   Result result = packet.Encode(buffer);
-  ASSERT_EQ(result.status(), Status::Ok());
+  ASSERT_EQ(result.status(), OkStatus());
 
   std::span<byte> packet_data(buffer, result.value().size());
   auto decode_result = Packet::FromBuffer(packet_data);
diff --git a/pw_rpc/public/pw_rpc/internal/base_server_writer.h b/pw_rpc/public/pw_rpc/internal/base_server_writer.h
index d47c3dc..67bf7aa 100644
--- a/pw_rpc/public/pw_rpc/internal/base_server_writer.h
+++ b/pw_rpc/public/pw_rpc/internal/base_server_writer.h
@@ -59,7 +59,7 @@
   uint32_t method_id() const;
 
   // Closes the ServerWriter, if it is open.
-  void Finish(Status status = Status::Ok());
+  void Finish(Status status = OkStatus());
 
  protected:
   constexpr BaseServerWriter() : state_{kClosed} {}
diff --git a/pw_rpc/public/pw_rpc/internal/packet.h b/pw_rpc/public/pw_rpc/internal/packet.h
index c67d86a..9eb58a1 100644
--- a/pw_rpc/public/pw_rpc/internal/packet.h
+++ b/pw_rpc/public/pw_rpc/internal/packet.h
@@ -34,7 +34,7 @@
   // Creates an RPC packet with the channel, service, and method ID of the
   // provided packet.
   static constexpr Packet Response(const Packet& request,
-                                   Status status = Status::Ok()) {
+                                   Status status = OkStatus()) {
     return Packet(PacketType::RESPONSE,
                   request.channel_id(),
                   request.service_id(),
@@ -74,7 +74,7 @@
                    uint32_t service_id,
                    uint32_t method_id,
                    ConstByteSpan payload = {},
-                   Status status = Status::Ok())
+                   Status status = OkStatus())
       : type_(type),
         channel_id_(channel_id),
         service_id_(service_id),
diff --git a/pw_rpc/pw_rpc_private/internal_test_utils.h b/pw_rpc/pw_rpc_private/internal_test_utils.h
index cf1899e..f9b227d 100644
--- a/pw_rpc/pw_rpc_private/internal_test_utils.h
+++ b/pw_rpc/pw_rpc_private/internal_test_utils.h
@@ -42,7 +42,7 @@
 
   Status SendAndReleaseBuffer(std::span<const std::byte> buffer) override {
     if (buffer.empty()) {
-      return Status::Ok();
+      return OkStatus();
     }
 
     PW_ASSERT(buffer.data() == buffer_.data());
@@ -50,7 +50,7 @@
     packet_count_ += 1;
     sent_data_ = buffer;
     Result<internal::Packet> result = internal::Packet::FromBuffer(sent_data_);
-    EXPECT_EQ(Status::Ok(), result.status());
+    EXPECT_EQ(OkStatus(), result.status());
     sent_packet_ = result.value_or(internal::Packet());
     return send_status_;
   }
@@ -108,7 +108,7 @@
                             kServiceId,
                             context_.method().id(),
                             payload,
-                            Status::Ok());
+                            OkStatus());
   }
 
   internal::ServerCall& get() { return context_; }
@@ -146,13 +146,13 @@
   // Sends a packet to be processed by the client. Returns the client's
   // ProcessPacket status.
   Status SendPacket(internal::PacketType type,
-                    Status status = Status::Ok(),
+                    Status status = OkStatus(),
                     std::span<const std::byte> payload = {}) {
     internal::Packet packet(
         type, kChannelId, kServiceId, kMethodId, payload, status);
     std::byte buffer[input_buffer_size];
     Result result = packet.Encode(buffer);
-    EXPECT_EQ(result.status(), Status::Ok());
+    EXPECT_EQ(result.status(), OkStatus());
     return client_.ProcessPacket(result.value_or(ConstByteSpan()));
   }
 
diff --git a/pw_rpc/raw/codegen_test.cc b/pw_rpc/raw/codegen_test.cc
index 722c5de..57e82bd 100644
--- a/pw_rpc/raw/codegen_test.cc
+++ b/pw_rpc/raw/codegen_test.cc
@@ -95,10 +95,10 @@
   protobuf::NestedEncoder encoder(buffer);
   test::TestRequest::Encoder test_request(&encoder);
   test_request.WriteInteger(123);
-  test_request.WriteStatusCode(Status::Ok().code());
+  test_request.WriteStatusCode(OkStatus().code());
 
   auto sws = context.call(encoder.Encode().value());
-  EXPECT_EQ(Status::Ok(), sws.status());
+  EXPECT_EQ(OkStatus(), sws.status());
 
   protobuf::Decoder decoder(context.response());
 
diff --git a/pw_rpc/raw/public/pw_rpc/raw_test_method_context.h b/pw_rpc/raw/public/pw_rpc/raw_test_method_context.h
index 5e13a95..9a4f399 100644
--- a/pw_rpc/raw/public/pw_rpc/raw_test_method_context.h
+++ b/pw_rpc/raw/public/pw_rpc/raw_test_method_context.h
@@ -35,7 +35,7 @@
 // struct can be accessed via context.response().
 //
 //   PW_RAW_TEST_METHOD_CONTEXT(my::CoolService, TheMethod) context;
-//   EXPECT_EQ(Status::Ok(), context.call(encoded_request).status());
+//   EXPECT_EQ(OkStatus(), context.call(encoded_request).status());
 //   EXPECT_EQ(0,
 //             std::memcmp(encoded_response,
 //                         context.response().data(),
@@ -49,7 +49,7 @@
 //   context.call(encoded_response);
 //
 //   EXPECT_TRUE(context.done());  // Check that the RPC completed
-//   EXPECT_EQ(Status::Ok(), context.status());  // Check the status
+//   EXPECT_EQ(OkStatus(), context.status());  // Check the status
 //
 //   EXPECT_EQ(3u, context.responses().size());
 //   ByteSpan& response = context.responses()[0];  // check individual responses
@@ -273,7 +273,7 @@
   PW_ASSERT(buffer.data() == packet_buffer_.data());
 
   if (buffer.empty()) {
-    return Status::Ok();
+    return OkStatus();
   }
 
   Result<internal::Packet> result = internal::Packet::FromBuffer(buffer);
@@ -299,7 +299,7 @@
     default:
       PW_CRASH("Unhandled PacketType");
   }
-  return Status::Ok();
+  return OkStatus();
 }
 
 }  // namespace internal::test::raw
diff --git a/pw_rpc/raw/raw_method_test.cc b/pw_rpc/raw/raw_method_test.cc
index 0008222..c72dcfe 100644
--- a/pw_rpc/raw/raw_method_test.cc
+++ b/pw_rpc/raw/raw_method_test.cc
@@ -143,7 +143,7 @@
   protobuf::Decoder decoder(response.payload());
   ASSERT_TRUE(decoder.Next().ok());
   int64_t value;
-  EXPECT_EQ(decoder.ReadInt64(&value), Status::Ok());
+  EXPECT_EQ(decoder.ReadInt64(&value), OkStatus());
   EXPECT_EQ(value, 461);
 }
 
@@ -177,7 +177,7 @@
   constexpr auto data = bytes::Array<0x0d, 0x06, 0xf0, 0x0d>();
   std::memcpy(buffer.data(), data.data(), data.size());
 
-  EXPECT_EQ(last_writer.Write(buffer.first(data.size())), Status::Ok());
+  EXPECT_EQ(last_writer.Write(buffer.first(data.size())), OkStatus());
 
   const internal::Packet& packet = context.output().sent_packet();
   EXPECT_EQ(packet.type(), internal::PacketType::RESPONSE);
@@ -185,7 +185,7 @@
   EXPECT_EQ(packet.service_id(), context.kServiceId);
   EXPECT_EQ(packet.method_id(), context.get().method().id());
   EXPECT_EQ(std::memcmp(packet.payload().data(), data.data(), data.size()), 0);
-  EXPECT_EQ(packet.status(), Status::Ok());
+  EXPECT_EQ(packet.status(), OkStatus());
 }
 
 TEST(RawServerWriter, Write_SendsExternalBuffer) {
@@ -195,7 +195,7 @@
   method.Invoke(context.get(), context.packet({}));
 
   constexpr auto data = bytes::Array<0x0d, 0x06, 0xf0, 0x0d>();
-  EXPECT_EQ(last_writer.Write(data), Status::Ok());
+  EXPECT_EQ(last_writer.Write(data), OkStatus());
 
   const internal::Packet& packet = context.output().sent_packet();
   EXPECT_EQ(packet.type(), internal::PacketType::RESPONSE);
@@ -203,7 +203,7 @@
   EXPECT_EQ(packet.service_id(), context.kServiceId);
   EXPECT_EQ(packet.method_id(), context.get().method().id());
   EXPECT_EQ(std::memcmp(packet.payload().data(), data.data(), data.size()), 0);
-  EXPECT_EQ(packet.status(), Status::Ok());
+  EXPECT_EQ(packet.status(), OkStatus());
 }
 
 TEST(RawServerWriter, Write_Closed_ReturnsFailedPrecondition) {
diff --git a/pw_rpc/raw/raw_method_union_test.cc b/pw_rpc/raw/raw_method_union_test.cc
index 77cfd5d..0a67d65 100644
--- a/pw_rpc/raw/raw_method_union_test.cc
+++ b/pw_rpc/raw/raw_method_union_test.cc
@@ -118,7 +118,7 @@
   protobuf::Decoder decoder(response.payload());
   ASSERT_TRUE(decoder.Next().ok());
   int64_t value;
-  EXPECT_EQ(decoder.ReadInt64(&value), Status::Ok());
+  EXPECT_EQ(decoder.ReadInt64(&value), OkStatus());
   EXPECT_EQ(value, 461);
 }
 
diff --git a/pw_rpc/server.cc b/pw_rpc/server.cc
index 845a64f..59da7d2 100644
--- a/pw_rpc/server.cc
+++ b/pw_rpc/server.cc
@@ -86,7 +86,7 @@
       internal::Channel temp_channel(packet.channel_id(), &interface);
       temp_channel.Send(
           Packet::ServerError(packet, Status::ResourceExhausted()));
-      return Status::Ok();  // OK since the packet was handled
+      return OkStatus();  // OK since the packet was handled
     }
   }
 
@@ -94,7 +94,7 @@
 
   if (method == nullptr) {
     channel->Send(Packet::ServerError(packet, Status::NotFound()));
-    return Status::Ok();
+    return OkStatus();
   }
 
   switch (packet.type()) {
@@ -118,7 +118,7 @@
       PW_LOG_WARN("Unable to handle packet of type %u",
                   unsigned(packet.type()));
   }
-  return Status::Ok();
+  return OkStatus();
 }
 
 std::tuple<Service*, const internal::Method*> Server::FindMethod(
diff --git a/pw_rpc/server_test.cc b/pw_rpc/server_test.cc
index e109edf..685e4fc 100644
--- a/pw_rpc/server_test.cc
+++ b/pw_rpc/server_test.cc
@@ -82,7 +82,7 @@
       std::span<const byte> payload = kDefaultPayload) {
     auto result = Packet(type, channel_id, service_id, method_id, payload)
                       .Encode(request_buffer_);
-    EXPECT_EQ(Status::Ok(), result.status());
+    EXPECT_EQ(OkStatus(), result.status());
     return result.value_or(ConstByteSpan());
   }
 
@@ -96,7 +96,7 @@
 };
 
 TEST_F(BasicServer, ProcessPacket_ValidMethod_InvokesMethod) {
-  EXPECT_EQ(Status::Ok(),
+  EXPECT_EQ(OkStatus(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::REQUEST, 1, 42, 100), output_));
 
@@ -151,7 +151,7 @@
 }
 
 TEST_F(BasicServer, ProcessPacket_InvalidMethod_NothingIsInvoked) {
-  EXPECT_EQ(Status::Ok(),
+  EXPECT_EQ(OkStatus(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::REQUEST, 1, 42, 101), output_));
 
@@ -160,7 +160,7 @@
 }
 
 TEST_F(BasicServer, ProcessPacket_InvalidMethod_SendsError) {
-  EXPECT_EQ(Status::Ok(),
+  EXPECT_EQ(OkStatus(),
             server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 42, 27),
                                   output_));
 
@@ -173,7 +173,7 @@
 }
 
 TEST_F(BasicServer, ProcessPacket_InvalidService_SendsError) {
-  EXPECT_EQ(Status::Ok(),
+  EXPECT_EQ(OkStatus(),
             server_.ProcessPacket(EncodeRequest(PacketType::REQUEST, 1, 43, 27),
                                   output_));
 
@@ -187,7 +187,7 @@
 
 TEST_F(BasicServer, ProcessPacket_UnassignedChannel_AssignsToAvailableSlot) {
   TestOutput<128> unassigned_output;
-  EXPECT_EQ(Status::Ok(),
+  EXPECT_EQ(OkStatus(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::REQUEST, /*channel_id=*/99, 42, 100),
                 unassigned_output));
@@ -198,7 +198,7 @@
        ProcessPacket_UnassignedChannel_SendsResourceExhaustedIfCannotAssign) {
   channels_[2] = Channel::Create<3>(&output_);  // Occupy only available channel
 
-  EXPECT_EQ(Status::Ok(),
+  EXPECT_EQ(OkStatus(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::REQUEST, /*channel_id=*/99, 42, 27),
                 output_));
@@ -212,7 +212,7 @@
 
 TEST_F(BasicServer, ProcessPacket_Cancel_MethodNotActive_SendsError) {
   // Set up a fake ServerWriter representing an ongoing RPC.
-  EXPECT_EQ(Status::Ok(),
+  EXPECT_EQ(OkStatus(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 1, 42, 100),
                 output_));
@@ -241,7 +241,7 @@
 };
 
 TEST_F(MethodPending, ProcessPacket_Cancel_ClosesServerWriter) {
-  EXPECT_EQ(Status::Ok(),
+  EXPECT_EQ(OkStatus(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 1, 42, 100),
                 output_));
@@ -250,7 +250,7 @@
 }
 
 TEST_F(MethodPending, ProcessPacket_Cancel_SendsStreamEndPacket) {
-  EXPECT_EQ(Status::Ok(),
+  EXPECT_EQ(OkStatus(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 1, 42, 100),
                 output_));
@@ -266,7 +266,7 @@
 
 TEST_F(MethodPending,
        ProcessPacket_ClientError_ClosesServerWriterWithoutStreamEnd) {
-  EXPECT_EQ(Status::OK,
+  EXPECT_EQ(OkStatus(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::CLIENT_ERROR, 1, 42, 100), output_));
 
@@ -275,7 +275,7 @@
 }
 
 TEST_F(MethodPending, ProcessPacket_Cancel_IncorrectChannel) {
-  EXPECT_EQ(Status::Ok(),
+  EXPECT_EQ(OkStatus(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 2, 42, 100),
                 output_));
@@ -286,7 +286,7 @@
 }
 
 TEST_F(MethodPending, ProcessPacket_Cancel_IncorrectService) {
-  EXPECT_EQ(Status::Ok(),
+  EXPECT_EQ(OkStatus(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 1, 43, 100),
                 output_));
@@ -299,7 +299,7 @@
 }
 
 TEST_F(MethodPending, ProcessPacket_CancelIncorrectMethod) {
-  EXPECT_EQ(Status::Ok(),
+  EXPECT_EQ(OkStatus(),
             server_.ProcessPacket(
                 EncodeRequest(PacketType::CANCEL_SERVER_STREAM, 1, 42, 101),
                 output_));
diff --git a/pw_status/public/pw_status/status.h b/pw_status/public/pw_status/status.h
index f9227d7..e142699 100644
--- a/pw_status/public/pw_status/status.h
+++ b/pw_status/public/pw_status/status.h
@@ -248,7 +248,7 @@
 
   // Functions that create a Status with the specified code.
   // clang-format off
-  [[nodiscard]] static constexpr Status Ok() {
+  [[deprecated("Use pw::StatusOk()"), nodiscard]] static constexpr Status Ok() {
     return PW_STATUS_OK;
   }
   [[nodiscard]] static constexpr Status Cancelled() {
diff --git a/pw_status/public/pw_status/status_with_size.h b/pw_status/public/pw_status/status_with_size.h
index 895ab99..e305995 100644
--- a/pw_status/public/pw_status/status_with_size.h
+++ b/pw_status/public/pw_status/status_with_size.h
@@ -100,7 +100,9 @@
 
   // Functions that create a StatusWithSize with the specified status code. For
   // codes other than OK, the size defaults to 0.
-  static constexpr StatusWithSize Ok(size_t size) {
+  [[deprecated(
+      "Use the StatusWithSize constructor")]] static constexpr StatusWithSize
+  Ok(size_t size) {
     return StatusWithSize(size);
   }
   static constexpr StatusWithSize Cancelled(size_t size = 0) {
@@ -152,10 +154,10 @@
     return StatusWithSize(Status::DataLoss(), size);
   }
 
-  // Creates a StatusWithSize with Status::Ok() and a size of 0.
+  // Creates a StatusWithSize with OkStatus() and a size of 0.
   explicit constexpr StatusWithSize() : size_(0) {}
 
-  // Creates a StatusWithSize with Status::Ok() and the provided size.
+  // Creates a StatusWithSize with status OK and the provided size.
   // std::enable_if is used to prevent enum types (e.g. Status) from being used.
   // TODO(hepler): Add debug-only assert that size <= max_size().
   template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
@@ -178,7 +180,7 @@
   // The maximum valid value for size.
   static constexpr size_t max_size() { return kSizeMask; }
 
-  // True if status() == Status::Ok().
+  // True if status() == OkStatus().
   constexpr bool ok() const { return (size_ & kStatusMask) == 0u; }
 
   constexpr Status status() const {
diff --git a/pw_status/status_test.cc b/pw_status/status_test.cc
index eb45758..f6ca551 100644
--- a/pw_status/status_test.cc
+++ b/pw_status/status_test.cc
@@ -178,7 +178,7 @@
 
 TEST(Status, DeprecatedAliases) {
   // TODO(pwbug/268): Remove this test after migrating from these aliases.
-  static_assert(PW_STATUS_OK == Status::OK);
+  static_assert(PW_STATUS_OK == OkStatus());
   static_assert(PW_STATUS_CANCELLED == Status::CANCELLED);
   static_assert(PW_STATUS_UNKNOWN == Status::UNKNOWN);
   static_assert(PW_STATUS_INVALID_ARGUMENT == Status::INVALID_ARGUMENT);
diff --git a/pw_status/status_with_size_test.cc b/pw_status/status_with_size_test.cc
index ef0f1cf..44d6c5a 100644
--- a/pw_status/status_with_size_test.cc
+++ b/pw_status/status_with_size_test.cc
@@ -26,14 +26,14 @@
 TEST(StatusWithSize, Default) {
   StatusWithSize result;
   EXPECT_TRUE(result.ok());
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(Status(), result.status());
   EXPECT_EQ(0u, result.size());
 }
 
 TEST(StatusWithSize, ConstructWithSize) {
   StatusWithSize result = StatusWithSize(456);
   EXPECT_TRUE(result.ok());
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(Status(), result.status());
   EXPECT_EQ(456u, result.size());
 }
 
@@ -45,9 +45,9 @@
 }
 
 TEST(StatusWithSize, ConstructWithOkAndSize) {
-  StatusWithSize result(Status::Ok(), 99);
+  StatusWithSize result(Status(), 99);
   EXPECT_TRUE(result.ok());
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(Status(), result.status());
   EXPECT_EQ(99u, result.size());
 }
 
@@ -99,7 +99,7 @@
 
   result = StatusWithSize(300);
   EXPECT_TRUE(result.ok());
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(Status(), result.status());
   EXPECT_EQ(300u, result.size());
 }
 
@@ -112,7 +112,7 @@
 
 TEST(StatusWithSize, Functions_Status) {
   // clang-format off
-  static_assert(StatusWithSize::Ok(0).status() == Status::Ok());
+  static_assert(StatusWithSize(0).status() == Status());
   static_assert(StatusWithSize::Cancelled().status() == Status::Cancelled());
   static_assert(StatusWithSize::Unknown().status() == Status::Unknown());
   static_assert(StatusWithSize::InvalidArgument().status() == Status::InvalidArgument());
@@ -130,7 +130,7 @@
   static_assert(StatusWithSize::Unavailable().status() == Status::Unavailable());
   static_assert(StatusWithSize::DataLoss().status() == Status::DataLoss());
 
-  static_assert(StatusWithSize::Ok(123).status() == Status::Ok());
+  static_assert(StatusWithSize(123).status() == Status());
   static_assert(StatusWithSize::Cancelled(123).status() == Status::Cancelled());
   static_assert(StatusWithSize::Unknown(123).status() == Status::Unknown());
   static_assert(StatusWithSize::InvalidArgument(123).status() == Status::InvalidArgument());
@@ -170,7 +170,7 @@
 }
 
 TEST(StatusWithSize, Functions_SpecifiedSize) {
-  static_assert(StatusWithSize::Ok(123).size() == 123u);
+  static_assert(StatusWithSize(123).size() == 123u);
   static_assert(StatusWithSize::Cancelled(123).size() == 123u);
   static_assert(StatusWithSize::Unknown(123).size() == 123u);
   static_assert(StatusWithSize::InvalidArgument(123).size() == 123u);
@@ -209,22 +209,22 @@
 }
 
 TEST(StatusWithSize, IsNotError) {
-  static_assert(!StatusWithSize::Ok(0).IsCancelled());
-  static_assert(!StatusWithSize::Ok(0).IsUnknown());
-  static_assert(!StatusWithSize::Ok(0).IsInvalidArgument());
-  static_assert(!StatusWithSize::Ok(0).IsDeadlineExceeded());
-  static_assert(!StatusWithSize::Ok(0).IsNotFound());
-  static_assert(!StatusWithSize::Ok(0).IsAlreadyExists());
-  static_assert(!StatusWithSize::Ok(0).IsPermissionDenied());
-  static_assert(!StatusWithSize::Ok(0).IsUnauthenticated());
-  static_assert(!StatusWithSize::Ok(0).IsResourceExhausted());
-  static_assert(!StatusWithSize::Ok(0).IsFailedPrecondition());
-  static_assert(!StatusWithSize::Ok(0).IsAborted());
-  static_assert(!StatusWithSize::Ok(0).IsOutOfRange());
-  static_assert(!StatusWithSize::Ok(0).IsUnimplemented());
-  static_assert(!StatusWithSize::Ok(0).IsInternal());
-  static_assert(!StatusWithSize::Ok(0).IsUnavailable());
-  static_assert(!StatusWithSize::Ok(0).IsDataLoss());
+  static_assert(!StatusWithSize(0).IsCancelled());
+  static_assert(!StatusWithSize(0).IsUnknown());
+  static_assert(!StatusWithSize(0).IsInvalidArgument());
+  static_assert(!StatusWithSize(0).IsDeadlineExceeded());
+  static_assert(!StatusWithSize(0).IsNotFound());
+  static_assert(!StatusWithSize(0).IsAlreadyExists());
+  static_assert(!StatusWithSize(0).IsPermissionDenied());
+  static_assert(!StatusWithSize(0).IsUnauthenticated());
+  static_assert(!StatusWithSize(0).IsResourceExhausted());
+  static_assert(!StatusWithSize(0).IsFailedPrecondition());
+  static_assert(!StatusWithSize(0).IsAborted());
+  static_assert(!StatusWithSize(0).IsOutOfRange());
+  static_assert(!StatusWithSize(0).IsUnimplemented());
+  static_assert(!StatusWithSize(0).IsInternal());
+  static_assert(!StatusWithSize(0).IsUnavailable());
+  static_assert(!StatusWithSize(0).IsDataLoss());
 }
 }  // namespace
 }  // namespace pw
diff --git a/pw_status/try_test.cc b/pw_status/try_test.cc
index b84258b..a69cd95 100644
--- a/pw_status/try_test.cc
+++ b/pw_status/try_test.cc
@@ -26,7 +26,7 @@
   PW_TRY(ReturnStatus(status));
 
   // Any status other than OK should have already returned.
-  EXPECT_EQ(status, Status::Ok());
+  EXPECT_EQ(status, OkStatus());
   return status;
 }
 
@@ -34,12 +34,12 @@
   PW_TRY(ReturnStatusWithSize(status));
 
   // Any status other than OK should have already returned.
-  EXPECT_EQ(status.status(), Status::Ok());
+  EXPECT_EQ(status.status(), OkStatus());
   return status.status();
 }
 
 TEST(Status, Try_Status) {
-  EXPECT_EQ(TryStatus(Status::Ok()), Status::Ok());
+  EXPECT_EQ(TryStatus(OkStatus()), OkStatus());
 
   // Don't need all the status types, just pick a few not-ok ones.
   EXPECT_EQ(TryStatus(Status::Cancelled()), Status::Cancelled());
@@ -49,8 +49,8 @@
 
 TEST(Status, Try_StatusWithSizeOk) {
   for (size_t i = 0; i < 32; ++i) {
-    StatusWithSize val(Status::Ok(), 0);
-    EXPECT_EQ(TryStatus(val), Status::Ok());
+    StatusWithSize val(OkStatus(), 0);
+    EXPECT_EQ(TryStatus(val), OkStatus());
   }
 }
 
@@ -73,7 +73,7 @@
   PW_TRY_ASSIGN(size_val, ReturnStatusWithSize(status));
 
   // Any status other than OK should have already returned.
-  EXPECT_EQ(status.status(), Status::Ok());
+  EXPECT_EQ(status.status(), OkStatus());
   EXPECT_EQ(size_val, status.size());
   return status.status();
 }
@@ -82,8 +82,8 @@
   size_t size_val = 0;
 
   for (size_t i = 1; i < 32; ++i) {
-    StatusWithSize val(Status::Ok(), i);
-    EXPECT_EQ(TryStatusAssign(size_val, val), Status::Ok());
+    StatusWithSize val(OkStatus(), i);
+    EXPECT_EQ(TryStatusAssign(size_val, val), OkStatus());
     EXPECT_EQ(size_val, i);
   }
 }
@@ -110,15 +110,15 @@
   PW_TRY_WITH_SIZE(ReturnStatus(status));
 
   // Any status other than OK should have already returned.
-  EXPECT_EQ(status, Status::Ok());
+  EXPECT_EQ(status, OkStatus());
 
   StatusWithSize return_val(status, 0u);
   return return_val;
 }
 
 TEST(Status, TryWithSize_StatusOk) {
-  StatusWithSize result = TryStatusWithSize(Status::Ok());
-  EXPECT_EQ(result.status(), Status::Ok());
+  StatusWithSize result = TryStatusWithSize(OkStatus());
+  EXPECT_EQ(result.status(), OkStatus());
   EXPECT_EQ(result.size(), 0u);
 }
 
@@ -130,8 +130,8 @@
 
 TEST(Status, TryWithSize_StatusWithSizeOk) {
   for (size_t i = 0; i < 32; ++i) {
-    StatusWithSize val(Status::Ok(), i);
-    EXPECT_EQ(TryStatusWithSize(val).status(), Status::Ok());
+    StatusWithSize val(OkStatus(), i);
+    EXPECT_EQ(TryStatusWithSize(val).status(), OkStatus());
     EXPECT_EQ(TryStatusWithSize(val).size(), i);
   }
 }
diff --git a/pw_stream/memory_stream.cc b/pw_stream/memory_stream.cc
index 8f7e29e..0a44810 100644
--- a/pw_stream/memory_stream.cc
+++ b/pw_stream/memory_stream.cc
@@ -33,7 +33,7 @@
   std::memcpy(dest_.data() + bytes_written_, data.data(), bytes_to_write);
   bytes_written_ += bytes_to_write;
 
-  return Status::Ok();
+  return OkStatus();
 }
 
 StatusWithSize MemoryReader::DoRead(ByteSpan dest) {
diff --git a/pw_stream/memory_stream_test.cc b/pw_stream/memory_stream_test.cc
index 51c9a38..b4a1395 100644
--- a/pw_stream/memory_stream_test.cc
+++ b/pw_stream/memory_stream_test.cc
@@ -38,7 +38,7 @@
   EXPECT_EQ(memory_writer.bytes_written(), 0u);
   Status status =
       memory_writer.Write(&kExpectedStruct, sizeof(kExpectedStruct));
-  EXPECT_EQ(status, Status::Ok());
+  EXPECT_EQ(status, OkStatus());
   EXPECT_EQ(memory_writer.bytes_written(), sizeof(kExpectedStruct));
 }  // namespace
 
@@ -68,7 +68,7 @@
     for (size_t i = 0; i < sizeof(buffer); ++i) {
       buffer[i] = std::byte(counter++);
     }
-    EXPECT_EQ(memory_writer.Write(std::span(buffer)), Status::Ok());
+    EXPECT_EQ(memory_writer.Write(std::span(buffer)), OkStatus());
   }
 
   EXPECT_GT(memory_writer.ConservativeWriteLimit(), 0u);
@@ -99,7 +99,7 @@
     size_t bytes_to_write =
         std::min(sizeof(buffer), memory_writer.ConservativeWriteLimit());
     EXPECT_EQ(memory_writer.Write(std::span(buffer, bytes_to_write)),
-              Status::Ok());
+              OkStatus());
   }
 
   EXPECT_EQ(memory_writer.ConservativeWriteLimit(), 0u);
@@ -116,7 +116,7 @@
   std::byte buffer[5] = {};
 
   MemoryWriter memory_writer(memory_buffer);
-  EXPECT_EQ(memory_writer.Write(buffer, 0), Status::Ok());
+  EXPECT_EQ(memory_writer.Write(buffer, 0), OkStatus());
   EXPECT_EQ(memory_writer.bytes_written(), 0u);
 }
 
@@ -171,7 +171,7 @@
   // Read exactly the available bytes.
   EXPECT_EQ(memory_reader.ConservativeReadLimit(), dest.size());
   Result<ByteSpan> result = memory_reader.Read(dest);
-  EXPECT_EQ(result.status(), Status::Ok());
+  EXPECT_EQ(result.status(), OkStatus());
   EXPECT_EQ(result.value().size_bytes(), dest.size());
 
   ASSERT_EQ(source.size(), result.value().size_bytes());
@@ -197,7 +197,7 @@
 
   // Read exactly the available bytes.
   Result<ByteSpan> result = memory_reader.Read(dest);
-  EXPECT_EQ(result.status(), Status::Ok());
+  EXPECT_EQ(result.status(), OkStatus());
   EXPECT_EQ(result.value().size_bytes(), 0u);
   EXPECT_EQ(result.value().data(), dest.data());
 
@@ -220,7 +220,7 @@
   // Try and read double the bytes available. Use the pointer/size version of
   // the API.
   Result<ByteSpan> result = memory_reader.Read(dest.data(), dest.size());
-  EXPECT_EQ(result.status(), Status::Ok());
+  EXPECT_EQ(result.status(), OkStatus());
   EXPECT_EQ(result.value().size_bytes(), source.size());
 
   ASSERT_EQ(source.size(), result.value().size_bytes());
@@ -255,7 +255,7 @@
 
     // Try and read a chunk of bytes.
     Result<ByteSpan> result = memory_reader.Read(dest);
-    EXPECT_EQ(result.status(), Status::Ok());
+    EXPECT_EQ(result.status(), OkStatus());
     EXPECT_EQ(result.value().size_bytes(), dest.size());
     EXPECT_EQ(memory_reader.ConservativeReadLimit(),
               read_limit - result.value().size_bytes());
diff --git a/pw_stream/public/pw_stream/null_stream.h b/pw_stream/public/pw_stream/null_stream.h
index eda1209..b3db9c5 100644
--- a/pw_stream/public/pw_stream/null_stream.h
+++ b/pw_stream/public/pw_stream/null_stream.h
@@ -26,7 +26,7 @@
 // Stream writer which quietly drops all of the data, similar to /dev/null.
 class NullWriter final : public Writer {
  private:
-  Status DoWrite(ConstByteSpan) final { return Status::Ok(); }
+  Status DoWrite(ConstByteSpan) final { return OkStatus(); }
 };
 
 // Stream reader which never reads any bytes. Always returns OUT_OF_RANGE, which
diff --git a/pw_stream/public/pw_stream/stream.h b/pw_stream/public/pw_stream/stream.h
index 9bbb069..2fcde9c 100644
--- a/pw_stream/public/pw_stream/stream.h
+++ b/pw_stream/public/pw_stream/stream.h
@@ -74,7 +74,7 @@
   // RESOURCE_EXHAUSTED or OUT_OF_RANGE. As Writer processes/handles enqueued of
   // other contexts write data this number can go up or down for some Writers.
   // Returns zero if, in the current state, Write() would not return
-  // Status::Ok().
+  // OkStatus().
   //
   // Returns std::numeric_limits<size_t>::max() if the implementation has no
   // limits on write sizes.
@@ -132,7 +132,7 @@
   // processes/handles/receives enqueued data or other contexts read data this
   // number can go up or down for some Readers.
   // Returns zero if, in the current state, Read() would not return
-  // Status::Ok().
+  // OkStatus().
   //
   // Returns std::numeric_limits<size_t>::max() if the implementation imposes no
   // limits on read sizes.
diff --git a/pw_stream/socket_stream.cc b/pw_stream/socket_stream.cc
index 1146797..5599307 100644
--- a/pw_stream/socket_stream.cc
+++ b/pw_stream/socket_stream.cc
@@ -48,7 +48,7 @@
   if (conn_fd_ < 0) {
     return Status::Internal();
   }
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status SocketStream::DoWrite(std::span<const std::byte> data) {
@@ -57,7 +57,7 @@
   if (bytes_sent < 0 || static_cast<uint64_t>(bytes_sent) != data.size()) {
     return Status::Internal();
   }
-  return Status::Ok();
+  return OkStatus();
 }
 
 StatusWithSize SocketStream::DoRead(ByteSpan dest) {
@@ -65,7 +65,7 @@
   if (bytes_rcvd < 0) {
     return StatusWithSize::Internal();
   }
-  return StatusWithSize::Ok(bytes_rcvd);
+  return StatusWithSize(bytes_rcvd);
 }
 
-};  // namespace pw::stream
\ No newline at end of file
+};  // namespace pw::stream
diff --git a/pw_string/format_test.cc b/pw_string/format_test.cc
index b7aab52..9aef419 100644
--- a/pw_string/format_test.cc
+++ b/pw_string/format_test.cc
@@ -26,7 +26,7 @@
   char buffer[32];
   auto result = Format(buffer, "-_-");
 
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(OkStatus(), result.status());
   EXPECT_EQ(3u, result.size());
   EXPECT_STREQ("-_-", buffer);
 }
@@ -35,7 +35,7 @@
   char buffer[32];
   auto result = Format(buffer, "%d4%s", 123, "5");
 
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(OkStatus(), result.status());
   EXPECT_EQ(5u, result.size());
   EXPECT_STREQ("12345", buffer);
 }
@@ -81,7 +81,7 @@
   char buffer[8];
   auto result = CallFormatWithVaList(buffer, "Yo%s", "?!");
 
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(OkStatus(), result.status());
   EXPECT_EQ(4u, result.size());
   EXPECT_STREQ("Yo?!", buffer);
 }
diff --git a/pw_string/public/pw_string/format.h b/pw_string/public/pw_string/format.h
index f3aa337..9499eb2 100644
--- a/pw_string/public/pw_string/format.h
+++ b/pw_string/public/pw_string/format.h
@@ -35,7 +35,7 @@
 //
 // The status is
 //
-//   Status::Ok() if the operation succeeded,
+//   OkStatus() if the operation succeeded,
 //   Status::ResourceExhausted() if the buffer was too small to fit the output,
 //   Status::InvalidArgument() if there was a formatting error.
 //
diff --git a/pw_string/public/pw_string/string_builder.h b/pw_string/public/pw_string/string_builder.h
index 425fbfb..7d2c5a4 100644
--- a/pw_string/public/pw_string/string_builder.h
+++ b/pw_string/public/pw_string/string_builder.h
@@ -135,7 +135,7 @@
   // The status from the last operation. May be OK while status() is not OK.
   Status last_status() const { return last_status_; }
 
-  // True if status() is Status::Ok().
+  // True if status() is OkStatus().
   bool ok() const { return status_.ok(); }
 
   // True if the string is empty.
@@ -150,10 +150,10 @@
   // Clears the string and resets its error state.
   void clear();
 
-  // Sets the statuses to Status::Ok();
+  // Sets the statuses to OkStatus();
   void clear_status() {
-    status_ = Status::Ok();
-    last_status_ = Status::Ok();
+    status_ = OkStatus();
+    last_status_ = OkStatus();
   }
 
   // Appends a single character. Stets the status to RESOURCE_EXHAUSTED if the
diff --git a/pw_string/string_builder.cc b/pw_string/string_builder.cc
index 1bc3b1f..60879a9 100644
--- a/pw_string/string_builder.cc
+++ b/pw_string/string_builder.cc
@@ -24,8 +24,8 @@
 void StringBuilder::clear() {
   size_ = 0;
   NullTerminate();
-  status_ = Status::Ok();
-  last_status_ = Status::Ok();
+  status_ = OkStatus();
+  last_status_ = OkStatus();
 }
 
 StringBuilder& StringBuilder::append(size_t count, char ch) {
@@ -70,7 +70,7 @@
   if (buffer_.empty() || chars_to_append != copied) {
     SetErrorStatus(Status::ResourceExhausted());
   } else {
-    last_status_ = Status::Ok();
+    last_status_ = OkStatus();
   }
   return copied;
 }
@@ -79,7 +79,7 @@
   if (new_size <= size_) {
     size_ = new_size;
     NullTerminate();
-    last_status_ = Status::Ok();
+    last_status_ = OkStatus();
   } else {
     SetErrorStatus(Status::OutOfRange());
   }
diff --git a/pw_string/string_builder_test.cc b/pw_string/string_builder_test.cc
index cfef0e7..22378cc 100644
--- a/pw_string/string_builder_test.cc
+++ b/pw_string/string_builder_test.cc
@@ -102,8 +102,8 @@
 
 TEST(StringBuilder, EmptyBuffer_AppendEmpty_ResourceExhausted) {
   StringBuilder sb(std::span<char>{});
-  EXPECT_EQ(Status::Ok(), sb.last_status());
-  EXPECT_EQ(Status::Ok(), sb.status());
+  EXPECT_EQ(OkStatus(), sb.last_status());
+  EXPECT_EQ(OkStatus(), sb.status());
 
   sb << "";
 
@@ -113,8 +113,8 @@
 
 TEST(StringBuilder, Status_StartsOk) {
   StringBuffer<16> sb;
-  EXPECT_EQ(Status::Ok(), sb.status());
-  EXPECT_EQ(Status::Ok(), sb.last_status());
+  EXPECT_EQ(OkStatus(), sb.status());
+  EXPECT_EQ(OkStatus(), sb.last_status());
 }
 
 TEST(StringBuilder, Status_StatusAndLastStatusUpdate) {
@@ -129,7 +129,7 @@
 
   sb << "";
   EXPECT_EQ(Status::OutOfRange(), sb.status());
-  EXPECT_EQ(Status::Ok(), sb.last_status());
+  EXPECT_EQ(OkStatus(), sb.last_status());
 }
 
 TEST(StringBuilder, Status_ClearStatus_SetsStatuesToOk) {
@@ -138,8 +138,8 @@
   EXPECT_EQ(Status::ResourceExhausted(), sb.last_status());
 
   sb.clear_status();
-  EXPECT_EQ(Status::Ok(), sb.status());
-  EXPECT_EQ(Status::Ok(), sb.last_status());
+  EXPECT_EQ(OkStatus(), sb.status());
+  EXPECT_EQ(OkStatus(), sb.last_status());
 }
 
 TEST(StringBuilder, StreamOutput_OutputSelf) {
@@ -153,7 +153,7 @@
 TEST(StringBuilder, PushBack) {
   StringBuffer<12> sb;
   sb.push_back('?');
-  EXPECT_EQ(Status::Ok(), sb.last_status());
+  EXPECT_EQ(OkStatus(), sb.last_status());
   EXPECT_EQ(1u, sb.size());
   EXPECT_STREQ("?", sb.data());
 }
@@ -168,7 +168,7 @@
 TEST(StringBuilder, PopBack) {
   auto sb = MakeString<12>("Welcome!");
   sb.pop_back();
-  EXPECT_EQ(Status::Ok(), sb.last_status());
+  EXPECT_EQ(OkStatus(), sb.last_status());
   EXPECT_EQ(7u, sb.size());
   EXPECT_STREQ("Welcome", sb.data());
 }
@@ -362,7 +362,7 @@
   constexpr std::string_view hello("hello");
 
   buffer << hello;
-  EXPECT_EQ(Status::Ok(), buffer.status());
+  EXPECT_EQ(OkStatus(), buffer.status());
   EXPECT_STREQ("hello", buffer.data());
 }
 
@@ -422,7 +422,7 @@
   two << "";
   ASSERT_STREQ("What heck", two.data());
   ASSERT_EQ(Status::ResourceExhausted(), two.status());
-  ASSERT_EQ(Status::Ok(), two.last_status());
+  ASSERT_EQ(OkStatus(), two.last_status());
 }
 
 TEST(StringBuffer, CopyConstructFromSmaller) {
diff --git a/pw_string/to_string_test.cc b/pw_string/to_string_test.cc
index 2f3608d..347010a 100644
--- a/pw_string/to_string_test.cc
+++ b/pw_string/to_string_test.cc
@@ -101,7 +101,7 @@
 
   auto result = ToString(MyEnum::kLuckyNumber, buffer);
   EXPECT_EQ(1u, result.size());
-  EXPECT_EQ(Status::Ok(), result.status());
+  EXPECT_EQ(OkStatus(), result.status());
   EXPECT_STREQ("8", buffer);
 }
 
diff --git a/pw_string/type_to_string.cc b/pw_string/type_to_string.cc
index 483d10e..4872504 100644
--- a/pw_string/type_to_string.cc
+++ b/pw_string/type_to_string.cc
@@ -190,7 +190,7 @@
   buffer[copied] = '\0';
 
   return StatusWithSize(
-      copied == value.size() ? Status::Ok() : Status::ResourceExhausted(),
+      copied == value.size() ? OkStatus() : Status::ResourceExhausted(),
       copied);
 }
 
diff --git a/pw_sys_io/docs.rst b/pw_sys_io/docs.rst
index cde6a3c..3a1a6c4 100644
--- a/pw_sys_io/docs.rst
+++ b/pw_sys_io/docs.rst
@@ -10,7 +10,7 @@
 
 This facade doesn't dictate any policies on input and output data encoding,
 format, or transmission protocol. It only requires that backends return a
-``Status::OK`` if the operation succeeds. Backends may provide useful error
+``OkStatus()`` if the operation succeeds. Backends may provide useful error
 Status types, but depending on the implementation-specific Status values is
 NOT recommended. Since this facade provides a very vague I/O interface, it
 does NOT provide tests. Backends are expected to provide their own testing to
diff --git a/pw_sys_io/public/pw_sys_io/sys_io.h b/pw_sys_io/public/pw_sys_io/sys_io.h
index 477c719..f93e64a 100644
--- a/pw_sys_io/public/pw_sys_io/sys_io.h
+++ b/pw_sys_io/public/pw_sys_io/sys_io.h
@@ -20,7 +20,7 @@
 //
 // This facade doesn't dictate any policies on input and output data encoding,
 // format, or transmission protocol. It only requires that backends return a
-// Status::Ok() if the operation succeeds. Backends may provide useful error
+// OkStatus() if the operation succeeds. Backends may provide useful error
 // Status types, but depending on the implementation-specific Status values is
 // NOT recommended. Since this facade provides a very vague I/O interface, it
 // does NOT provide tests. Backends are expected to provide their own testing to
@@ -51,14 +51,14 @@
 // This function will block until it either succeeds or fails to read a byte
 // from the pw_sys_io backend.
 //
-// Returns Status::Ok() - A byte was successfully read.
+// Returns OkStatus() - A byte was successfully read.
 //         Status::ResourceExhausted() - if the underlying source vanished.
 Status ReadByte(std::byte* dest);
 
 // Read a single byte from the sys io backend, if available.
 // Implemented by: Backend
 //
-// Returns Status::Ok() - A byte was successfully read, and is in dest.
+// Returns OkStatus() - A byte was successfully read, and is in dest.
 //         Status::Unavailable() - No byte is available to read; try later.
 //         Status::Unimplemented() - Not supported on this target.
 Status TryReadByte(std::byte* dest);
@@ -69,7 +69,7 @@
 // This function will block until it either succeeds or fails to write a byte
 // out the pw_sys_io backend.
 //
-// Returns Status::Ok() if a byte was successfully read.
+// Returns OkStatus() if a byte was successfully read.
 Status WriteByte(std::byte b);
 
 // Write a string out the sys io backend.
@@ -79,7 +79,7 @@
 // backend, adding any platform-specific newline character(s) (these are
 // accounted for in the returned StatusWithSize).
 //
-// Return status is Status::Ok() if all the bytes from the source string were
+// Return status is OkStatus() if all the bytes from the source string were
 // successfully written. In all cases, the number of bytes successfully written
 // are returned as part of the StatusWithSize.
 StatusWithSize WriteLine(const std::string_view& s);
@@ -93,7 +93,7 @@
 // undefined. This function blocks until either an error occurs, or all bytes
 // are successfully read from the backend's ReadByte() implementation.
 //
-// Return status is Status::Ok() if the destination span was successfully
+// Return status is OkStatus() if the destination span was successfully
 // filled. In all cases, the number of bytes successuflly read to the
 // destination span are returned as part of the StatusWithSize.
 StatusWithSize ReadBytes(std::span<std::byte> dest);
@@ -107,7 +107,7 @@
 // either an error occurs, or all bytes are successfully read from the backend's
 // WriteByte() implementation.
 //
-// Return status is Status::Ok() if all the bytes from the source span were
+// Return status is OkStatus() if all the bytes from the source span were
 // successfully written. In all cases, the number of bytes successfully written
 // are returned as part of the StatusWithSize.
 StatusWithSize WriteBytes(std::span<const std::byte> src);
diff --git a/pw_sys_io_arduino/sys_io_arduino.cc b/pw_sys_io_arduino/sys_io_arduino.cc
index fbbc7bc..9e86c73 100644
--- a/pw_sys_io_arduino/sys_io_arduino.cc
+++ b/pw_sys_io_arduino/sys_io_arduino.cc
@@ -31,7 +31,7 @@
 Status ReadByte(std::byte* dest) {
   while (true) {
     if (TryReadByte(dest).ok()) {
-      return Status::Ok();
+      return OkStatus();
     }
   }
 }
@@ -41,7 +41,7 @@
     return Status::Unavailable();
   }
   *dest = static_cast<std::byte>(Serial.read());
-  return Status::Ok();
+  return OkStatus();
 }
 
 // Send a byte over USART1. Since this blocks on every byte, it's rather
@@ -54,7 +54,7 @@
   while (Serial.availableForWrite() < 1) {
   }
   Serial.write((uint8_t)b);
-  return Status::Ok();
+  return OkStatus();
 }
 
 // Writes a string using pw::sys_io, and add newline characters at the end.
diff --git a/pw_sys_io_baremetal_lm3s6965evb/sys_io_baremetal.cc b/pw_sys_io_baremetal_lm3s6965evb/sys_io_baremetal.cc
index 86cc341..1c1ccbc 100644
--- a/pw_sys_io_baremetal_lm3s6965evb/sys_io_baremetal.cc
+++ b/pw_sys_io_baremetal_lm3s6965evb/sys_io_baremetal.cc
@@ -91,7 +91,7 @@
 Status ReadByte(std::byte* dest) {
   while (true) {
     if (TryReadByte(dest).ok()) {
-      return Status::Ok();
+      return OkStatus();
     }
   }
 }
@@ -105,7 +105,7 @@
     return Status::Unavailable();
   }
   *dest = static_cast<std::byte>(uart0.data_register);
-  return Status::Ok();
+  return OkStatus();
 }
 
 // Send a byte over UART0. Since this blocks on every byte, it's rather
@@ -118,7 +118,7 @@
   while (!(uart0.status_flags & kTxFifoEmptyMask)) {
   }
   uart0.data_register = static_cast<uint32_t>(b);
-  return Status::Ok();
+  return OkStatus();
 }
 
 // Writes a string using pw::sys_io, and add newline characters at the end.
diff --git a/pw_sys_io_baremetal_stm32f429/sys_io_baremetal.cc b/pw_sys_io_baremetal_stm32f429/sys_io_baremetal.cc
index 846e34c..915fd67 100644
--- a/pw_sys_io_baremetal_stm32f429/sys_io_baremetal.cc
+++ b/pw_sys_io_baremetal_stm32f429/sys_io_baremetal.cc
@@ -171,7 +171,7 @@
 Status ReadByte(std::byte* dest) {
   while (true) {
     if (TryReadByte(dest).ok()) {
-      return Status::Ok();
+      return OkStatus();
     }
   }
 }
@@ -184,7 +184,7 @@
     return Status::Unavailable();
   }
   *dest = static_cast<std::byte>(usart1.data_register);
-  return Status::Ok();
+  return OkStatus();
 }
 
 // Send a byte over USART1. Since this blocks on every byte, it's rather
@@ -197,7 +197,7 @@
   while (!(usart1.status & kTxRegisterEmpty)) {
   }
   usart1.data_register = static_cast<uint32_t>(b);
-  return Status::Ok();
+  return OkStatus();
 }
 
 // Writes a string using pw::sys_io, and add newline characters at the end.
diff --git a/pw_sys_io_stdio/sys_io.cc b/pw_sys_io_stdio/sys_io.cc
index 53c9d5e..333b18f 100644
--- a/pw_sys_io_stdio/sys_io.cc
+++ b/pw_sys_io_stdio/sys_io.cc
@@ -28,7 +28,7 @@
     return Status::ResourceExhausted();
   }
   *dest = static_cast<std::byte>(value);
-  return Status::Ok();
+  return OkStatus();
 }
 
 Status TryReadByte(std::byte*) {
@@ -40,7 +40,7 @@
   if (std::putchar(static_cast<char>(b)) == EOF) {
     return Status::Internal();
   }
-  return Status::Ok();
+  return OkStatus();
 }
 
 StatusWithSize WriteLine(const std::string_view& s) {
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 426820c..90d119d 100644
--- a/pw_trace_tokenized/public/pw_trace_tokenized/trace_callback.h
+++ b/pw_trace_tokenized/public/pw_trace_tokenized/trace_callback.h
@@ -89,7 +89,7 @@
 // start, allowing buffers to allocate the required amount at the start when
 // necessary.
 //
-// If Status::Ok() is not returned from Start, the events bytes will be skipped.
+// If OkStatus() is not returned from Start, the events bytes will be skipped.
 //
 // NOTE: Called while tracing is locked (which might be a critical section
 // depending on application), so quick/simple operations only. One trace event
diff --git a/pw_trace_tokenized/public/pw_trace_tokenized/trace_tokenized.h b/pw_trace_tokenized/public/pw_trace_tokenized/trace_tokenized.h
index a7e5ca4..56516e3 100644
--- a/pw_trace_tokenized/public/pw_trace_tokenized/trace_tokenized.h
+++ b/pw_trace_tokenized/public/pw_trace_tokenized/trace_tokenized.h
@@ -77,7 +77,7 @@
     }
     head_ = (head_ + 1) % kSize;
     is_empty_ = false;
-    return pw::Status::OK;
+    return pw::OkStatus();
   }
 
   const volatile QueueEventBlock* PeekFront() const {
diff --git a/pw_trace_tokenized/trace_buffer_log.cc b/pw_trace_tokenized/trace_buffer_log.cc
index 3d9e5a6..adaf17a 100644
--- a/pw_trace_tokenized/trace_buffer_log.cc
+++ b/pw_trace_tokenized/trace_buffer_log.cc
@@ -78,7 +78,7 @@
     PW_LOG_INFO("[TRACE] data: %s", line_builder.c_str());
   }
   PW_LOG_INFO("[TRACE] end");
-  return pw::Status::Ok();
+  return pw::OkStatus();
 }
 
 }  // namespace trace
diff --git a/pw_trace_tokenized/trace_buffer_test.cc b/pw_trace_tokenized/trace_buffer_test.cc
index bbe7dc8..410db74f 100644
--- a/pw_trace_tokenized/trace_buffer_test.cc
+++ b/pw_trace_tokenized/trace_buffer_test.cc
@@ -84,7 +84,7 @@
   std::byte value[expected_max_bytes_used];
   size_t bytes_read = 0;
   EXPECT_EQ(buf->PeekFront(std::span<std::byte>(value), &bytes_read),
-            pw::Status::Ok());
+            pw::OkStatus());
 
   // read size is minus 1, since doesn't include varint size
   EXPECT_GE(bytes_read, expected_min_bytes_used - 1);
@@ -123,8 +123,8 @@
     std::byte value[PW_TRACE_BUFFER_MAX_BLOCK_SIZE_BYTES];
     size_t bytes_read = 0;
     EXPECT_EQ(buf->PeekFront(std::span<std::byte>(value), &bytes_read),
-              pw::Status::Ok());
-    EXPECT_EQ(buf->PopFront(), pw::Status::Ok());
+              pw::OkStatus());
+    EXPECT_EQ(buf->PopFront(), pw::OkStatus());
     EXPECT_EQ(*reinterpret_cast<size_t*>(&value[bytes_read - sizeof(size_t)]),
               expected_count);
     expected_count++;
diff --git a/pw_trace_tokenized/trace_test.cc b/pw_trace_tokenized/trace_test.cc
index 5e6d2a4..104dce8 100644
--- a/pw_trace_tokenized/trace_test.cc
+++ b/pw_trace_tokenized/trace_test.cc
@@ -578,7 +578,7 @@
   constexpr size_t kQueueSize = 5;
   pw::trace::internal::TraceQueue<kQueueSize> queue;
   for (size_t i = 0; i < kQueueSize; i++) {
-    EXPECT_EQ(queue.TryPushBack(QUEUE_TESTS_ARGS(i)), pw::Status::OK);
+    EXPECT_EQ(queue.TryPushBack(QUEUE_TESTS_ARGS(i)), pw::OkStatus());
   }
   EXPECT_FALSE(queue.IsEmpty());
   EXPECT_TRUE(queue.IsFull());
@@ -598,7 +598,7 @@
   constexpr size_t kQueueSize = 5;
   pw::trace::internal::TraceQueue<kQueueSize> queue;
   for (size_t i = 0; i < kQueueSize; i++) {
-    EXPECT_EQ(queue.TryPushBack(QUEUE_TESTS_ARGS(i)), pw::Status::OK);
+    EXPECT_EQ(queue.TryPushBack(QUEUE_TESTS_ARGS(i)), pw::OkStatus());
   }
   EXPECT_FALSE(queue.IsEmpty());
   EXPECT_TRUE(queue.IsFull());