LLMs + Clojure = Who needs frameworks? (by Kapil Reddy)

SUMMARY

Kapil Reddy explores using LLMs to compose Clojure libraries via llms.edn blueprints, easing onboarding without frameworks while honoring Clojure's composable philosophy.

STATEMENTS

• Clojure's onboarding challenges have diminished over time, with learning resources and editor options improving, but starting new projects remains a significant hurdle for newcomers.
• The Clojure community benefits from a stable core, JVM support, an amazing ecosystem, and a philosophy prioritizing libraries over frameworks for greater flexibility and options.
• While libraries in Clojure excel at single responsibilities and interoperability, the lack of a central framework like Rails creates a "kickstart problem" for initiating projects.
• Large Language Models (LLMs) transform coding by enabling rapid project scaffolding, as demonstrated in generating UI for a 3D r/place clone using Three.js.
• The llms.edn format adapts concepts from llm.txt specifically for Clojure, describing libraries' categories, usage patterns, documentation, and examples to guide LLM composition.
• Blueprints categorize essential library types like web servers, routing, and templating, allowing interchangeable options to generate cohesive starter projects without rigid frameworks.
• The 'a' CLI tool leverages LLMs to create projects from text prompts, selecting blueprints, resolving dependencies, and using tool-calling for file operations in Babashka.
• Future enhancements for 'a' include a community-driven SQLite database for semantic blueprint searches, offline local LLM support, and expansions to deployments and targets like ClojureScript.
• LLMs shift the library-vs-framework debate by providing framework-like convenience through dynamic composition, potentially eliminating the need for monolithic frameworks in software development.
• Clojure's simplicity positions it advantageously in an LLM-driven world, where problems like state management in AI agents resemble flow engineering facilitated by composable libraries.

IDEAS

• LLMs can dynamically compose Clojure libraries into full projects, mimicking framework benefits without lock-in, revolutionizing how developers bootstrap applications.
• Clojure's library-centric approach, combined with LLMs, allows for interchangeable components in categories like routing, enabling personalized stacks without starting from scratch.
• The llms.edn file standardizes library declarations with usage patterns and examples, turning the ecosystem into a queryable knowledge base for AI-driven generation.
• Blueprints act as flexible templates with placeholders for categories, not fixed code, allowing LLMs to select and integrate libraries based on project needs.
• The 'a' tool, named for unity and rhyming with build tools, uses Babashka to run an AI agent that handles file creation and editing via tool-calling.
• Even lesser-known Clojure libraries can be effectively used by LLMs if declared in llms.edn, bypassing internet indexing limitations for niche ecosystem tools.
• A community data pipeline could ingest llms.edn files and example projects into a SQLite database, enabling semantic searches for tailored blueprints.
• Offline LLM modes in tools like 'a' would reduce reliance on cloud APIs, making Clojure development more accessible and cost-effective for local workflows.
• Deploying Clojure apps, often seen as simple JAR pushes by experts, poses onboarding barriers; LLMs could automate this for newcomers across targets like Babashka or Jank.
• In the LLM era, software modularity—emphasized in Clojure—aligns with AI agents' needs for simple, composable flows, potentially redefining traditional framework necessities.

INSIGHTS

• Clojure's emphasis on composable libraries inherently prepares it for LLM augmentation, where AI can orchestrate modular pieces into seamless wholes, fostering innovation without prescriptive structures.
• Onboarding friction in ecosystems like Clojure stems not from the language's complexity but from the cognitive load of assembly; LLMs offload this by pattern-matching declarations to user intent.
• Standardizing library metadata via formats like llms.edn transforms scattered ecosystem knowledge into an AI-readable ontology, enabling emergent composability that scales with community contributions.
• The shift from static templates to dynamic blueprints via LLMs democratizes expertise, allowing novices to experiment with advanced stacks while veterans customize without boilerplate drudgery.
• In an AI-assisted future, frameworks may evolve into optional conveniences, as LLMs excel at contextual synthesis, rewarding languages that prioritize flexibility over opinionated integrations.
• Clojure's simplicity counters LLM-induced complexity in development pipelines, positioning it as a lingua franca for AI agents managing state flows in increasingly automated software creation.

QUOTES

• "reducing time to ripple right that's your main goal that's when everyone has a aha moment and they say okay closure is awesome"
• "libraries over frameworks I think this is something that everyone kind of knows about it uh people talk about it on different channels that you should prefer libraries over frameworks"
• "Clojure needs a rails right this is exactly kind of pointing to the problem of okay let's how do I start creating a new closure project"
• "LLM world needs lot more simple software to be written because LLMs themselves cause a lot of complexity and uh I think closure just like Vedang mentioned closure can be like a advantageous position because of the simplicity it brings"
• "if you think really long term and that places us closer in a very unique and good position of like uh software development in long term that okay we have like actually got something right which is paying off in other ways also"

HABITS

• Dedicate most of one's professional life to writing Clojure code, seeking out and creating opportunities to sustain deep engagement with the language and ecosystem.
• Organize community events like conferences (e.g., inClojure) to foster knowledge sharing and address collective challenges such as onboarding and hiring.
• Experiment with LLMs during sabbaticals to explore new coding paradigms, such as generating UI for complex projects like a 3D r/place clone.
• Balance perspectives by collaborating with non-LLM advocates, using their deep thinking on frameworks to refine one's AI-integrated approaches.
• Curate and build tools iteratively, starting with experimental demos and incorporating community feedback to evolve projects like 'a' toward production viability.

FACTS

