diff --git a/frc971/codelab/basic_test.cc b/frc971/codelab/basic_test.cc
index 91059f6..487a09b 100644
--- a/frc971/codelab/basic_test.cc
+++ b/frc971/codelab/basic_test.cc
@@ -6,9 +6,8 @@
 #include <memory>
 
 #include "aos/controls/control_loop_test.h"
-#include "aos/events/shm-event-loop.h"
-#include "aos/queue.h"
-#include "frc971/codelab/basic.q.h"
+#include "aos/events/shm_event_loop.h"
+#include "frc971/codelab/basic_generated.h"
 #include "frc971/control_loops/team_number_test_environment.h"
 #include "gtest/gtest.h"
 
@@ -25,12 +24,9 @@
  public:
   BasicSimulation(::aos::EventLoop *event_loop, chrono::nanoseconds dt)
       : event_loop_(event_loop),
-        position_sender_(event_loop_->MakeSender<BasicQueue::Position>(
-            ".frc971.codelab.basic_queue.position")),
-        status_fetcher_(event_loop_->MakeFetcher<BasicQueue::Status>(
-            ".frc971.codelab.basic_queue.status")),
-        output_fetcher_(event_loop_->MakeFetcher<BasicQueue::Output>(
-            ".frc971.codelab.basic_queue.output")) {
+        position_sender_(event_loop_->MakeSender<Position>("/codelab")),
+        status_fetcher_(event_loop_->MakeFetcher<Status>("/codelab")),
+        output_fetcher_(event_loop_->MakeFetcher<Output>("/codelab")) {
     event_loop_->AddPhasedLoop(
         [this](int) {
           // Skip this the first time.
@@ -45,11 +41,13 @@
 
   // Sends a queue message with the position data.
   void SendPositionMessage() {
-    auto position = position_sender_.MakeMessage();
+    auto builder = position_sender_.MakeBuilder();
 
-    position->limit_sensor = limit_sensor_;
+    Position::Builder position_builder = builder.MakeBuilder<Position>();
 
-    position.Send();
+    position_builder.add_limit_sensor(limit_sensor_);
+
+    builder.Send(position_builder.Finish());
   }
 
   void VerifyResults(double voltage, bool status) {
@@ -59,8 +57,8 @@
     ASSERT_TRUE(output_fetcher_.get() != nullptr);
     ASSERT_TRUE(status_fetcher_.get() != nullptr);
 
-    EXPECT_EQ(output_fetcher_->intake_voltage, voltage);
-    EXPECT_EQ(status_fetcher_->intake_complete, status);
+    EXPECT_EQ(output_fetcher_->intake_voltage(), voltage);
+    EXPECT_EQ(status_fetcher_->intake_complete(), status);
   }
 
   void set_limit_sensor(bool value) { limit_sensor_ = value; }
@@ -71,9 +69,9 @@
  private:
   ::aos::EventLoop *event_loop_;
 
-  ::aos::Sender<BasicQueue::Position> position_sender_;
-  ::aos::Fetcher<BasicQueue::Status> status_fetcher_;
-  ::aos::Fetcher<BasicQueue::Output> output_fetcher_;
+  ::aos::Sender<Position> position_sender_;
+  ::aos::Fetcher<Status> status_fetcher_;
+  ::aos::Fetcher<Output> output_fetcher_;
 
   bool limit_sensor_ = false;
 
@@ -83,13 +81,41 @@
 class BasicControlLoopTest : public ::aos::testing::ControlLoopTest {
  public:
   BasicControlLoopTest()
-      : ::aos::testing::ControlLoopTest(chrono::microseconds(5050)),
+      : ::aos::testing::ControlLoopTest(
+            "{\n"
+            "  \"channels\": [ \n"
+            "    {\n"
+            "      \"name\": \"/aos\",\n"
+            "      \"type\": \"aos.JoystickState\"\n"
+            "    },\n"
+            "    {\n"
+            "      \"name\": \"/aos\",\n"
+            "      \"type\": \"aos.RobotState\"\n"
+            "    },\n"
+            "    {\n"
+            "      \"name\": \"/codelab\",\n"
+            "      \"type\": \"frc971.codelab.Goal\"\n"
+            "    },\n"
+            "    {\n"
+            "      \"name\": \"/codelab\",\n"
+            "      \"type\": \"frc971.codelab.Output\"\n"
+            "    },\n"
+            "    {\n"
+            "      \"name\": \"/codelab\",\n"
+            "      \"type\": \"frc971.codelab.Status\"\n"
+            "    },\n"
+            "    {\n"
+            "      \"name\": \"/codelab\",\n"
+            "      \"type\": \"frc971.codelab.Position\"\n"
+            "    }\n"
+            "  ]\n"
+            "}\n",
+            chrono::microseconds(5050)),
         test_event_loop_(MakeEventLoop()),
-        goal_sender_(test_event_loop_->MakeSender<BasicQueue::Goal>(
-            ".frc971.codelab.basic_queue.goal")),
+        goal_sender_(test_event_loop_->MakeSender<Goal>("/codelab")),
 
         basic_event_loop_(MakeEventLoop()),
-        basic_(basic_event_loop_.get(), ".frc971.codelab.basic_queue"),
+        basic_(basic_event_loop_.get(), "/codelab"),
 
         basic_simulation_event_loop_(MakeEventLoop()),
         basic_simulation_(basic_simulation_event_loop_.get(), dt()) {
@@ -97,7 +123,7 @@
   }
 
   ::std::unique_ptr<::aos::EventLoop> test_event_loop_;
-  ::aos::Sender<BasicQueue::Goal> goal_sender_;
+  ::aos::Sender<Goal> goal_sender_;
 
   ::std::unique_ptr<::aos::EventLoop> basic_event_loop_;
   Basic basic_;
@@ -109,9 +135,10 @@
 // Tests that when the motor has finished intaking it stops.
 TEST_F(BasicControlLoopTest, IntakeLimitTransitionsToTrue) {
   {
-    auto message = goal_sender_.MakeMessage();
-    message->intake = true;
-    ASSERT_TRUE(message.Send());
+    auto builder = goal_sender_.MakeBuilder();
+    Goal::Builder goal_builder = builder.MakeBuilder<Goal>();
+    goal_builder.add_intake(true);
+    ASSERT_TRUE(builder.Send(goal_builder.Finish()));
   }
 
   basic_simulation_.set_limit_sensor(false);
@@ -121,9 +148,10 @@
   basic_simulation_.VerifyResults(12.0, false);
 
   {
-    auto message = goal_sender_.MakeMessage();
-    message->intake = true;
-    ASSERT_TRUE(message.Send());
+    auto builder = goal_sender_.MakeBuilder();
+    Goal::Builder goal_builder = builder.MakeBuilder<Goal>();
+    goal_builder.add_intake(true);
+    ASSERT_TRUE(builder.Send(goal_builder.Finish()));
   }
   basic_simulation_.set_limit_sensor(true);
 
@@ -136,9 +164,10 @@
 // and intake is requested.
 TEST_F(BasicControlLoopTest, IntakeLimitNotSet) {
   {
-    auto message = goal_sender_.MakeMessage();
-    message->intake = true;
-    ASSERT_TRUE(message.Send());
+    auto builder = goal_sender_.MakeBuilder();
+    Goal::Builder goal_builder = builder.MakeBuilder<Goal>();
+    goal_builder.add_intake(true);
+    ASSERT_TRUE(builder.Send(goal_builder.Finish()));
   }
   basic_simulation_.set_limit_sensor(false);
 
@@ -151,9 +180,10 @@
 // even if the limit sensor is off.
 TEST_F(BasicControlLoopTest, NoIntakeLimitNotSet) {
   {
-    auto message = goal_sender_.MakeMessage();
-    message->intake = false;
-    ASSERT_TRUE(message.Send());
+    auto builder = goal_sender_.MakeBuilder();
+    Goal::Builder goal_builder = builder.MakeBuilder<Goal>();
+    goal_builder.add_intake(false);
+    ASSERT_TRUE(builder.Send(goal_builder.Finish()));
   }
   basic_simulation_.set_limit_sensor(false);
 
@@ -166,9 +196,10 @@
 // is pressed and intake is requested.
 TEST_F(BasicControlLoopTest, IntakeLimitSet) {
   {
-    auto message = goal_sender_.MakeMessage();
-    message->intake = true;
-    ASSERT_TRUE(message.Send());
+    auto builder = goal_sender_.MakeBuilder();
+    Goal::Builder goal_builder = builder.MakeBuilder<Goal>();
+    goal_builder.add_intake(true);
+    ASSERT_TRUE(builder.Send(goal_builder.Finish()));
   }
   basic_simulation_.set_limit_sensor(true);
 
@@ -180,9 +211,10 @@
 // Tests that the intake is off if no intake is requested,
 TEST_F(BasicControlLoopTest, NoIntakeLimitSet) {
   {
-    auto message = goal_sender_.MakeMessage();
-    message->intake = false;
-    ASSERT_TRUE(message.Send());
+    auto builder = goal_sender_.MakeBuilder();
+    Goal::Builder goal_builder = builder.MakeBuilder<Goal>();
+    goal_builder.add_intake(false);
+    ASSERT_TRUE(builder.Send(goal_builder.Finish()));
   }
   basic_simulation_.set_limit_sensor(true);
 
@@ -205,9 +237,10 @@
   basic_simulation_.set_limit_sensor(true);
 
   {
-    auto message = goal_sender_.MakeMessage();
-    message->intake = true;
-    ASSERT_TRUE(message.Send());
+    auto builder = goal_sender_.MakeBuilder();
+    Goal::Builder goal_builder = builder.MakeBuilder<Goal>();
+    goal_builder.add_intake(true);
+    ASSERT_TRUE(builder.Send(goal_builder.Finish()));
   }
 
   SetEnabled(false);