diff --git a/CHANGELOG.md b/CHANGELOG.md
index 31320c5..fb41d16 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,9 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+### Changed
+
+- Use `set_` prefix for setters, [PR-2](https://github.com/panda-official/DriftBytes/pull/2)
+
 ## 0.1.0 - 2023-07-20
 
 ### Added
 
 - Python bindings, [PR-1](https://github.com/panda-official/DriftBytes/pull/1)
-- Initial implementationL
+- Initial implementation
diff --git a/README.md b/README.md
index 4f03d68..2fdb542 100644
--- a/README.md
+++ b/README.md
@@ -37,8 +37,8 @@ using drift_bytes::Bytes;
 int main() {
     uint8_t val{42};
     auto bytes = Bytes();
-    bytes.scalar(val);
-    auto new_val = bytes.scalar<uint8_t>();
+    bytes.set_scalar(val);
+    auto new_val = bytes.set_scalar<uint8_t>();
 
     std::cout << new_val << std::endl;
 }
diff --git a/conan/test_package/src/example.cc b/conan/test_package/src/example.cc
index ab4b90c..3571f1e 100644
--- a/conan/test_package/src/example.cc
+++ b/conan/test_package/src/example.cc
@@ -7,7 +7,7 @@ using drift_bytes::Bytes;
 int main() {
   uint8_t val{42};
   auto bytes = Bytes();
-  bytes.scalar(val);
+  bytes.set_scalar(val);
   auto new_val = bytes.scalar<uint8_t>();
 
   std::cout << new_val << std::endl;
diff --git a/drift_bytes/bytes.h b/drift_bytes/bytes.h
index fa0a025..7aace29 100644
--- a/drift_bytes/bytes.h
+++ b/drift_bytes/bytes.h
@@ -56,19 +56,19 @@ class Bytes {
   }
 
   template <typename T>
-  void scalar(const T &t) {
+  void set_scalar(const T &t) {
     cereal::PortableBinaryOutputArchive archive(buffer_);
     archive(t);
   }
 
   template <typename T>
-  void vec(const std::vector<T> &t) {
+  void set_vec(const std::vector<T> &t) {
     cereal::PortableBinaryOutputArchive archive(buffer_);
     archive(t);
   }
 
   template <typename T>
-  void mat(const std::vector<std::vector<T>> &t) {
+  void set_mat(const std::vector<std::vector<T>> &t) {
     cereal::PortableBinaryOutputArchive archive(buffer_);
     archive(t);
   }
diff --git a/python/src/main.cc b/python/src/main.cc
index 46f5f4e..408e0a3 100644
--- a/python/src/main.cc
+++ b/python/src/main.cc
@@ -18,121 +18,123 @@ PYBIND11_MODULE(_drift_bytes, m) {
       .def("get_bool",
            [](drift_bytes::Bytes &bytes) { return bytes.scalar<bool>(); })
       .def("set_bool",
-           [](drift_bytes::Bytes &bytes, bool val) { bytes.scalar(val); })
+           [](drift_bytes::Bytes &bytes, bool val) { bytes.set_scalar(val); })
       .def("get_int8",
            [](drift_bytes::Bytes &bytes) { return bytes.scalar<int8_t>(); })
       .def("set_int8",
-           [](drift_bytes::Bytes &bytes, int8_t val) { bytes.scalar(val); })
+           [](drift_bytes::Bytes &bytes, int8_t val) { bytes.set_scalar(val); })
       .def("get_int16",
            [](drift_bytes::Bytes &bytes) { return bytes.scalar<int16_t>(); })
-      .def("set_int16",
-           [](drift_bytes::Bytes &bytes, int16_t val) { bytes.scalar(val); })
+      .def("set_int16", [](drift_bytes::Bytes &bytes,
+                           int16_t val) { bytes.set_scalar(val); })
       .def("get_int32",
            [](drift_bytes::Bytes &bytes) { return bytes.scalar<int32_t>(); })
-      .def("set_int32",
-           [](drift_bytes::Bytes &bytes, int32_t val) { bytes.scalar(val); })
+      .def("set_int32", [](drift_bytes::Bytes &bytes,
+                           int32_t val) { bytes.set_scalar(val); })
       .def("get_int64",
            [](drift_bytes::Bytes &bytes) { return bytes.scalar<int64_t>(); })
-      .def("set_int64",
-           [](drift_bytes::Bytes &bytes, int64_t val) { bytes.scalar(val); })
+      .def("set_int64", [](drift_bytes::Bytes &bytes,
+                           int64_t val) { bytes.set_scalar(val); })
       .def("get_uint8",
            [](drift_bytes::Bytes &bytes) { return bytes.scalar<uint8_t>(); })
-      .def("set_uint8",
-           [](drift_bytes::Bytes &bytes, uint8_t val) { bytes.scalar(val); })
+      .def("set_uint8", [](drift_bytes::Bytes &bytes,
+                           uint8_t val) { bytes.set_scalar(val); })
       .def("get_uint16",
            [](drift_bytes::Bytes &bytes) { return bytes.scalar<uint16_t>(); })
-      .def("set_uint16",
-           [](drift_bytes::Bytes &bytes, uint16_t val) { bytes.scalar(val); })
+      .def("set_uint16", [](drift_bytes::Bytes &bytes,
+                            uint16_t val) { bytes.set_scalar(val); })
       .def("get_uint32",
            [](drift_bytes::Bytes &bytes) { return bytes.scalar<uint32_t>(); })
-      .def("set_uint32",
-           [](drift_bytes::Bytes &bytes, uint32_t val) { bytes.scalar(val); })
+      .def("set_uint32", [](drift_bytes::Bytes &bytes,
+                            uint32_t val) { bytes.set_scalar(val); })
       .def("get_uint64",
            [](drift_bytes::Bytes &bytes) { return bytes.scalar<uint64_t>(); })
-      .def("set_uint64",
-           [](drift_bytes::Bytes &bytes, uint64_t val) { bytes.scalar(val); })
+      .def("set_uint64", [](drift_bytes::Bytes &bytes,
+                            uint64_t val) { bytes.set_scalar(val); })
       .def("get_float32",
            [](drift_bytes::Bytes &bytes) { return bytes.scalar<float>(); })
       .def("set_float32",
-           [](drift_bytes::Bytes &bytes, float val) { bytes.scalar(val); })
+           [](drift_bytes::Bytes &bytes, float val) { bytes.set_scalar(val); })
       .def("get_float64",
            [](drift_bytes::Bytes &bytes) { return bytes.scalar<double>(); })
       .def("set_float64",
-           [](drift_bytes::Bytes &bytes, double val) { bytes.scalar(val); })
+           [](drift_bytes::Bytes &bytes, double val) { bytes.set_scalar(val); })
       .def(
           "get_string",
           [](drift_bytes::Bytes &bytes) { return bytes.scalar<std::string>(); })
       .def("set_string", [](drift_bytes::Bytes &bytes,
-                            const std::string &val) { bytes.scalar(val); })
+                            const std::string &val) { bytes.set_scalar(val); })
       // Vector types
       .def("get_bool_vec",
            [](drift_bytes::Bytes &bytes) { return bytes.vec<bool>(); })
-      .def("set_bool_vec", [](drift_bytes::Bytes &bytes,
-                              const std::vector<bool> &val) { bytes.vec(val); })
+      .def("set_bool_vec",
+           [](drift_bytes::Bytes &bytes, const std::vector<bool> &val) {
+             bytes.set_vec(val);
+           })
       .def("get_int8_vec",
            [](drift_bytes::Bytes &bytes) { return bytes.vec<int8_t>(); })
       .def("set_int8_vec",
            [](drift_bytes::Bytes &bytes, const std::vector<int8_t> &val) {
-             bytes.vec(val);
+             bytes.set_vec(val);
            })
       .def("get_int16_vec",
            [](drift_bytes::Bytes &bytes) { return bytes.vec<int16_t>(); })
       .def("set_int16_vec",
            [](drift_bytes::Bytes &bytes, const std::vector<int16_t> &val) {
-             bytes.vec(val);
+             bytes.set_vec(val);
            })
       .def("get_int32_vec",
            [](drift_bytes::Bytes &bytes) { return bytes.vec<int32_t>(); })
       .def("set_int32_vec",
            [](drift_bytes::Bytes &bytes, const std::vector<int32_t> &val) {
-             bytes.vec(val);
+             bytes.set_vec(val);
            })
       .def("get_int64_vec",
            [](drift_bytes::Bytes &bytes) { return bytes.vec<int64_t>(); })
       .def("set_int64_vec",
            [](drift_bytes::Bytes &bytes, const std::vector<int64_t> &val) {
-             bytes.vec(val);
+             bytes.set_vec(val);
            })
       .def("get_uint8_vec",
            [](drift_bytes::Bytes &bytes) { return bytes.vec<uint8_t>(); })
       .def("set_uint8_vec",
            [](drift_bytes::Bytes &bytes, const std::vector<uint8_t> &val) {
-             bytes.vec(val);
+             bytes.set_vec(val);
            })
       .def("get_uint16_vec",
            [](drift_bytes::Bytes &bytes) { return bytes.vec<uint16_t>(); })
       .def("set_uint16_vec",
            [](drift_bytes::Bytes &bytes, const std::vector<uint16_t> &val) {
-             bytes.vec(val);
+             bytes.set_vec(val);
            })
       .def("get_uint32_vec",
            [](drift_bytes::Bytes &bytes) { return bytes.vec<uint32_t>(); })
       .def("set_uint32_vec",
            [](drift_bytes::Bytes &bytes, const std::vector<uint32_t> &val) {
-             bytes.vec(val);
+             bytes.set_vec(val);
            })
       .def("get_uint64_vec",
            [](drift_bytes::Bytes &bytes) { return bytes.vec<uint64_t>(); })
       .def("set_uint64_vec",
            [](drift_bytes::Bytes &bytes, const std::vector<uint64_t> &val) {
-             bytes.vec(val);
+             bytes.set_vec(val);
            })
       .def("get_float32_vec",
            [](drift_bytes::Bytes &bytes) { return bytes.vec<float>(); })
       .def("set_float32_vec",
            [](drift_bytes::Bytes &bytes, const std::vector<float> &val) {
-             bytes.vec(val);
+             bytes.set_vec(val);
            })
       .def("get_float64_vec",
            [](drift_bytes::Bytes &bytes) { return bytes.vec<double>(); })
       .def("set_float64_vec",
            [](drift_bytes::Bytes &bytes, const std::vector<double> &val) {
-             bytes.vec(val);
+             bytes.set_vec(val);
            })
       .def("get_string_vec",
            [](drift_bytes::Bytes &bytes) { return bytes.vec<std::string>(); })
       .def("set_string_vec",
            [](drift_bytes::Bytes &bytes, const std::vector<std::string> &val) {
-             bytes.vec(val);
+             bytes.set_vec(val);
            });
 }
