Making Tools Developers Actually Use

SUMMARY

Michiel Borkent, aka @borkdude, discusses his Clojure tools like babashka and squint, revealing how they transitioned from experiments to daily essentials by reducing barriers, emphasizing fun, and incorporating community input.

STATEMENTS

Reagent transformed frontend development for Clojure programmers by wrapping React with familiar concepts like functions, Hiccup, and atoms, eliminating the fear of JavaScript and browsers.
Backward compatibility ensures tools remain usable over time, as evidenced by Reagent examples from 2014 still working flawlessly in the volatile JavaScript ecosystem.
Gradual adoption allows users to start simple and build complexity incrementally, avoiding overwhelming learners with advanced features like React hooks right away.
Babashka enables fast-starting Clojure scripts comparable to bash, targeting JVM Clojure developers and replacing cumbersome shell scripting with intuitive Clojure syntax.
By focusing on one key improvement—such as startup time—tools like Babashka differentiate themselves from existing solutions while retaining familiarity.
Pods in Babashka simplify library integration by downloading and registering binaries on-the-fly, making features like SQLite accessible without additional installations.
NBB extends Babashka's scripting model to Node.js environments, allowing JavaScript developers to experiment with Clojure via npx without setup hurdles.
Squint creates a ClojureScript dialect that unifies Clojure and JavaScript data structures, enabling small bundle sizes and seamless npm publishing for hybrid projects.
Sharing early experiments and scrappy prototypes can lead to unexpected widespread adoption, as seen with depj evolving into official Clojure installation methods.
Eating your own dog food by rigorously testing tools on real ecosystems ensures reliability and uncovers issues before users encounter them.

IDEAS

Tools that reuse established language concepts can demystify intimidating domains, turning backend developers into confident frontend builders overnight.
Instant startup times in scripting tools bridge the gap between perceived "heavy" languages like Clojure and lightweight shells, sparking immediate productivity.
Self-contained binaries and pods eliminate dependency hell, allowing scripts to be shared effortlessly across teams without setup friction.
Browser-based scripting prototypes like Squint enable rapid ideation in unconventional environments, from train rides to quick HTML hacks.
Error messages that pinpoint exact code locations, rather than vague outputs, transform debugging from frustration to efficient correction.
Gradual migrations, such as porting TypeScript files one-by-one to Squint, make large-scale adoptions feasible without all-or-nothing risks.
Community anecdotes, like coworkers adopting fun utility scripts, demonstrate how playful tools seed broader ecosystem engagement.
Unifying data structures across languages reduces cognitive overhead, allowing idiomatic code to produce lean JavaScript bundles under 5KB.
Surveys and Slack polls actively shape tool evolution, turning passive users into collaborative innovators.
Financial and communal support sustains long-term open-source projects, preventing burnout and enabling iterative improvements over years.

INSIGHTS

Effective developer tools prioritize psychological ease by mirroring familiar patterns, thereby accelerating skill transfer and reducing abandonment rates.
Differentiation through singular, laser-focused enhancements—like blazing startup—creates indispensable niches amid saturated ecosystems.
Playful, low-friction entry points foster organic discovery, transforming casual tinkering into deep, sustained language adoption.
Robust error handling and precise feedback loops build trust, ensuring tools integrate seamlessly into daily workflows without interruption.
Community-driven iteration, fueled by shared experiments, amplifies impact beyond solo efforts, evolving prototypes into standards.
Reliability via backward compatibility and self-testing preserves user investment, cultivating loyalty in fast-changing tech landscapes.

QUOTES

"If you want to make a tool that developers actually use, lower the barrier to entry. Reuse familiar concepts."
"I started writing way more utility scripts when I found Babashka. The magic of Clojure: instant startup, easy to shell out to other commands."
"Easy and fun really matters. If you make something easy and really fun, people start playing around with their ideas."
"Share your experiments, share your scrappy fiddles. And there is actually a talk about this idea at Heart of Clojure last year by Lou Wilson."
"To summarize, if you want to have people use your tools, make it easy and make it fun and have fun making it and make it different."

HABITS

Regularly test new libraries in personal tools during development to ensure compatibility and identify gaps proactively.
Share early prototypes and experiments publicly to invite feedback and uncover unforeseen applications.
Conduct informal polls or surveys on community platforms like Slack to gather user opinions on features.
Eat your own dog food by applying tools to everyday tasks, such as porting personal scripts.
Maintain backward compatibility in all updates to preserve long-term usability for existing users.

FACTS

Reagent, introduced in 2014, still runs its original examples without changes, defying the JavaScript ecosystem's rapid evolution.
Babashka scripts with pods, like SQLite integration, start in 60 milliseconds, rivaling Node.js performance without npm installations.
Squint-generated bundles, such as a Reagent-like counter app with riyagami, compress to just 5KB gzipped after ESBuild optimization.
Depj, initially a holiday experiment, became the official Windows installer for Clojure, resolving PowerShell compatibility issues.
Clojure/doc's frontend migrated from TypeScript to Squint file-by-file, maintaining a small bundle while easing maintenance for non-JS experts.

