diff --git a/docs/bot-usage.md b/docs/bot-usage.md
index 72426c42f..11f6beb8b 100644
--- a/docs/bot-usage.md
+++ b/docs/bot-usage.md
@@ -67,6 +67,7 @@ The following experiment modes are currently available:
 * `build-and-test`: run `cargo build` and `cargo test` on every crate
 * `build-only`: run `cargo build` on every crate
 * `check-only`: run `cargo check` on every crate (faster)
+* `rustdoc`: run `cargo doc --no-deps` on every crate
 
 The mode you should use depends on what your experiment is testing:
 
diff --git a/src/experiments.rs b/src/experiments.rs
index 851c4f31e..5f14a6ad5 100644
--- a/src/experiments.rs
+++ b/src/experiments.rs
@@ -21,6 +21,7 @@ string_enum!(pub enum Mode {
     BuildAndTest => "build-and-test",
     BuildOnly => "build-only",
     CheckOnly => "check-only",
+    Rustdoc => "rustdoc",
     UnstableFeatures => "unstable-features",
 });
 
diff --git a/src/runner/graph.rs b/src/runner/graph.rs
index fe0c5e6a2..6a721d4ed 100644
--- a/src/runner/graph.rs
+++ b/src/runner/graph.rs
@@ -255,6 +255,10 @@ pub(super) fn build_graph(ex: &Experiment, config: &Config) -> TasksGraph {
                             tc: tc.clone(),
                             quiet,
                         },
+                        Mode::Rustdoc => TaskStep::Rustdoc {
+                            tc: tc.clone(),
+                            quiet,
+                        },
                         Mode::UnstableFeatures => TaskStep::UnstableFeatures { tc: tc.clone() },
                     },
                 },
diff --git a/src/runner/tasks.rs b/src/runner/tasks.rs
index 748eb9fd6..a03c3d140 100644
--- a/src/runner/tasks.rs
+++ b/src/runner/tasks.rs
@@ -14,6 +14,7 @@ pub(super) enum TaskStep {
     BuildAndTest { tc: Toolchain, quiet: bool },
     BuildOnly { tc: Toolchain, quiet: bool },
     CheckOnly { tc: Toolchain, quiet: bool },
+    Rustdoc { tc: Toolchain, quiet: bool },
     UnstableFeatures { tc: Toolchain },
 }
 
@@ -39,6 +40,12 @@ impl fmt::Debug for TaskStep {
                     write!(f, " (quiet)")?;
                 }
             }
+            TaskStep::Rustdoc { ref tc, quiet } => {
+                write!(f, "doc {}", tc.to_string())?;
+                if quiet {
+                    write!(f, " (quiet)")?;
+                }
+            }
             TaskStep::UnstableFeatures { ref tc } => {
                 write!(f, "find unstable features on {}", tc.to_string())?;
             }
@@ -71,6 +78,7 @@ impl Task {
             TaskStep::BuildAndTest { ref tc, .. }
             | TaskStep::BuildOnly { ref tc, .. }
             | TaskStep::CheckOnly { ref tc, .. }
+            | TaskStep::Rustdoc { ref tc, .. }
             | TaskStep::UnstableFeatures { ref tc } => {
                 db.get_result(ex, tc, &self.krate).unwrap_or(None).is_none()
             }
@@ -89,6 +97,7 @@ impl Task {
             TaskStep::BuildAndTest { ref tc, .. }
             | TaskStep::BuildOnly { ref tc, .. }
             | TaskStep::CheckOnly { ref tc, .. }
+            | TaskStep::Rustdoc { ref tc, .. }
             | TaskStep::UnstableFeatures { ref tc } => {
                 db.record_result(ex, tc, &self.krate, || {
                     error!("this task or one of its parent failed!");
@@ -114,6 +123,7 @@ impl Task {
             }
             TaskStep::BuildOnly { ref tc, quiet } => self.run_build_only(config, ex, tc, db, quiet),
             TaskStep::CheckOnly { ref tc, quiet } => self.run_check_only(config, ex, tc, db, quiet),
+            TaskStep::Rustdoc { ref tc, quiet } => self.run_rustdoc(config, ex, tc, db, quiet),
             TaskStep::UnstableFeatures { ref tc } => self.run_unstable_features(config, ex, db, tc),
         }
     }
@@ -199,6 +209,26 @@ impl Task {
         ).map(|_| ())
     }
 
+    fn run_rustdoc<DB: WriteResults>(
+        &self,
+        config: &Config,
+        ex: &Experiment,
+        tc: &Toolchain,
+        db: &DB,
+        quiet: bool,
+    ) -> Fallible<()> {
+        test::run_test(
+            config,
+            "documenting",
+            ex,
+            tc,
+            &self.krate,
+            db,
+            quiet,
+            test::test_rustdoc,
+        ).map(|_| ())
+    }
+
     fn run_unstable_features<DB: WriteResults>(
         &self,
         config: &Config,
diff --git a/src/runner/test.rs b/src/runner/test.rs
index 7bca1a5a4..414d000ad 100644
--- a/src/runner/test.rs
+++ b/src/runner/test.rs
@@ -43,6 +43,12 @@ fn run_cargo(
         rustflags.push_str(tc_rustflags);
     }
 
+    let rustflags_env = if let Some(&"doc") = args.get(0) {
+        "RUSTDOCFLAGS"
+    } else {
+        "RUSTFLAGS"
+    };
+
     RunCommand::new(CARGO.toolchain(toolchain))
         .args(args)
         .quiet(quiet)
@@ -50,7 +56,7 @@ fn run_cargo(
         .env("CARGO_TARGET_DIR", "/target")
         .env("CARGO_INCREMENTAL", "0")
         .env("RUST_BACKTRACE", "full")
-        .env("RUSTFLAGS", rustflags)
+        .env(rustflags_env, rustflags)
         .sandboxed()
         .mount(target_dir, "/target", MountPerms::ReadWrite)
         .memory_limit(Some(config.sandbox.memory_limit))
@@ -202,3 +208,31 @@ pub fn test_check_only(
         Ok(TestResult::TestPass)
     }
 }
+
+pub fn test_rustdoc(
+    config: &Config,
+    ex: &Experiment,
+    source_path: &Path,
+    toolchain: &Toolchain,
+    quiet: bool,
+) -> Fallible<TestResult> {
+    let res = run_cargo(
+        config,
+        ex,
+        source_path,
+        toolchain,
+        quiet,
+        &["doc", "--frozen", "--no-deps", "--document-private-items"],
+    );
+
+    // Make sure to remove the built documentation
+    // There is no point in storing it after the build is done
+    let target_dir = toolchain.target_dir(&ex.name);
+    ::utils::fs::remove_dir_all(&target_dir.join("doc"))?;
+
+    if let Err(err) = res {
+        Ok(TestResult::BuildFail(failure_reason(&err)))
+    } else {
+        Ok(TestResult::TestPass)
+    }
+}
diff --git a/src/server/routes/ui/experiments.rs b/src/server/routes/ui/experiments.rs
index 843045cd8..2387d9aab 100644
--- a/src/server/routes/ui/experiments.rs
+++ b/src/server/routes/ui/experiments.rs
@@ -38,6 +38,7 @@ impl ExperimentData {
                 Mode::BuildAndTest => "cargo test",
                 Mode::BuildOnly => "cargo build",
                 Mode::CheckOnly => "cargo check",
+                Mode::Rustdoc => "cargo doc",
                 Mode::UnstableFeatures => "unstable features",
             },
             assigned_to: experiment.assigned_to.as_ref().map(|a| a.to_string()),