From Scripts to Buy-In: How Small Clojure Wins Create Big Opportunities

SUMMARY

Burin Choomnuan, a seasoned developer, shares strategies for introducing Clojure in resistant enterprise environments by automating mundane tasks with small scripts, building momentum through demonstrated value rather than pitches.

STATEMENTS

Traditional pitches comparing Clojure's syntax and features to other languages rarely succeed in convincing companies to adopt it, as they come across as hard sells.
Instead of direct evangelism, focus on solving everyday workplace pains with Clojure tools, turning routine tasks into automated efficiencies that naturally gain attention.
In enterprises using AWS and SSO like Okta, manual daily logins via tools like Token DTO can take 5-10 minutes; automating them with Babashka scripts reduces this to 30 seconds.
Automating AWS EC2 instance alias management with Babashka allows quick SSH access to running servers, handling IP changes from restarts without manual intervention.
Replacing Postman for API testing with Clojure's http-client and Specter enables seamless data manipulation for testing scenarios, making complex payload adjustments efficient.
Integrating tmux and expect in scripts for password handling during SSO token renewal streamlines multi-session workflows in secure environments.
External activities, such as presenting Clojure at non-Clojure meetups like Python or JavaScript groups, amplify internal adoption by showcasing productivity gains.
Sharing GitHub contributions and writing articles on platforms like Cuvajs and Tier helps build visibility and credibility for Clojure's practical applications.
Emerging tools like clojure-mcp for AI integration and interop with Java/JS codebases provide low-risk entry points for Clojure in legacy systems.
Starting small with personal automations creates "show, don't tell" opportunities where colleagues inquire about rapid problem-solving, fostering organic buy-in.

IDEAS

Clojure's strength lies not in abstract language superiority but in its ability to treat API responses as manipulable data, revolutionizing testing workflows over GUI tools like Postman.
Daily rituals like SSO logins, often dismissed as mundane, represent untapped opportunities for scripting innovations that save cumulative hours across teams.
Babashka's CLI integration turns shell scripting into a Clojure playground, blending familiarity with functional power to automate infrastructure tasks effortlessly.
IP address volatility in cloud environments like AWS creates hidden frustrations; dynamic alias generation via describe-instances API calls eliminates this chaos.
Specter's path-based data navigation excels at applying business rules to nested JSON, enabling testers to iterate scenarios far faster than manual edits.
Stealth adoption thrives on personal utility first: build tools for your own efficiency, then let curiosity from peers drive wider interest.
Evangelizing Clojure outside echo chambers, like at Python meetups, plants seeds of intrigue by demonstrating cross-language productivity boosts.
Tmux combined with automation scripts supports parallel sessions for diverse tasks, turning a single command into a multitasking powerhouse.
GitHub as a showcase amplifies internal wins externally, turning private scripts into public proof of Clojure's enterprise viability.
Interop with Java/JS ecosystems positions Clojure as a gradual enhancer rather than a disruptive replacement, easing resistance in mixed tech stacks.
AI tools like clojure-mcp hint at future convergences, where functional paradigms could streamline machine learning integrations in traditional devops.
The "boring task" principle—targeting unavoidable drudgery—ensures scripts deliver immediate ROI, making adoption feel inevitable rather than experimental.

INSIGHTS

By prioritizing practical automations over ideological pitches, developers can bypass bureaucratic hurdles, creating value that self-advocates for Clojure's adoption.
Mundane workflows harbor the greatest leverage for innovation; transforming them with Clojure reveals how functional programming excels at data-centric problem-solving.
External evangelism complements internal stealth by building a narrative of proven utility, turning isolated scripts into communal success stories.
Dynamic scripting for volatile environments like AWS underscores Clojure's adaptability, where API-driven aliasing prevents downtime from minor changes.
Tools like Specter abstract complexity in data manipulation, allowing rapid hypothesis testing that accelerates development cycles in API-heavy systems.
Organic buy-in emerges from demonstrated speed: when colleagues witness 30-second solutions to 10-minute pains, skepticism yields to emulation.

QUOTES

"Don't tell them just show them right because there's a lot of opportunity for closure that you can you can you can use in your workplace."
"Go and spread the love, right? But my the takeaway is that you can do this your um you can start small basically."
"The postman workflow It's terrible, right? It's terrible."
"Spectre is just awesome right with that kind of data you get back in our case it's a news data it's a lot of thing that with business rule."
"Action for Monday. Go and try it out. find something that's boring and something you have to do anyway and then go forward with it."

HABITS

Automate daily morning rituals like SSO logins using Babashka scripts to reduce setup time from minutes to seconds, integrating seamlessly into shell workflows.
Maintain dynamic aliases for AWS instances by sourcing scripts that query active servers, ensuring quick SSH access amid IP changes.
Use Specter for manipulating API payloads in testing, applying business rules to nested data for efficient scenario variations.
Renew expired tokens mid-day with a single command via tmux and expect, handling passwords without manual intervention.
Present Clojure examples at non-Clojure meetups and share GitHub repos to build external visibility while refining internal tools.

