@mitchell_clojure Hey I just saw the mention, here's my custom fn:

(defun cider--guess-evaluation-context ()
  "returns list of let-binding strings from the inside out, without closing parens
     \"(let [...]\""
  (save-excursion
    (let ((res ()))
      (condition-case er
          (while t
            (backward-up-list)
            (when (looking-at (rx "(" (or "when-let" "if-let" "let") (opt "*")
                                  symbol-end (* space)
                                  (group "["))) ;; binding vector
              (let ((beg (match-beginning 0))
                    (end (save-excursion
                           (goto-char (match-beginning 1))
                           (forward-sexp 1)
                           (point))))
                (push (buffer-substring-no-properties beg end) res))))
        (scan-error res)))))

(defun cider-eval-dwim ()
  (interactive)
  (let ((ctx (cider--guess-evaluation-context))
        (bounds (cider-sexp-at-point 'bounds)))
    (cider-interactive-eval (concat (apply #'concat ctx)
                                    (buffer-substring-no-properties (car bounds) (cadr bounds))
                                    (make-string (length ctx) ?\)))
                            nil bounds
                            (cider--nrepl-pr-request-map))))

cider-eval-dwim is the interactive command, bind it to something convenient and it'll automatically splice the form you're evaluating with all its enclosing let forms

it's still in a somewhat rough state, I'll use it myself for a while more before deciding whether to contribute it upstream (maybe as part of cider-eval-in-context)

woah, sick! thank you very much. I'll incorporate this in my workflow and let you know if I come up with any interesting tweaks