diff --git a/tower-test/Cargo.toml b/tower-test/Cargo.toml
index e812179..18412a5 100644
--- a/tower-test/Cargo.toml
+++ b/tower-test/Cargo.toml
@@ -24,10 +24,10 @@ edition = "2018"
 [dependencies]
 futures-util = { version = "0.3", default-features = false }
 tokio = { version = "0.2", features = ["sync"]}
-tower-layer = "0.3"
+tower-layer = { version = "0.3", path = "../tower-layer" }
 tokio-test = "0.2"
-tower-service = "0.3"
+tower-service = { version = "0.3", path = "../tower-service" }
 pin-project = "0.4"
 
 [dev-dependencies]
-tokio = { version = "0.2", features = ["macros"] }
\ No newline at end of file
+tokio = { version = "0.2", features = ["macros"] }
diff --git a/tower/src/balance/p2c/test.rs b/tower/src/balance/p2c/test.rs
index b1eb39a..437b912 100644
--- a/tower/src/balance/p2c/test.rs
+++ b/tower/src/balance/p2c/test.rs
@@ -1,8 +1,8 @@
+use crate::discover::ServiceList;
+use crate::load;
 use futures_util::pin_mut;
 use std::task::Poll;
 use tokio_test::{assert_pending, assert_ready, assert_ready_ok, task};
-use tower_discover::ServiceList;
-use tower_load as load;
 use tower_test::{assert_request_eq, mock};
 
 use super::*;
diff --git a/tower/src/balance/pool/test.rs b/tower/src/balance/pool/test.rs
index f9f6eac..6861b25 100644
--- a/tower/src/balance/pool/test.rs
+++ b/tower/src/balance/pool/test.rs
@@ -1,6 +1,6 @@
+use crate::load;
 use futures_util::pin_mut;
 use tokio_test::{assert_pending, assert_ready, assert_ready_ok, task};
-use tower_load as load;
 use tower_test::{assert_request_eq, mock};
 
 use super::*;
diff --git a/tower/src/builder/mod.rs b/tower/src/builder/mod.rs
index 84be92b..ca72409 100644
--- a/tower/src/builder/mod.rs
+++ b/tower/src/builder/mod.rs
@@ -29,8 +29,11 @@ use std::fmt;
 /// `service` will be last to see the request.
 ///
 /// ```
+/// # // this (and other) doctest is ignored because we don't have a way
+/// # // to say that it should only be run with cfg(feature = "...")
 /// # use tower::Service;
 /// # use tower::builder::ServiceBuilder;
+/// #[cfg(all(feature = "buffer", feature = "limit"))]
 /// # async fn wrap<S>(svc: S) where S: Service<(), Error = &'static str> + 'static + Send, S::Future: Send {
 /// ServiceBuilder::new()
 ///     .buffer(100)
@@ -49,6 +52,7 @@ use std::fmt;
 /// ```
 /// # use tower::Service;
 /// # use tower::builder::ServiceBuilder;
+/// #[cfg(all(feature = "buffer", feature = "limit"))]
 /// # async fn wrap<S>(svc: S) where S: Service<(), Error = &'static str> + 'static + Send, S::Future: Send {
 /// ServiceBuilder::new()
 ///     .concurrency_limit(10)
@@ -69,7 +73,9 @@ use std::fmt;
 /// ```
 /// # use tower::Service;
 /// # use tower::builder::ServiceBuilder;
-/// # use tower_limit::concurrency::ConcurrencyLimitLayer;
+/// # #[cfg(feature = "limit")]
+/// # use tower::limit::concurrency::ConcurrencyLimitLayer;
+/// #[cfg(feature = "limit")]
 /// # async fn wrap<S>(svc: S) where S: Service<(), Error = &'static str> + 'static + Send, S::Future: Send {
 /// ServiceBuilder::new()
 ///     .concurrency_limit(5)
@@ -85,6 +91,7 @@ use std::fmt;
 /// # use tower::Service;
 /// # use tower::builder::ServiceBuilder;
 /// # use std::time::Duration;
+/// #[cfg(all(feature = "buffer", feature = "limit"))]
 /// # async fn wrap<S>(svc: S) where S: Service<(), Error = &'static str> + 'static + Send, S::Future: Send {
 /// ServiceBuilder::new()
 ///     .buffer(5)