REFERENCES

Reagent: A React wrapper library that uses Clojure functions, Hiccup, and atoms for intuitive frontend development.
Babashka: Fast-starting Clojure scripting tool with pods for binary libraries like SQLite.
Squint: ClojureScript dialect unifying JS data structures for minimal bundles and npm compatibility.
SCI: Small Clojure Interpreter used across projects for macro execution without full compiler overhead.

HOW TO APPLY

Identify user fears, such as frontend complexity, and design tools that reuse core language primitives to make unfamiliar domains approachable without new learning curves.
Focus on one standout improvement, like reducing startup time from seconds to milliseconds, while keeping the interface and syntax identical to popular alternatives for seamless substitution.
Implement self-contained features, such as on-demand pod downloads, to eliminate external dependencies and allow instant script sharing among teams.
Provide precise error localization in outputs, pointing directly to source code lines, to speed up debugging and enhance user confidence during initial trials.
Encourage gradual integration by supporting simple starting points, like basic scripts or UI elements, that scale to advanced usage without forcing comprehensive setups upfront.

ONE-SENTENCE TAKEAWAY

Build developer tools that lower barriers through familiarity, fun, and focused innovation to drive widespread adoption.

RECOMMENDATIONS

Prototype in unconventional settings, like mobile editors during commutes, to validate ease-of-use and inspire creative applications.
Integrate community feedback loops early via polls, ensuring tools evolve with real needs rather than assumptions.
Prioritize pod-like mechanisms for zero-install extensions, making advanced capabilities accessible to novices instantly.
Publish scrappy experiments openly, as hidden gems can unexpectedly become ecosystem staples through collective refinement.

MEMO

In the niche yet fervent world of Clojure programming, Michiel Borkent—better known as @borkdude—has quietly revolutionized how developers approach their craft. At Clojure/Conj 2025 in Charlotte, North Carolina, Borkent delivered a captivating talk titled "Making Tools Developers Actually Use," recounting the improbable journeys of his open-source creations from mere experiments to indispensable allies. What began as personal frustrations with Clojure's barriers—its unique syntax, lazy evaluation, and JVM heft—evolved into tools like Babashka and Squint, now wielded daily by thousands. Borkent's narrative underscores a profound truth: in software, utility isn't born from complexity but from cunning simplicity that meets users where they stand.

Borkent's epiphany traces back to 2014 and the Reagent library, a React wrapper that cloaked JavaScript's eccentricities in Clojure's comforting idioms: functions, Hiccup markup, and reactive atoms. As a self-proclaimed backend devotee terrified of browsers and their ancient foils like Internet Explorer 6, Borkent found Reagent disarming. "It lured me into frontend," he confessed, half a year later delivering talks on it in Sweden. This personal pivot illuminated a blueprint for tool design: lower entry barriers by recycling familiar concepts, fostering intuitive adoption. Reagent's enduring backward compatibility—its decade-old examples still run flawlessly—further proved that stability trumps fleeting trends in the chaotic JavaScript realm.

Enter Babashka, Borkent's 2019 brainchild, a lightweight Clojure interpreter that launches scripts in milliseconds, mimicking bash's snappiness while harnessing 95% of JVM Clojure's power. Aimed at JVM veterans weary of shell scripting's quirks—like forgetting nested if-else syntax—Babashka replaced tedium with joy. One Hacker News commenter captured its allure: instant startup, seamless shell integration, and REPL-driven development made utility scripting "just a good time." Pods, Babashka's killer feature, bundle libraries as downloadable binaries; a SQLite script, for instance, requires no installs, querying databases via RPC in 60 milliseconds—on par with Node.js but self-contained. Such innovations hooked even Rust-weary developers, easing them into Clojure through familiar scripting rituals and spawning coworker adoptions.

Borkent's toolkit extends further, adapting to diverse ecosystems. For Node.js fans dodging the JVM, NBB offers Clojure scripting via a simple npx nbb command, no setup needed. Squint, a dialect of ClojureScript, merges data structures with JavaScript for bundles as tiny as 5KB gzipped, enabling npm-published libraries and gradual TypeScript migrations—as Clojure/doc did, file by file. Even browser-bound hacks shine: Squint powered a logistics firm's year-long UI prototype and a Dutch developer's phone-hacked pinball game during a tedious train ride. These stories reveal Borkent's ethos—make it easy, fun, and incrementally adoptable—to dismantle Clojure's adoption hurdles.

Yet success hinged on community symbiosis. Borkent credits Slack polls, surveys, and financial backers like Next Journal for sustaining his "Borkdudeverse." Sharing scrappy fiddles, like the holiday-porting of Clojure CLI that birthed official Windows installers, amplified impacts. "Eat your own dog food," he urged, testing 106 libraries in Babashka's CI to preempt breaks. As Borkent wrapped, his tools embody a manifesto: craft with delight, differentiate sharply, and build reliably. In an era of bloated frameworks, his lesson endures—true indispensability whispers through unassuming elegance, inviting creators to flourish.