Simple spec testing DSL
This is a case where a dynamic variable is the ideal solution:

(def ^:dynamic *described-entity*)

(defn it [fun &amp; v]
    (assert (apply fun *described-entity* v)))

(def it-is it)
(def it-is-the it)

(defmacro describe [value nest]
  `(binding [*described-entity* ~value]
     ~nest))

(defmacro when-applied-to [&amp; args-and-nest]
  (let [args (butlast args-and-nest)
        nest (last args-and-nest)]
    `(binding [*described-entity* (*described-entity* ~@args)]
       ~nest)))

(defmacro when-applied [nest]
  `(when-applied-to
    ~nest))


Online resources can probably explain dynamic vars better than I can here.  For the purposes here, think of it like your atom except that it's thread local and will restore the original value when the binding context exits.

To use a macro from another macro, you'll want to do it as shown here rather than trying to literally def it in terms of another macro.  The reasons why should probably be saved for when you get a little more macro experience.

And of course, butlast.  

In when-applied-to you can do your argument wrangling outside of the macro.  Note though, I'd probably consider passing args in a vector like (when-applied-to [42 35] (it = 77)) to make the arguments more explicit and require less pre-processing.