diff --git a/tests/bytes_test.cc b/tests/bytes_test.cc
index cfe4cd9..95eed1a 100644
--- a/tests/bytes_test.cc
+++ b/tests/bytes_test.cc
@@ -23,7 +23,7 @@ TEST_CASE("Scalars") {
   CAPTURE(val);
 
   auto bytes = drift_bytes::Bytes();
-  bytes.scalar(val);
+  bytes.set_scalar(val);
 
   decltype(val) new_val;
   new_val = bytes.scalar<decltype(val)>();
@@ -38,7 +38,7 @@ TEST_CASE("Strings") {
   CAPTURE(val);
 
   auto bytes = drift_bytes::Bytes();
-  bytes.scalar(val);
+  bytes.set_scalar(val);
 
   auto new_val = bytes.scalar<decltype(val)>();
 
@@ -52,7 +52,7 @@ TEST_CASE("Vectors") {
   CAPTURE(val);
 
   auto bytes = drift_bytes::Bytes();
-  bytes.vec(val);
+  bytes.set_vec(val);
 
   auto new_val = bytes.vec<int>();
 
@@ -67,7 +67,7 @@ TEST_CASE("Matrices") {
   CAPTURE(val);
 
   auto bytes = drift_bytes::Bytes();
-  bytes.vec(val);
+  bytes.set_vec(val);
 
   auto new_val = bytes.mat<int>();
 
@@ -81,10 +81,10 @@ TEST_CASE("Mixed data") {
   std::vector<std::vector<int>> mat = {{1, 2, 3}, {4, 5, 6}};
 
   auto bytes = drift_bytes::Bytes();
-  bytes.scalar(a);
-  bytes.vec(fvec);
-  bytes.scalar(s);
-  bytes.mat(mat);
+  bytes.set_scalar(a);
+  bytes.set_vec(fvec);
+  bytes.set_scalar(s);
+  bytes.set_mat(mat);
 
   auto new_a = bytes.scalar<decltype(a)>();
   auto new_fvec = bytes.vec<float>();
@@ -101,7 +101,7 @@ TEST_CASE("Serialization") {
   std::vector<std::vector<int>> mat = {{1, 2, 3}, {4, 5, 6}};
 
   auto bytes = drift_bytes::Bytes();
-  bytes.mat(mat);
+  bytes.set_mat(mat);
 
   bytes = drift_bytes::Bytes(bytes.str());