What does the Bob say? (clojure version)
First, working top-down, your triggers at the top should be in sets (#{}), not vectors (you'll see why a little farther down):

(def sure-triggers
  #{"Does this cryogenic chamber make me look fat?"
    "4?"})

(def whatever-triggers
  #{"Tom-ay-to, tom-aaaah-to."
    "Let's go make out behind the gym!"
    "It's OK if you don't want to go to the DMV."
    "Ending with ? means a question."
    "1, 2, 3"})

(def chill-out-triggers
  #{"WATCH OUT!"
    "WHAT THE HELL WERE YOU THINKING?"
    "ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!"
    "1, 2, 3 GO!"
    "I HATE YOU"})




has-phrase has a couple things that can be improved:


Clojure ends predicates with a ? by convention. I'd rename it to has-phrase?.
some already returns a truthy/falsey value. (if pred? true false) is unnecessary.


Just reduce it to:

(defn has-phrase?
  "Return whether or not the given phrase is found in the collection"
  [phrase coll]
  (some #(= phrase %) coll))


BUT, now that you're using sets instead of vectors, this whole function is unnecessary:

(whatever-triggers "1, 2, 3")
=&gt; "1, 2, 3" ; Truthy

(whatever-triggers "Not in the set")
=&gt; nil


Sets themselves can be used as functions. If the item is in the set, they return the item back (a truthy result), else they return nil (falsey). This will also be much faster, since now you don't need to have some iterate potentially the entire vector (although obviously speed isn't a factor here). This changes reponse-for to:

(defn response-for
  "return `true` if the given phrase is found in the collection, `false` otherwise"
  [phrase]
  (cond
    (whatever-triggers phrase) whatever
    (chill-out-triggers phrase) chill-out
    (sure-triggers phrase) sure
    (= (clojure.string/trim phrase) "") fine))




This could be changed using some some trickery. some returns the first truthy value returned by its predicate. If you pass it pairs of [trigger-set response], you can iterate over the the pairs to find the first one that satisfies it, then return the response:

(defn response-for2 [phrase]
  (some (fn [[trigger-set response]]
          (when (trigger-set phrase)
            response))

        [[sure-triggers sure]
         [chill-out-triggers chill-out]
         [whatever-triggers whatever]
         [#{"" " "} fine]]))


Now, in this particular example, I wouldn't recommend doing this. It's not as clear as what you already had. I have used (some #(when ...)) before though, and it works great in some cases. I just thought I'd show you it here in case you run into a similar problem where this can be applied.

I'm sure something could be done using a map mapping triggers to responses, but I just did another Clojure review, and my brain's tapped out.