diff --git a/include/glaze/beve/write.hpp b/include/glaze/beve/write.hpp
index 06d953ae83..9cba61b54a 100644
--- a/include/glaze/beve/write.hpp
+++ b/include/glaze/beve/write.hpp
@@ -677,7 +677,7 @@ namespace glz
          static constexpr size_t count_to_write = [] {
             size_t count{};
             invoke_table<N>([&]<size_t I>() {
-               using V = std::remove_cvref_t<refl_t<T, I>>;
+               using V = field_t<T, I>;
 
                if constexpr (std::same_as<V, hidden> || std::same_as<V, skip>) {
                   // do not serialize
@@ -707,7 +707,7 @@ namespace glz
             }();
 
             invoke_table<N>([&]<size_t I>() {
-               using val_t = std::remove_cvref_t<refl_t<T, I>>;
+               using val_t = field_t<T, I>;
 
                if constexpr (std::same_as<val_t, hidden> || std::same_as<val_t, skip>) {
                   return;
@@ -745,7 +745,7 @@ namespace glz
             }();
 
             invoke_table<N>([&]<size_t I>() {
-               using val_t = std::remove_cvref_t<refl_t<T, I>>;
+               using val_t = field_t<T, I>;
 
                if constexpr (std::same_as<val_t, hidden> || std::same_as<val_t, skip>) {
                   return;
diff --git a/include/glaze/core/reflect.hpp b/include/glaze/core/reflect.hpp
index b3dd789c34..2d6ccf4121 100644
--- a/include/glaze/core/reflect.hpp
+++ b/include/glaze/core/reflect.hpp
@@ -207,53 +207,40 @@ namespace glz
       static constexpr auto size = 0;
    };
 
+   // The type of the field before get_member is applied
    template <class T, size_t I>
    using elem_t = reflect<T>::template elem<I>;
 
+   // The type of the field after get_member is applied
    template <class T, size_t I>
    using refl_t = reflect<T>::template type<I>;
-
-   // MSVC requires this specialization, otherwise it will try to instatiate dead `if constexpr` branches for N == 0
-   template <opts Opts, class T>
-   struct object_info;
-
-   template <opts Opts, class T>
-      requires(reflect<T>::size == 0)
-   struct object_info<Opts, T>
-   {
-      static constexpr bool maybe_skipped = false;
-   };
-
+   
+   // The decayed type after get_member is called
+   template <class T, size_t I>
+   using field_t = std::remove_cvref_t<refl_t<T, I>>;
+   
    template <opts Opts, class T>
-      requires(reflect<T>::size > 0)
-   struct object_info<Opts, T>
-   {
-      static constexpr auto N = reflect<T>::size;
-
-      static constexpr bool maybe_skipped = [] {
-         if constexpr (N > 0 && Opts.skip_null_members) {
-            bool found_maybe_skipped{};
-            for_each_short_circuit<N>([&](auto I) {
-               using V = std::remove_cvref_t<refl_t<T, I>>;
-
-               if constexpr (Opts.skip_null_members && detail::null_t<V>) {
-                  found_maybe_skipped = true;
-                  return true; // early exit
-               }
-
-               if constexpr (is_includer<V> || std::same_as<V, hidden> || std::same_as<V, skip>) {
-                  found_maybe_skipped = true;
-                  return true; // early exit
-               }
-               return false; // continue
-            });
-            return found_maybe_skipped;
+   inline constexpr bool maybe_skipped = [] {
+      if constexpr (reflect<T>::size > 0)
+      {
+         constexpr auto N = reflect<T>::size;
+         if constexpr (Opts.skip_null_members) {
+            // if any type could be null then we might skip
+            return []<size_t... I>(std::index_sequence<I...>) {
+               return ((detail::always_skipped<field_t<T, I>> || detail::null_t<field_t<T, I>>) || ...);
+            }(std::make_index_sequence<N>{});
          }
          else {
-            return false;
+            // if we have an always_skipped type then we return true
+            return []<size_t... I>(std::index_sequence<I...>) {
+               return ((detail::always_skipped<field_t<T, I>>) || ...);
+            }(std::make_index_sequence<N>{});
          }
-      }();
-   };
+      }
+      else {
+         return false;
+      }
+   }();
 }
 
 namespace glz::detail
diff --git a/include/glaze/json/write.hpp b/include/glaze/json/write.hpp
index 17a050486f..33ad9fbfe4 100644
--- a/include/glaze/json/write.hpp
+++ b/include/glaze/json/write.hpp
@@ -1584,7 +1584,7 @@ namespace glz
          constexpr auto N = reflect<T>::size;
          std::optional<size_t> fixed = 2 + 16; // {} + extra padding
          for_each_short_circuit<N>([&](auto I) -> bool {
-            using val_t = std::remove_cvref_t<refl_t<T, I>>;
+            using val_t = field_t<T, I>;
             if constexpr (required_padding<val_t>()) {
                fixed.value() += required_padding<val_t>();
                fixed.value() += reflect<T>::keys[I].size() + 2; // key length
@@ -1677,10 +1677,10 @@ namespace glz
                }();
 
                static constexpr auto padding = round_up_to_nearest_16(maximum_key_size<T> + write_padding_bytes);
-               if constexpr (object_info<Opts, T>::maybe_skipped) {
+               if constexpr (maybe_skipped<Opts, T>) {
                   bool first = true;
                   invoke_table<N>([&]<size_t I>() {
-                     using val_t = std::remove_cvref_t<refl_t<T, I>>;
+                     using val_t = field_t<T, I>;
 
                      if constexpr (always_skipped<val_t>) {
                         return;
@@ -1784,7 +1784,7 @@ namespace glz
                      std::memcpy(&b[ix], quoted_key.data(), n);
                      ix += n;
 
-                     using val_t = std::remove_cvref_t<refl_t<T, I>>;
+                     using val_t = field_t<T, I>;
 
                      static constexpr auto check_opts = required_padding<val_t>() ? write_unchecked_on<Opts>() : Opts;
                      if constexpr (reflectable<T>) {
diff --git a/include/glaze/tuplet/tuple.hpp b/include/glaze/tuplet/tuple.hpp
index 0f54a4141c..6d2a5b010d 100644
--- a/include/glaze/tuplet/tuple.hpp
+++ b/include/glaze/tuplet/tuple.hpp
@@ -33,16 +33,12 @@ namespace glz
       template <class T>
       using identity_t = T;
 
-      // Obtains T::type
       template <class T>
       using type_t = typename T::type;
 
       template <size_t I>
       using tag = std::integral_constant<size_t, I>;
 
-      template <size_t I>
-      constexpr tag<I> tag_v{};
-
       template <size_t N>
       using tag_range = std::make_index_sequence<N>;
 
@@ -51,8 +47,6 @@ namespace glz
 
       template <class Tup>
       using base_list_t = typename std::decay_t<Tup>::base_list;
-      template <class Tup>
-      using element_list_t = typename std::decay_t<Tup>::element_list;
 
       template <class Tuple>
       concept base_list_tuple = requires() { typename std::decay_t<Tuple>::base_list; };
@@ -140,9 +134,9 @@ namespace glz
    template <class T>
    using unwrap_ref_decay_t = typename std::unwrap_ref_decay<T>::type;
 
-   // tuplet::detail::get_tuple_base implementation
-   // tuplet::detail::apply_impl
-   namespace tuplet::detail
+   // tuplet::get_tuple_base implementation
+   // tuplet::apply_impl
+   namespace tuplet
    {
       template <class A, class... T>
       struct get_tuple_base;
@@ -186,24 +180,19 @@ namespace glz
       {
          return {{{static_cast<type_t<Outer>&&>(tup.identity_t<Outer>::value).identity_t<Inner>::value}...}};
       }
-   } // namespace tuplet::detail
-
-   // tuple implementation
-   namespace tuplet
-   {
+      
       template <class... T>
-      using tuple_base_t = typename detail::get_tuple_base<tag_range<sizeof...(T)>, T...>::type;
-   } // namespace tuplet
+      using tuple_base_t = typename get_tuple_base<tag_range<sizeof...(T)>, T...>::type;
+   }
 
    template <class... T>
    struct tuple : tuplet::tuple_base_t<T...>
    {
       static constexpr auto glaze_reflect = false;
-      constexpr static size_t N = sizeof...(T);
+      static constexpr size_t N = sizeof...(T);
       using super = tuplet::tuple_base_t<T...>;
       using super::operator[];
       using base_list = typename super::base_list;
-      using element_list = tuplet::type_list<T...>;
       using super::decl_elem;
 
       template <tuplet::other_than<tuple> U> // Preserves default assignments
@@ -360,7 +349,6 @@ namespace glz
       constexpr static size_t N = 0;
       using super = tuplet::tuple_base_t<>;
       using base_list = tuplet::type_list<>;
-      using element_list = tuplet::type_list<>;
 
       template <tuplet::other_than<tuple> U> // Preserves default assignments
          requires tuplet::stateless<U> // Check that U is similarly stateless
@@ -456,7 +444,7 @@ namespace glz
    template <class F, tuplet::base_list_tuple Tup>
    constexpr decltype(auto) apply(F&& func, Tup&& tup)
    {
-      return tuplet::detail::apply_impl(static_cast<F&&>(func), static_cast<Tup&&>(tup),
+      return tuplet::apply_impl(static_cast<F&&>(func), static_cast<Tup&&>(tup),
                                         typename std::decay_t<Tup>::base_list());
    }
 
@@ -494,9 +482,9 @@ namespace glz
             using big_tuple = tuple<std::decay_t<T>...>;
 #endif
             using outer_bases = base_list_t<big_tuple>;
-            constexpr auto outer = detail::get_outer_bases(outer_bases{});
-            constexpr auto inner = detail::get_inner_bases(outer_bases{});
-            return detail::cat_impl(big_tuple{{{std::forward<T>(ts)}...}}, outer, inner);
+            constexpr auto outer = get_outer_bases(outer_bases{});
+            constexpr auto inner = get_inner_bases(outer_bases{});
+            return cat_impl(big_tuple{{{std::forward<T>(ts)}...}}, outer, inner);
          }
       }
 
diff --git a/tests/json_reflection_test/json_reflection_test.cpp b/tests/json_reflection_test/json_reflection_test.cpp
index fa45d13385..9ac600ee20 100644
--- a/tests/json_reflection_test/json_reflection_test.cpp
+++ b/tests/json_reflection_test/json_reflection_test.cpp
@@ -454,7 +454,7 @@ struct empty_t
 {};
 
 static_assert(glz::reflect<empty_t>::size == 0);
-static_assert(not glz::object_info<glz::opts{}, empty_t>::maybe_skipped);
+static_assert(not glz::maybe_skipped<glz::opts{}, empty_t>);
 
 suite empty_test = [] {
    "empty_t"_test = [] {