Abstract:

This blog post introduces "Pseudo," a novel Common Lisp macro that deeply embeds a large language model (LLM) directly into the programming language. This allows developers to write natural language pseudocode expressions within their Lisp code, which the LLM then expands into executable s-expressions. The pseudo macro achieves this by providing extensive contextual information from the Lisp environment to the LLM. While demonstrating the unique advantages of Lisp's s-expression-based macro system for such integration, the author sternly warns against using this in production due to inherent LLM limitations, including slowness, cost, unpredictability, and the potential for generating incorrect code.

Summary:

• Introduction of the pseudo Macro (Start of text): Joe Marshall proposes pseudo, a Common Lisp macro designed to embed a Large Language Model (LLM) directly into the programming language, allowing pseudocode expressions to be expanded into s-expressions.
• Core Functionality and Examples (Paragraph 2 & Examples): The pseudo macro accepts a string of pseudocode and uses an LLM to convert it into a Common Lisp s-expression. Demonstrated examples include simple arithmetic like (pseudo "multiply b by factorial of a.") and more complex operations such as computing the discriminant for a quadratic equation.
• Rich Contextual Information for LLM (Paragraph 5): pseudo enhances the LLM's generation by supplying comprehensive context, including lexically visible variables, bound symbols, overall and style directives (e.g., functional vs. imperative, loop preferences), and even the source code of the current file. The LLM is configured with a low temperature for more predictable results.
• Lisp's Metaprogramming Advantage (Paragraph 7): The author highlights that Common Lisp's s-expression-based macro system offers a significant advantage for this approach. It provides richer contextual information and allows direct manipulation of the code's syntax tree, making such deep integration far more feasible than in languages with text-expansion-based macro systems like Java.
• Critical LLM Caveats and Warnings (Paragraph 8): Key limitations of LLM integration are stressed: slowness, cost, potential for unpredictable or incorrect code, and the necessity of precise pseudocode for desired outcomes. The author explicitly states it would be "absolutely mad" to use pseudo in a production environment.
• Implementation Details and Dependencies (Paragraph 10): pseudo was developed using Google's Gemini as the backend and requires the gemini library and a Google API key. It also has a dependency on a specific SBCL function for extracting lexical variables, requiring an equivalent function if ported to other Common Lisp implementations, plus several other standard Lisp libraries.
• Discussion on LLM Scope (Comments Section): Josh Ballanco shares a similar concept in Julia (ElegantREPL.jl) for broader code generation. Joe Marshall responds, stating that LLMs perform better when their scope is limited to smaller expressions to avoid issues like unpredictable function naming. He clarifies that pseudo intentionally avoids expanding into full definitions (starting with "def") and notes difficulties in generating complex structures like class definitions, as these often require user-provided names.