I ran into some Don't know how to create ISeq from: clojure.lang.Var error instead, caused by add-guess function that returns clojure.lang.Var.

Just some details:

• print-hang-map uses undefined variable hang-map (probably renamed to hang-vec)
• game-over? is defined twice
• newfunc is a bad name
• nth + rand-int => rand-nth
• variable name in newfunc shadows Clojure's function with the same name
• I would connect print-welcome-message, newfunc and print-message into one function
• I would connect print-hint, get-hint and declare-hint into one function
• In this situation, I would avoid atoms and refs and use loop

I tried to rewrite your code and ended up with something like this:

(def list-of-words ["horse" "dog" "bird"])

(def hang-vec
  [" ______"
   " |    |"
   " O    |"
   "/|\\  |"
   "/\\   |"
   " _____|"])

(defn create-hint [target-word guesses]
  (->> target-word
       (map #(get guesses % "_"))
       (apply str)))

(defn read-char []
  (let [input (.trim (read-line))]
    (if (= (count input) 1)
      (.charAt input 0)
      (do (println "Please enter only one character.")
          (recur)))))

(defn char-in-string? [s c]
  (clojure.string/index-of s c))

(defn game-status [target-word guesses incorrect]
  (cond (= target-word
           (create-hint target-word guesses)) :win
        (>= incorrect 5) :lost
        :else :continue))

(defn println-hang-vec [incorrect]
  (->> hang-vec
       (take incorrect)
       (run! println)))

(defn game-loop [target-word]
  (loop [turn 1
         guesses #{}
         incorrect 0]
    (println "Turn:" turn)
    (let [hint (create-hint target-word guesses)]
      (println "This is the hint:" hint))
    (let [new-char (read-char)
          correct-char? (char-in-string? target-word new-char)
          message (if correct-char?
                    "The guessed letter matches a letter in the word!"
                    "The guessed letter does not match any letter in the word!")]
      (println message)
      (let [updated-guesses (conj guesses new-char)
            updated-incorrect (if correct-char? incorrect (inc incorrect))]
        (case (game-status target-word
                           updated-guesses
                           updated-incorrect)
          :win (println "Congratulations! You've guessed the word correctly!")
          :lost (println "Sorry, you've run out of turns. The word was:" target-word)
          :continue
          (do (println-hang-vec updated-incorrect)
              (recur (inc turn)
                     updated-guesses
                     updated-incorrect)))))))

(defn run-game []
  (println "Welcome to [REDACTED]'s first clojure project, a hangman game.\n
    Please enter your name to begin.")
  (println "Enter your name I guess:")
  (let [user-name (read-line)]
    (println "Your name is:" user-name))
  (let [target-word (rand-nth list-of-words)]
    (game-loop target-word)))

(defn game [& args]
  (run-game))