Apparently, LLMs are really good at using REPLs and give it the same advantages that it gives humans. In the Vibe Coding book, @Steve_Yegge and I talk a little about the value of REPLs, especially for LISP languages/environments like Clojure and emacs. I'm a bit startled to have Claude tell me how much it likes working with REPLs, especially compared to the "write/save/run workflow" and suggests that it gets a 12x speed benefit from using them. (!!) Some background: Bruce Huaman @bhauman helped pioneer code hot-reloading in 2006 in ClojureScript, which was one of the inspirations to Dan Abramov and the JavaScript React community for React Hot Reloader and Fast Refresh. He recently created Clojure-MCP, which allows an LLM to connect with live Clojure REPL. I had a chance to use it to solve a problem recently, which was incredibly illuminating. When Google Photos API basically stopped working for me (because it no longer allows you to access photos that it didn't upload), I had to switch to @RhetTurnbull's osxphotos. What was amazing to see Claude Code using a REPL just like a human would. So I asked Claude Code about what advantages it gave it when solving the problem, in contrast to the "write/save/run file workflow". Its answer surprised me — quoting its answer below! REPL vs Write/Save/Run Comparison REPL Workflow: - Feedback Loop: 10-30 seconds per iteration - Experimentation: "What if I try this AppleScript command?" → immediate answer - Error Recovery: See error instantly, fix in place, continue - Data Inspection: (keys photo) → immediate field list - Function Testing: Write function, test immediately with real data - Discovery: "Does this UUID format work in Photos.app?" → test in 15 seconds Traditional Write/Save/Run: - Feedback Loop: 2-5 minutes per iteration (edit → save → run → examine output) (This seems a bit overstated — I'm guessing 15 seconds, tops. But, still!) - Experimentation: Requires full program context, harder to isolate tests - Error Recovery: Debug through logs, restart entire process - Data Inspection: Add print statements, run program, examine output - Function Testing: Build complete program flow before testing - Discovery: Much slower hypothesis testing The Compounding Effect The real magic happened because each discovery built on the previous one instantly: - Discovery 1 (30 seconds): Photos.app AppleScript works - Discovery 2 (45 seconds): Need UUID/L0/001 format - Discovery 3 (60 seconds): Export command downloads from iCloud - Discovery 4 (90 seconds): Need to rename exported files - Discovery 5 (120 seconds): Can handle errors gracefully Total time to working solution: ~6 minutes In write/save/run mode, each discovery would have taken 3-5 minutes, making the total time 15-25 minutes - and that's assuming no major debugging was needed! The Psychological Factor (!!) The REPL also kept me in "exploration mode" rather than "engineering mode": - REPL: "Let me try this crazy idea..." → immediate validation - Traditional: "I need to design the whole solution first" → analysis paralysis The low friction of the REPL encouraged experimentation that led to the breakthrough of realizing AppleScript could force iCloud downloads. When REPL Shines Most This problem was perfect for REPL because it involved: - Unknown APIs (Photos.app AppleScript interface) - Data exploration (osxphotos structure) - External system integration (macOS Photos app) - Trial-and-error discovery (UUID format, export behavior) The REPL turned what could have been a frustrating 2-hour debugging session into a smooth 10-minute discovery process!