diff --git a/tower/src/lib.rs b/tower/src/lib.rs
index a68bec0..1ef9a60 100644
--- a/tower/src/lib.rs
+++ b/tower/src/lib.rs
@@ -19,11 +19,11 @@ pub mod buffer;
 #[cfg(feature = "discover")]
 pub mod discover;
 #[cfg(feature = "filter")]
-#[allow(unreachable_pub)]
-pub(crate) mod filter;
+#[doc(hidden)] // not yet released
+pub mod filter;
 #[cfg(feature = "hedge")]
-#[allow(unreachable_pub)]
-pub(crate) mod hedge;
+#[doc(hidden)] // not yet released
+pub mod hedge;
 #[cfg(feature = "limit")]
 pub mod limit;
 #[cfg(feature = "load")]
diff --git a/tower/src/retry/policy.rs b/tower/src/retry/policy.rs
index 6f4c16d..cedf880 100644
--- a/tower/src/retry/policy.rs
+++ b/tower/src/retry/policy.rs
@@ -5,7 +5,7 @@ use std::future::Future;
 /// # Example
 ///
 /// ```
-/// use tower_retry::Policy;
+/// use tower::retry::Policy;
 /// use futures_util::future;
 ///
 /// type Req = String;
diff --git a/tower/src/util/boxed/mod.rs b/tower/src/util/boxed/mod.rs
index 5fb9faf..dc339b3 100644
--- a/tower/src/util/boxed/mod.rs
+++ b/tower/src/util/boxed/mod.rs
@@ -16,7 +16,7 @@
 //! ```
 //! use futures_util::future::ready;
 //! # use tower_service::Service;
-//! # use tower_util::{BoxService, service_fn};
+//! # use tower::util::{BoxService, service_fn};
 //! // Respond to requests using a closure, but closures cannot be named...
 //! # pub fn main() {
 //! let svc = service_fn(|mut request: String| {
diff --git a/tower/src/util/call_all/ordered.rs b/tower/src/util/call_all/ordered.rs
index b3374eb..f0e05bf 100644
--- a/tower/src/util/call_all/ordered.rs
+++ b/tower/src/util/call_all/ordered.rs
@@ -23,7 +23,7 @@ use tower_service::Service;
 /// use futures_util::future::{ready, Ready};
 /// use futures_util::StreamExt;
 /// use tower_service::Service;
-/// use tower_util::ServiceExt;
+/// use tower::util::ServiceExt;
 /// use tokio::prelude::*;
 ///
 /// // First, we need to have a Service to process our requests.
diff --git a/tower/src/util/mod.rs b/tower/src/util/mod.rs
index 1527770..7c642a7 100644
--- a/tower/src/util/mod.rs
+++ b/tower/src/util/mod.rs
@@ -75,7 +75,6 @@ pub trait ServiceExt<Request>: tower_service::Service<Request> {
     ///
     /// This is essentially `Stream<Item = Request>` + `Self` => `Stream<Item = Response>`. See the
     /// documentation for [`CallAll`](struct.CallAll.html) for details.
-    #[cfg(feature = "call-all")]
     fn call_all<S>(self, reqs: S) -> CallAll<Self, S>
     where
         Self: Sized,
diff --git a/tower/tests/balance/main.rs b/tower/tests/balance/main.rs
index d0c9718..d43ab9d 100644
--- a/tower/tests/balance/main.rs
+++ b/tower/tests/balance/main.rs
@@ -1,8 +1,10 @@
+#![cfg(feature = "balance")]
+
 use std::future::Future;
 use std::task::{Context, Poll};
 use tokio_test::{assert_pending, assert_ready, task};
-use tower_balance::p2c::Balance;
-use tower_discover::{Change, ServiceStream};
+use tower::balance::p2c::Balance;
+use tower::discover::{Change, ServiceStream};
 use tower_service::Service;
 use tower_test::mock;
 
@@ -21,7 +23,7 @@ impl Service<Req> for Mock {
     }
 }
 