• Helpshift reduced Clojure onboarding from six months to one month through targeted training and resources, addressing early ecosystem gaps.
• The Clojure community is uniquely praised by Lisp author Paul Graham for breaking the "curse of Lisp" through its stable core, JVM integration, and vibrant support.
• Instant DB provides an llm.txt file for their real-time database, akin to a "batteries-included" Firebase, accelerating LLM-assisted development.
• The 'a' tool is entirely written in Babashka, including its AI agent, enabling lightweight, scriptable project generation without heavy dependencies.
• Projects like DUI index the entire Clojure ecosystem, supporting efforts to make library metadata searchable and AI-ready.

REFERENCES

• "Clojure needs a Rails" blog post, highlighting the kickstart challenges for new projects.
• Instant DB's llm.txt implementation for real-time database integration.
• Luke Vanderhart's talk at Kuun Hack on indexing identities with LLMs and RDF.
• Daniel Jackson's "Back to Modularity" talk on structuring software for the LLM world.
• Blog post on writing coding agents in Babashka, explaining REST-based looping for AI interactions.

HOW TO APPLY

• Define library categories (e.g., web server, routing, templating) in your project's llms.edn file, including documentation sources and usage examples to enable AI composition.
• Install the 'a' CLI tool and run 'a create [project-name]' with a text prompt describing your app, allowing it to select a blueprint and generate initial structure.
• Customize blueprints post-generation by commanding 'a replace [category] [library]', such as swapping Ring for another routing option, to match team preferences.
• Contribute to the community database by adding llms.edn to your library repositories, providing metadata that feeds into semantic searches for broader ecosystem use.
• Test generated projects immediately by checking deps.edn for resolved dependencies and running the server, iterating with LLM refinements for specific features like authentication.

ONE-SENTENCE TAKEAWAY

LLMs empower Clojure's library composition to bypass frameworks, streamlining onboarding and future-proofing development.

RECOMMENDATIONS

• Adopt llms.edn declarations in your Clojure libraries to make them AI-discoverable, enhancing composability for both human and machine collaborators.
• Experiment with tools like 'a' for prototyping, but always review and refine LLM-generated code to ensure alignment with best practices and security.
• Engage in community discussions to standardize blueprint formats, accelerating the ecosystem's evolution toward LLM-native workflows.
• Prioritize simplicity in project structures, as Clojure's modular ethos amplifies LLM efficiency in handling complex state flows.
• Explore offline LLM integrations early to build resilient, cost-free development pipelines independent of cloud dependencies.

MEMO

In the evolving landscape of functional programming, Kapil Reddy, a seasoned Clojure practitioner and AI builder at Unravel Tech, challenges the long-standing tension between flexibility and accessibility. For over a decade, Reddy has championed Clojure, leading backend teams at Helpshift and organizing India's inClojure conference. Yet, even as learning resources abound—from Calva editors to abundant tutorials—the act of launching a new project remains a formidable barrier. "It's the curse of knowledge," Reddy notes, where veterans overlook the overwhelm faced by newcomers piecing together libraries like Ring for web serving or Reitit for routing. Enter large language models (LLMs), which Reddy positions not as a gimmick but as a philosophical ally to Clojure's core tenet: libraries over frameworks.

Reddy's innovation, unveiled at reClojure 2025, hinges on llms.edn—a Clojure-native format inspired by llm.txt but tailored for the ecosystem's modular ethos. This structured file declares a library's category, usage patterns, documentation, and examples, transforming disparate tools into an AI-queryable blueprint. Imagine prompting an LLM: "Build a simple web app." Instead of rigid templates, it composes interchangeable components—a server here, templating there—yielding a starter project that embodies best practices without the lock-in of Rails-like monoliths. "We're unifying the Clojure ecosystem under one thing," Reddy explains, introducing the CLI tool a (evoking Sanskrit for unity and cleverly rhyming with Make). Written entirely in Babashka, including its AI agent, a handles tool-calling to generate files, resolve dependencies, and even swap libraries on command.

During a live demo, the audience watched a spin up a basic server from a prompt, pulling in Compojure for routing after a quick replacement. Applause followed, not for perfection—Reddy admits it's experimental and not production-ready—but for crossing "a lot of hurdles" that daunt novices. What elevates this beyond novelty is its community vision: a SQLite database ingesting llms.edn files and example projects, powered by semantic search for precise blueprint matching. Projects like DUI, which indexes the Clojure world, pave the way, while offline modes with local LLMs promise token-free accessibility. For lesser-known libraries absent from the web's index, this metadata bridge ensures they're viable in AI workflows.

Yet Reddy probes deeper: In an LLM-saturated future, do frameworks even matter? Clojure's simplicity, he argues, positions it uniquely, countering AI-induced complexity with flow-like state management. Inspirations abound—from Luke Vanderhart's RDF-indexing talks to Daniel Jackson's modularity manifesto—reminding us that software's modularity aligns with AI agents' needs. Challenges persist: deployments, still a JAR-push simplicity for experts, confound the uninitiated; expansions to ClojureScript or Babashka loom large. Still, Reddy's work hints at a breeze where project kicks start effortlessly, balancing his LLM enthusiasm with skeptics like collaborator Adit, who shuns AI for thoughtful composition.

As Clojure turns 20, Reddy's proposal isn't just technical—it's a call to action. By declaring llms.edn in libraries and curating blueprints, the community can democratize its power, reducing "time to ripple"—that euphoric aha moment when Clojure clicks. In a world where AI redefines creation, this library-first harmony might just be the elegant path forward, honoring Paul Graham's praise for a community that broke Lisp's curse while adapting to tomorrow's tools.