diff --git a/frc971/control_loops/claw/claw.cc b/frc971/control_loops/claw/claw.cc
index 22cbf5a..44ec4e8 100644
--- a/frc971/control_loops/claw/claw.cc
+++ b/frc971/control_loops/claw/claw.cc
@@ -51,8 +51,8 @@
 static const double kMaxVoltage = 12.0;
 const double kRezeroThreshold = 0.03;
 
-ClawLimitedLoop::ClawLimitedLoop(StateFeedbackLoop<4, 2, 2> loop)
-    : StateFeedbackLoop<4, 2, 2>(loop),
+ClawLimitedLoop::ClawLimitedLoop(StateFeedbackLoop<4, 2, 2> &&loop)
+    : StateFeedbackLoop<4, 2, 2>(::std::move(loop)),
       uncapped_average_voltage_(0.0),
       is_zeroing_(true),
       U_Poly_((Eigen::Matrix<double, 4, 2>() << 1, 0,
diff --git a/frc971/control_loops/claw/claw.h b/frc971/control_loops/claw/claw.h
index 13d911e..12f7264 100644
--- a/frc971/control_loops/claw/claw.h
+++ b/frc971/control_loops/claw/claw.h
@@ -25,7 +25,7 @@
 
 class ClawLimitedLoop : public StateFeedbackLoop<4, 2, 2> {
  public:
-  ClawLimitedLoop(StateFeedbackLoop<4, 2, 2> loop);
+  ClawLimitedLoop(StateFeedbackLoop<4, 2, 2> &&loop);
   virtual void CapU();
 
   void set_is_zeroing(bool is_zeroing) { is_zeroing_ = is_zeroing; }
diff --git a/frc971/control_loops/drivetrain/drivetrain.cc b/frc971/control_loops/drivetrain/drivetrain.cc
index ca9c3c7..77d5781 100644
--- a/frc971/control_loops/drivetrain/drivetrain.cc
+++ b/frc971/control_loops/drivetrain/drivetrain.cc
@@ -28,8 +28,8 @@
  public:
   class LimitedDrivetrainLoop : public StateFeedbackLoop<4, 2, 2> {
    public:
-    LimitedDrivetrainLoop(const StateFeedbackLoop<4, 2, 2> &loop)
-        : StateFeedbackLoop<4, 2, 2>(loop),
+    LimitedDrivetrainLoop(StateFeedbackLoop<4, 2, 2> &&loop)
+        : StateFeedbackLoop<4, 2, 2>(::std::move(loop)),
         U_Poly_((Eigen::Matrix<double, 4, 2>() << 1, 0,
                  -1, 0,
                  0, 1,
diff --git a/frc971/control_loops/shooter/shooter.h b/frc971/control_loops/shooter/shooter.h
index 1352c49..82a06b6 100755
--- a/frc971/control_loops/shooter/shooter.h
+++ b/frc971/control_loops/shooter/shooter.h
@@ -26,13 +26,13 @@
 // that isn't true.
 
 // This class implements the CapU function correctly given all the extra
-// information that we know about from the wrist motor.
+// information that we know about.
 // It does not have any zeroing logic in it, only logic to deal with a delta U
 // controller.
 class ZeroedStateFeedbackLoop : public StateFeedbackLoop<3, 1, 1> {
  public:
-  ZeroedStateFeedbackLoop(StateFeedbackLoop<3, 1, 1> loop)
-      : StateFeedbackLoop<3, 1, 1>(loop),
+  ZeroedStateFeedbackLoop(StateFeedbackLoop<3, 1, 1> &&loop)
+      : StateFeedbackLoop<3, 1, 1>(::std::move(loop)),
         voltage_(0.0),
         last_voltage_(0.0),
         uncapped_voltage_(0.0),
@@ -42,7 +42,6 @@
 
   const static int kZeroingMaxVoltage = 5;
 
-  // Caps U, but this time respects the state of the wrist as well.
   virtual void CapU();
 
   // Returns the accumulated voltage.
diff --git a/frc971/control_loops/shooter/shooter_lib_test.cc b/frc971/control_loops/shooter/shooter_lib_test.cc
index 9a55d55..a37cf6b 100755
--- a/frc971/control_loops/shooter/shooter_lib_test.cc
+++ b/frc971/control_loops/shooter/shooter_lib_test.cc
@@ -259,7 +259,7 @@
   }
 
   // pointer to plant
-  ::std::unique_ptr<StateFeedbackPlant<2, 1, 1>> shooter_plant_;
+  const ::std::unique_ptr<StateFeedbackPlant<2, 1, 1>> shooter_plant_;
 
   // true latch closed
   bool latch_piston_state_;
diff --git a/frc971/control_loops/state_feedback_loop.h b/frc971/control_loops/state_feedback_loop.h
index f289e81..d62bc63 100644
--- a/frc971/control_loops/state_feedback_loop.h
+++ b/frc971/control_loops/state_feedback_loop.h
@@ -9,6 +9,11 @@
 #include "Eigen/Dense"
 
 #include "aos/common/logging/logging.h"
+#include "aos/common/macros.h"
+
+// TODO(brians): There are a lot of public member variables in here that should
+// be made private and have (const) accessors instead (and have _s at the end of
+// their names).
 
 template <int number_of_states, int number_of_inputs, int number_of_outputs>
 class StateFeedbackPlantCoefficients {
@@ -57,6 +62,30 @@
 class StateFeedbackPlant {
  public:
   EIGEN_MAKE_ALIGNED_OPERATOR_NEW;
+
+  StateFeedbackPlant(
+      const ::std::vector<StateFeedbackPlantCoefficients<
+          number_of_states, number_of_inputs,
+          number_of_outputs> *> &coefficients)
+      : coefficients_(coefficients),
+        plant_index_(0) {
+    Reset();
+  }
+
+  StateFeedbackPlant(StateFeedbackPlant &&other)
+      : plant_index_(other.plant_index_) {
+    ::std::swap(coefficients_, other.coefficients_);
+    X.swap(other.X);
+    Y.swap(other.Y);
+    U.swap(other.U);
+  }
+
+  virtual ~StateFeedbackPlant() {
+    for (auto c : coefficients_) {
+      delete c;
+    }
+  }
+
   ::std::vector<StateFeedbackPlantCoefficients<
       number_of_states, number_of_inputs, number_of_outputs> *> coefficients_;
 
@@ -112,23 +141,6 @@
   Eigen::Matrix<double, number_of_outputs, 1> Y;
   Eigen::Matrix<double, number_of_inputs, 1> U;
 
-  StateFeedbackPlant(
-      const ::std::vector<StateFeedbackPlantCoefficients<
-          number_of_states, number_of_inputs,
-          number_of_outputs> *> &coefficients)
-      : coefficients_(coefficients),
-        plant_index_(0) {
-    Reset();
-  }
-
-  StateFeedbackPlant(StateFeedbackPlant &&other)
-      : plant_index_(0) {
-    Reset();
-    ::std::swap(coefficients_, other.coefficients_);
-  }
-
-  virtual ~StateFeedbackPlant() {}
-
   // Assert that U is within the hardware range.
   virtual void CheckU() {
     for (int i = 0; i < kNumOutputs; ++i) {
@@ -154,6 +166,8 @@
 
  private:
   int plant_index_;
+
+  DISALLOW_COPY_AND_ASSIGN(StateFeedbackPlant);
 };
 
 // A Controller is a structure which holds a plant and the K and L matrices.
@@ -183,6 +197,51 @@
  public:
   EIGEN_MAKE_ALIGNED_OPERATOR_NEW;
 
+  StateFeedbackLoop(const StateFeedbackController<
+      number_of_states, number_of_inputs, number_of_outputs> &controller)
+      : controller_index_(0) {
+    controllers_.push_back(new StateFeedbackController<
+        number_of_states, number_of_inputs, number_of_outputs>(controller));
+    Reset();
+  }
+
+  StateFeedbackLoop(const ::std::vector<StateFeedbackController<
+      number_of_states, number_of_inputs, number_of_outputs> *> &controllers)
+      : controllers_(controllers), controller_index_(0) {
+    Reset();
+  }
+
+  StateFeedbackLoop(StateFeedbackLoop &&other) {
+    X_hat.swap(other.X_hat);
+    R.swap(other.R);
+    U.swap(other.U);
+    U_uncapped.swap(other.U_uncapped);
+    U_ff.swap(other.U_ff);
+    ::std::swap(controllers_, other.controllers_);
+    Y_.swap(other.Y_);
+    new_y_ = other.new_y_;
+    controller_index_ = other.controller_index_;
+  }
+
+  StateFeedbackLoop(
+      const Eigen::Matrix<double, number_of_states, number_of_outputs> &L,
+      const Eigen::Matrix<double, number_of_outputs, number_of_states> &K,
+      const StateFeedbackPlantCoefficients<number_of_states, number_of_inputs,
+                               number_of_outputs> &plant)
+      : controller_index_(0) {
+    controllers_.push_back(
+        new StateFeedbackController<number_of_states, number_of_inputs,
+                                    number_of_outputs>(L, K, plant));
+
+    Reset();
+  }
+
+  virtual ~StateFeedbackLoop() {
+    for (auto c : controllers_) {
+      delete c;
+    }
+  }
+
   const Eigen::Matrix<double, number_of_states, number_of_states> &A() const {
     return controller().plant.A;
   }
@@ -216,12 +275,6 @@
   }
   double U_max(int i, int j) const { return U_max()(i, j); }
 
-  Eigen::Matrix<double, number_of_states, 1> X_hat;
-  Eigen::Matrix<double, number_of_states, 1> R;
-  Eigen::Matrix<double, number_of_inputs, 1> U;
-  Eigen::Matrix<double, number_of_inputs, 1> U_uncapped;
-  Eigen::Matrix<double, number_of_outputs, 1> U_ff;
-
   const StateFeedbackController<number_of_states, number_of_inputs,
                                 number_of_outputs> &controller() const {
     return *controllers_[controller_index_];
@@ -241,34 +294,6 @@
     U_ff.setZero();
   }
 
-  StateFeedbackLoop(const StateFeedbackController<
-      number_of_states, number_of_inputs, number_of_outputs> &controller)
-      : controller_index_(0) {
-    controllers_.push_back(new StateFeedbackController<
-        number_of_states, number_of_inputs, number_of_outputs>(controller));
-    Reset();
-  }
-
-  StateFeedbackLoop(const ::std::vector<StateFeedbackController<
-      number_of_states, number_of_inputs, number_of_outputs> *> &controllers)
-      : controllers_(controllers), controller_index_(0) {
-    Reset();
-  }
-
-  StateFeedbackLoop(
-      const Eigen::Matrix<double, number_of_states, number_of_outputs> &L,
-      const Eigen::Matrix<double, number_of_outputs, number_of_states> &K,
-      const StateFeedbackPlantCoefficients<number_of_states, number_of_inputs,
-                               number_of_outputs> &plant)
-      : controller_index_(0) {
-    controllers_.push_back(
-        new StateFeedbackController<number_of_states, number_of_inputs,
-                                    number_of_outputs>(L, K, plant));
-
-    Reset();
-  }
-  virtual ~StateFeedbackLoop() {}
-
   virtual void FeedForward() {
     for (int i = 0; i < number_of_outputs; ++i) {
       U_ff[i] = 0.0;
@@ -350,6 +375,12 @@
 
   int controller_index() const { return controller_index_; }
 
+  Eigen::Matrix<double, number_of_states, 1> X_hat;
+  Eigen::Matrix<double, number_of_states, 1> R;
+  Eigen::Matrix<double, number_of_inputs, 1> U;
+  Eigen::Matrix<double, number_of_inputs, 1> U_uncapped;
+  Eigen::Matrix<double, number_of_outputs, 1> U_ff;
+
  protected:
   ::std::vector<StateFeedbackController<number_of_states, number_of_inputs,
                                         number_of_outputs> *> controllers_;
@@ -365,6 +396,9 @@
   bool new_y_ = false;
 
   int controller_index_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(StateFeedbackLoop);
 };
 
 #endif  // FRC971_CONTROL_LOOPS_STATEFEEDBACKLOOP_H_