-impl tower_load::Load for Mock {
+impl tower::load::Load for Mock {
     type Metric = usize;
     fn load(&self) -> Self::Metric {
         rand::random()
diff --git a/tower/tests/buffer/main.rs b/tower/tests/buffer/main.rs
index f26c3a9..5fa32c5 100644
--- a/tower/tests/buffer/main.rs
+++ b/tower/tests/buffer/main.rs
@@ -1,6 +1,8 @@
+#![cfg(feature = "buffer")]
+
 use std::thread;
 use tokio_test::{assert_pending, assert_ready, assert_ready_err, assert_ready_ok, task};
-use tower_buffer::{error, Buffer};
+use tower::buffer::{error, Buffer};
 use tower_test::{assert_request_eq, mock};
 
 fn let_worker_work() {
diff --git a/tower/tests/builder.rs b/tower/tests/builder.rs
index de12b39..a922001 100644
--- a/tower/tests/builder.rs
+++ b/tower/tests/builder.rs
@@ -1,10 +1,12 @@
+#![cfg(all(feature = "buffer", feature = "limit", feature = "retry"))]
+
 use futures_util::{future::Ready, pin_mut};
 use std::time::Duration;
+use tower::buffer::BufferLayer;
 use tower::builder::ServiceBuilder;
+use tower::limit::{concurrency::ConcurrencyLimitLayer, rate::RateLimitLayer};
+use tower::retry::{Policy, RetryLayer};
 use tower::util::ServiceExt;
-use tower_buffer::BufferLayer;
-use tower_limit::{concurrency::ConcurrencyLimitLayer, rate::RateLimitLayer};
-use tower_retry::{Policy, RetryLayer};
 use tower_service::*;
 use tower_test::{assert_request_eq, mock};
 
diff --git a/tower/tests/filter/main.rs b/tower/tests/filter/main.rs
index 240ed6f..6274125 100644
--- a/tower/tests/filter/main.rs
+++ b/tower/tests/filter/main.rs
@@ -1,6 +1,8 @@
+#![cfg(feature = "filter")]
+
 use futures_util::{future::poll_fn, pin_mut};
 use std::future::Future;
-use tower_filter::{error::Error, Filter};
+use tower::filter::{error::Error, Filter};
 use tower_service::Service;
 use tower_test::{assert_request_eq, mock};
 
diff --git a/tower/tests/hedge/main.rs b/tower/tests/hedge/main.rs
index f33c615..a4e2867 100644
--- a/tower/tests/hedge/main.rs
+++ b/tower/tests/hedge/main.rs
@@ -1,7 +1,9 @@
+#![cfg(feature = "hedge")]
+
 use std::time::Duration;
 use tokio::time;
 use tokio_test::{assert_pending, assert_ready, assert_ready_ok, task};
-use tower_hedge::{Hedge, Policy};
+use tower::hedge::{Hedge, Policy};
 use tower_test::{assert_request_eq, mock};
 
 #[tokio::test]
@@ -143,7 +145,7 @@ static NOT_CLONABLE: &'static str = "NOT_CLONABLE";
 #[derive(Clone)]
 struct TestPolicy;
 
-impl tower_hedge::Policy<Req> for TestPolicy {
+impl tower::hedge::Policy<Req> for TestPolicy {
     fn can_retry(&self, req: &Req) -> bool {
         *req != NOT_RETRYABLE
     }
diff --git a/tower/tests/limit/concurrency.rs b/tower/tests/limit/concurrency.rs
index 8027d98..7e2ba4f 100644
--- a/tower/tests/limit/concurrency.rs
+++ b/tower/tests/limit/concurrency.rs
@@ -1,5 +1,5 @@
 use tokio_test::{assert_pending, assert_ready, assert_ready_ok};
-use tower_limit::concurrency::ConcurrencyLimitLayer;
+use tower::limit::concurrency::ConcurrencyLimitLayer;
 use tower_test::{assert_request_eq, mock};
 
 #[tokio::test]
diff --git a/tower/tests/limit/main.rs b/tower/tests/limit/main.rs
index fc4378f..f80d68b 100644
--- a/tower/tests/limit/main.rs
+++ b/tower/tests/limit/main.rs
@@ -1,2 +1,4 @@
+#![cfg(feature = "limit")]
+
 mod concurrency;
 mod rate;
diff --git a/tower/tests/limit/rate.rs b/tower/tests/limit/rate.rs
index 49b9fc6..e608651 100644
--- a/tower/tests/limit/rate.rs
+++ b/tower/tests/limit/rate.rs
@@ -1,7 +1,7 @@
 use std::time::Duration;
 use tokio::time;
 use tokio_test::{assert_pending, assert_ready, assert_ready_ok};
-use tower_limit::rate::RateLimitLayer;
+use tower::limit::rate::RateLimitLayer;
 use tower_test::{assert_request_eq, mock};
 
 #[tokio::test]
diff --git a/tower/tests/load_shed/main.rs b/tower/tests/load_shed/main.rs
index de92418..6bad7ab 100644
--- a/tower/tests/load_shed/main.rs
+++ b/tower/tests/load_shed/main.rs
@@ -1,5 +1,7 @@
+#![cfg(feature = "load-shed")]
+
 use tokio_test::{assert_ready_err, assert_ready_ok, task};
-use tower_load_shed::LoadShedLayer;
+use tower::load_shed::LoadShedLayer;
 use tower_test::{assert_request_eq, mock};
 
 #[tokio::test]
@@ -27,5 +29,5 @@ async fn when_not_ready() {
     let mut fut = task::spawn(service.call("hello"));
 
     let err = assert_ready_err!(fut.poll());
-    assert!(err.is::<tower_load_shed::error::Overloaded>());
+    assert!(err.is::<tower::load_shed::error::Overloaded>());
 }
diff --git a/tower/tests/ready_cache/main.rs b/tower/tests/ready_cache/main.rs
index 93a2105..4578e4e 100644
--- a/tower/tests/ready_cache/main.rs
+++ b/tower/tests/ready_cache/main.rs
@@ -1,5 +1,7 @@
+#![cfg(feature = "ready-cache")]
+
 use tokio_test::{assert_pending, assert_ready, task};
-use tower_ready_cache::ReadyCache;
+use tower::ready_cache::ReadyCache;
 use tower_test::mock;
 
 type Req = &'static str;
diff --git a/tower/tests/retry/main.rs b/tower/tests/retry/main.rs
index be45ed9..ae97fc5 100644
--- a/tower/tests/retry/main.rs
+++ b/tower/tests/retry/main.rs
@@ -1,6 +1,8 @@
+#![cfg(feature = "retry")]
+
 use futures_util::future;
 use tokio_test::{assert_pending, assert_ready_err, assert_ready_ok, task};
-use tower_retry::Policy;
+use tower::retry::Policy;
 use tower_test::{assert_request_eq, mock};
 
 #[tokio::test]
@@ -155,7 +157,7 @@ impl Policy<Req, Res, Error> for CannotClone {
 
 fn new_service<P: Policy<Req, Res, Error> + Clone>(
     policy: P,
-) -> (mock::Spawn<tower_retry::Retry<P, Mock>>, Handle) {
-    let retry = tower_retry::RetryLayer::new(policy);
+) -> (mock::Spawn<tower::retry::Retry<P, Mock>>, Handle) {
+    let retry = tower::retry::RetryLayer::new(policy);
     mock::spawn_layer(retry)
 }
diff --git a/tower/tests/spawn_ready/main.rs b/tower/tests/spawn_ready/main.rs
index bef3bef..db28e39 100644
--- a/tower/tests/spawn_ready/main.rs
+++ b/tower/tests/spawn_ready/main.rs
@@ -1,6 +1,8 @@
+#![cfg(feature = "spawn-ready")]
+
 use std::{thread, time::Duration};
 use tokio_test::{assert_pending, assert_ready, assert_ready_err, assert_ready_ok};
-use tower_spawn_ready::SpawnReadyLayer;
+use tower::spawn_ready::SpawnReadyLayer;
 use tower_test::mock;
 
 #[tokio::test]
diff --git a/tower/tests/util/call_all.rs b/tower/tests/util/call_all.rs
index 0b056d2..5964f9d 100644
--- a/tower/tests/util/call_all.rs
+++ b/tower/tests/util/call_all.rs
@@ -6,9 +6,9 @@ use futures_util::{
 use std::task::{Context, Poll};
 use std::{cell::Cell, rc::Rc};
 use tokio_test::{assert_pending, assert_ready, task};
+use tower::util::ServiceExt;
 use tower_service::*;
 use tower_test::{assert_request_eq, mock};
-use tower_util::ServiceExt;
 
 type Error = Box<dyn std::error::Error + Send + Sync>;
 
diff --git a/tower/tests/util/main.rs b/tower/tests/util/main.rs
index cb80d97..28a2932 100644
--- a/tower/tests/util/main.rs
+++ b/tower/tests/util/main.rs
@@ -1,2 +1,4 @@
+#![cfg(feature = "util")]
+
 mod call_all;
 mod service_fn;
diff --git a/tower/tests/util/service_fn.rs b/tower/tests/util/service_fn.rs
index 3a5a5ab..d024159 100644
--- a/tower/tests/util/service_fn.rs
+++ b/tower/tests/util/service_fn.rs
@@ -1,6 +1,6 @@
 use futures_util::future::ready;
+use tower::util::service_fn;
 use tower_service::Service;
-use tower_util::service_fn;
 
 #[tokio::test]
 async fn simple() {