Quick take - Programming language and Token Efficiency
Clojure is up there, of course :)
Aside from all the GitHub actions downtimes related/”build GitHub but better” posts, I saw this interesting note from Paul Graham on LLMs/token usage - As biased as it may sound, something I strongly believe in pre and post AI. We have seen it reflected in our AI token usage on our clojure-heavy codebase plenty already, but not without its struggles - more details below.
Quick note on GitHub downtimes - while it feels logical to want to explore alternatives, but none of those seem viable or battle tested for scale, compliance and flexibility (yet..), so betting on GitHub still seems the most viable option 🤞
Back to tokens and programming languages
🔍 Of course Paul is referring to the Lisp family
Humans find the Lisp family complicated, period. Picking on Clojure specifically, it can be a significant learning curve - symbol-heavy syntax, prefix notations, macros/meta-programming constructs, the numerous ((((())))), the JVM startup is snail-like, etc.
But this family is just superior in brevity, period. Plus the data-code-data meta interchange is so philosophically relevant in software engineering, and rewarding when put to good use.
Clojure is super valuable in enterprise software stacks due to its JVM interop along with the Lisp-y constructs.
I am working on something new and I had to evaluate which language stack can give me an advantage with AI/agentic product and ops. After evaluating side-by-side implementations across Clojure, Go and JS/TS, it was clear there is a training and availability part of the equation that changes the AI agent’s output quality. Claude Code/Codex/GitHub Copilot, etc. ie the harnesses/agents are trained more on widely available references and resource (also loud). In my opinion, the Clojure community is pretty self-contained, and not easy to break into. It’s not as much visible or public as Python or JS/TS/Go communities are and related content. So long story short I have ended up using Go (for now…).
Context from Gemini research agent
—AI Content Starts—
Python and TypeScript/JavaScript remain the gold standards for coding harnesses and AI orchestration engines across tools like Claude Code, Cursor, and open-source agent frameworks. However, selecting the right language depends heavily on whether you are optimizing for training data abundance (critical for open-weight models) or token/context efficiency (critical for reducing commercial API costs)
Detailed Coding Harness Comparison
Language - Python
Suitability for Harnesses - Maximum (Industry Standard)
Token Efficiency - Medium (Indentation adds tokens)
Context Window Fit - Excellent (Rich libraries compress logic)
Open-Source / Weight Model Synergies - Perfect (Highest training data volume)
Best Use-Case in AI Stack - Agent orchestrators, data parsers, eval scripts.
Language - JavaScript / TypeScript
Suitability for Harnesses - High (Web & Tooling)
Token Efficiency - Medium-Low (Braces/syntax noise)
Context Window Fit - Good (Widespread snippet compression)
Open-Source / Weight Model Synergies - Excellent (Massive open-source corpus)
Best Use-Case in AI Stack - Browser-based runtimes, IDE extensions, V8 sandboxes.
Language - Go
Suitability for Harnesses - High (Infrastructure)
Token Efficiency - Medium (Verbose error handling)
Context Window Fit - Excellent (Clean, readable syntax layout)
Open-Source / Weight Model Synergies - Great (Fast compilation/execution test loops)
Best Use-Case in AI Stack - High-throughput execution runtimes, CLI harnesses.
Language - Clojure / Common Lisp
Suitability for Harnesses - Experimental (High-Leverage)
Token Efficiency - Maximum (Minimalist prefix syntax)
Context Window Fit - Maximum (Dense code fits massive logic)
Open-Source / Weight Model Synergies - Poor (Sparse training data for small weights)
Best Use-Case in AI Stack - Self-modifying code, code-as-data gen, recursive logic.
Language - Rust
Suitability for Harnesses - High (Performance Engines)
Token Efficiency - Low (Heavy type signatures/lifetimes)
Context Window Fit - Poor (Long types/generics fill context)
Open-Source / Weight Model Synergies - Good (Rigid compiler catches LLM bugs)
Best Use-Case in AI Stack - Safe sandboxed execution engines, WASM runtimes.
Language - Elixir
Suitability for Harnesses - Medium-High (Agent Frameworks)
Token Efficiency - High (Powerful AST macros)
Context Window Fit - Excellent (Macros hide massive boilerplate)
Open-Source / Weight Model Synergies - Fair (Niche data requires fine-tuning)
Best Use-Case in AI Stack - Highly concurrent multi-agent message routing.
Language - C# / Java
Suitability for Harnesses - Medium-High (Enterprise)
Token Efficiency - Low (Heavy boilerplate/classes)
Context Window Fit - Poor (File splitting expands context)
Open-Source / Weight Model Synergies - Good (Huge enterprise repos available)
Best Use-Case in AI Stack - Legacy enterprise integration testing harnesses.
—AI Content Ends—
If you see the highlighted parts, the reasons for picking Go is obvious. Go over Python doesn’t have too much basis.
Hiring for Clojure is hard
Just like how it is usually difficult to hire good Clojure engineers, it looks like the harnesses have also found it hard to train/find enough to justify strong support. So, applying the same principle, training the harnesses on our internal Clojure knowledge and know-hows is the way to go forward.
Here are things we did that helped recover some of those disadvantages.
Sharing a screenshot from our skills repository and expanding what exactly you can also do below that
Add clojure-lsp plugin - helps understanding and write clojure code
Add Serena mcp for building deep cross-service functional flows/tracing and then build tests with that
Bonus - Setup autoresearch loops with serena tracing to handle legacy knowledge gaps and build trust in new work/updates
Preferred approach after trials
Add n/repl eval constructs - simplifying discovery and reuse of repl envs saves a lot of time wasted in cold starts (Clojure/JVM startup speed is still a big impediment)
Add a differential-diagnosis review skill.
Optional but super useful for making progress. Folks who write Clojure famously dislike non-idiomatic code. This skill can help balance the purist to a pragmatic state for shipping and keeping things clean eventually.
We are still far away from this being super smooth AI agents for Clojure implementations, but well worth investing as the simplicity compounds. Maybe I will have to rewrite the new Go system to Clojure soon - more on that soon 😄
P.S: https://stories.getswym.com/p/why-clojure-though - an older but relevant post in that context