FACTS

Manual AWS SSO logins via Token DTO typically consume 5-10 minutes daily per user in enterprise settings with Okta authentication.
Babashka scripts can generate EC2 instance aliases in seconds, filtering for running states to handle server restarts and IP shifts.
Postman-based API testing involves repetitive GUI steps, contrasting with Clojure's data manipulation that covers test matrices rapidly.
Clojure's interop with Java and JavaScript allows embedding in existing codebases, supporting gradual adoption without full rewrites.
Presentations at Python and JavaScript meetups in Sydney have introduced Clojure to diverse audiences, highlighting productivity gains.

REFERENCES

Babashka: CLI tool for scripting Clojure tasks like AWS automation and token handling.
Specter: Library for path-based data manipulation in API responses and testing payloads.
Token DTO: Python package for interacting with Okta SSO tokens, wrapped in Clojure scripts.
Postman: GUI tool for API testing, critiqued as inefficient compared to Clojure alternatives.
clojure-mcp: Emerging tool for AI integration within Clojure workflows.

HOW TO APPLY

Identify a repetitive daily task, such as SSO login, that consumes 5-10 minutes and document the manual steps involved.
Choose Babashka for scripting; install it and use its CLI to interact with tools like Token DTO for authentication.
Query relevant APIs, like AWS describe-instances, to fetch dynamic data such as active server IPs and filter for running states.
Integrate the script into your shell profile, adding aliases and sourcing commands to make execution one-step, such as via tmux for multi-sessions.
Test and refine the script personally until it saves significant time, then demonstrate it casually to colleagues when they notice your efficiency, inviting questions without pitching.

ONE-SENTENCE TAKEAWAY

Start small by automating boring tasks with Clojure scripts to demonstrate undeniable value and spark organic adoption.

RECOMMENDATIONS

Target unavoidable pains like API testing or logins for your first Clojure scripts, ensuring immediate personal and team benefits.
Leverage Specter for any data-heavy tasks, as its navigation simplifies complex manipulations over manual or GUI methods.
Evangelize subtly at external meetups to gain fresh perspectives and amplify internal credibility through shared stories.
Use GitHub to document and share scripts, turning private wins into visible assets that attract collaborators.
Explore interop tools early to integrate Clojure with legacy Java/JS, positioning it as an enhancer rather than a replacement.

MEMO

In the high-stakes world of enterprise software, where innovation often stalls behind layers of approval committees, Burin Choomnuan offers a subversive playbook for Clojure enthusiasts. Drawing from two decades in the field—from Java's rigidity to Ruby's expressiveness and finally Clojure's elegant functionalism—Choomnuan arrived at Clojure/Conj 2025 in Charlotte, North Carolina, with a message tailored for the frustrated pioneers in the audience. His talk, "From Scripts to Buy-In," eschews grand manifestos in favor of stealthy increments: solve the tedious problems no one else wants to touch, and let the results do the persuading.

Choomnuan's strategy begins with the drudgery of daily life in a non-Clojure company. Picture the morning ritual at an AWS-heavy enterprise: logging in via Okta's single sign-on, wrestling with Token DTO for two-factor authentication, and manually SSH-ing into servers whose IPs shift unpredictably after restarts. What takes colleagues 5 to 10 minutes—copy-pasting tokens, fumbling through terminals—Choomnuan condenses to 30 seconds using Babashka scripts. These lightweight Clojure runners query active EC2 instances, generate aliases on the fly, and integrate with tmux for seamless multi-session management. "You do it for yourself first," he advises, "and when they notice how fast you are, they ask, 'How did you build that?'"

The power extends beyond infrastructure to core development flows. For testers bogged down by Postman's clunky interface—endlessly tweaking payloads for API scenarios—Choomnuan deploys Clojure's http-client paired with Specter, a library for surgical data navigation. Nested JSON from endpoints becomes malleable, allowing quick application of business rules to test matrices. No more GUI drudgery; instead, functional purity turns responses into programmable data, covering complex cases in minutes. This isn't theoretical elegance—it's tactical advantage, born from Choomnuan's own needs while supporting team testing in a sprawling system.

To scale these wins, Choomnuan advocates hybrid tactics: internal subtlety meets external amplification. He presented Clojure at Sydney's Python and JavaScript meetups, spreading "the love" to skeptics and showcasing GitHub repos as productivity exhibits. Emerging tools like clojure-mcp for AI interop hint at broader horizons, bridging Clojure with Java and JavaScript legacies. The result? Teams don't just tolerate Clojure; they crave it, drawn by the momentum of small victories.

Ultimately, Choomnuan's ethos is pragmatic rebellion: find the boring, automate ruthlessly, and share without preaching. In an industry where languages live or die by utility, this approach transforms Clojure from niche curiosity to indispensable ally, one script at a time. For developers eyeing Monday's action, the directive is clear—dive into the mundane, emerge transformed.