diff --git a/src/common/communication/vst3.h b/src/common/communication/vst3.h
index 4b2c783e..0f97478b 100644
--- a/src/common/communication/vst3.h
+++ b/src/common/communication/vst3.h
@@ -152,11 +152,9 @@ class Vst3MessageHandler : public AdHocSocketHandler<Thread> {
      * @param callback The function used to generate a response out of the
      *   request.  See the definition of `F` for more information.
      *
-     * @tparam F A function type in the form of `T::Response(Request(T))`. C++
-     *   doesn't have syntax for this, but the function receives a `Request`
-     *   variant containing a `T`, and the function should return a `T::Reponse`
-     *   object. This way we can directly deserialize into a `T::Reponse` on the
-     *   side that called `send_object(T)`.
+     * @tparam F A function type in the form of `T::Response(T)` for every `T`
+     * in `Request`. This way we can directly deserialize into a `T::Response`
+     * on the side that called `receive_into(T, T::Response&)`.
      *
      * @relates Vst3MessageHandler::send_event
      */
@@ -178,7 +176,14 @@ class Vst3MessageHandler : public AdHocSocketHandler<Thread> {
                         request);
                 }
 
-                const auto& response = callback(request);
+                // We do the visiting here using a templated lambda. This way we
+                // always know for sure that the function returns the correct
+                // type, and we can scrap a lot of boilerplate elsewhere.
+                const auto& response = std::visit(
+                    [&]<typename T>(const T object) ->
+                    typename T::Response { return callback(object); },
+                    request);
+
                 if (logging) {
                     auto [logger, is_host_vst] = *logging;
                     logger.log_response(!is_host_vst, response);
diff --git a/src/common/serialization/vst3.h b/src/common/serialization/vst3.h
index e6880d76..dc15b1c8 100644
--- a/src/common/serialization/vst3.h
+++ b/src/common/serialization/vst3.h
@@ -58,7 +58,7 @@ struct WantsPluginFactory {
 /**
  * When we send a control message from the plugin to the Wine VST host, this
  * encodes the information we request or the operation we want to perform. A
- * request of type `ControlRequest(T)` should send back a `T::Reponse`.
+ * request of type `ControlRequest(T)` should send back a `T::Response`.
  */
 using ControlRequest = std::variant<WantsPluginFactory>;
 
@@ -70,7 +70,7 @@ void serialize(S& s, ControlRequest& payload) {
 /**
  * When we do a callback from the Wine VST host to the plugin, this encodes the
  * information we want or the operation we want to perform. A request of type
- * `CallbackRequest(T)` should send back a `T::Reponse`.
+ * `CallbackRequest(T)` should send back a `T::Response`.
  */
 using CallbackRequest = std::variant<WantsConfiguration>;
 
diff --git a/src/plugin/bridges/vst3.cpp b/src/plugin/bridges/vst3.cpp
index 167b7ede..3575fbd4 100644
--- a/src/plugin/bridges/vst3.cpp
+++ b/src/plugin/bridges/vst3.cpp
@@ -78,13 +78,8 @@ Vst3PluginBridge::Vst3PluginBridge()
     host_callback_handler = std::jthread([&]() {
         sockets.vst_host_callback.receive_messages(
             std::pair<Vst3Logger&, bool>(logger, false),
-            [&](CallbackRequest request) -> auto {
-                return std::visit(overload{[&](const WantsConfiguration&)
-                                               -> WantsConfiguration::Response {
-                                      return config;
-                                  }},
-                                  request);
-            });
+            overload{[&](const WantsConfiguration&)
+                         -> WantsConfiguration::Response { return config; }});
     });
 
     // Set up the plugin factory, since this is the first thing the host will
diff --git a/src/wine-host/bridges/vst3.cpp b/src/wine-host/bridges/vst3.cpp
index 9920bf2c..150cc16d 100644
--- a/src/wine-host/bridges/vst3.cpp
+++ b/src/wine-host/bridges/vst3.cpp
@@ -49,11 +49,9 @@ Vst3Bridge::Vst3Bridge(MainContext& main_context,
 
 void Vst3Bridge::run() {
     sockets.host_vst_control.receive_messages(
-        std::nullopt, [&](ControlRequest request) -> auto& {
-            return std::visit(overload{[&](const WantsPluginFactory&)
-                                           -> WantsPluginFactory::Response {
-                                  return *plugin_factory;
-                              }},
-                              request);
-        });
+        std::nullopt,
+        overload{
+            [&](const WantsPluginFactory&) -> WantsPluginFactory::Response {
+                return *plugin_factory;
+            }});
 }