     (swap! state #(assoc % :step-future future))
     state))
 
-(defn start-wait-for-git-step [state & {:keys [ref ms-between-polls] :or {ms-between-polls 100
-                                                                          ref              "refs/heads/master"}}]
+(defn start-wait-for-git-step [state & {:keys [ref ms-between-polls wait] :or {ms-between-polls 100
+                                                                          ref              "refs/heads/master"
+                                                                               wait true}}]
   (execute-pipeline-step state (fn [_ ctx]
-                                 (wait-for-git ctx (get-in @state [:git :remote]) :ref ref :ms-between-polls ms-between-polls))))
+                                 (wait-for-git ctx (get-in @state [:git :remote]) :ref ref :ms-between-polls ms-between-polls)))
+  (when wait
+    (wait-for-step-waiting state))
+  state)
 
 
 (defn start-clone-step [state ref cwd]

    (async/pipe step-result-updates-ch only-status-updates)
    only-status-updates))

(defn- init-state []
  (let [is-killed (atom false)
        ctx (some-ctx-with :is-killed is-killed)


(defn wait-for-step-waiting [state]
  (let [step-status-ch (:step-status-channel @state)
        result         (read-channel-or-time-out
                         (async/go
                           (loop []
                             (let [status (async/<! step-status-ch)]
                               (if (not= :waiting status)
                                 (recur)
                                 nil)))))]
    (when (instance? Exception result)
      (throw result)))
  state)

(defn execute-pipeline-step [state step]
  (clear-channel (:step-status-channel @state))
  (let [future (future
                 (let [execute-step-result (lambdacd-core/execute-step {} (:ctx @state)
                                                                       step)]
