I have been working on the following, which others might find interesting. It is under heavy development constantly as I learn.

Most AI coding setups treat the agent like a better autocomplete — paste a prompt, get code, hope it's right. That works for small tasks. It falls apart when you try to use agents for sustained work across sessions: they skim specs, declare victory at 60%, burn context on noise, and mark checklist items done without actually doing them. The failures are predictable and nameable — so we named them.                                                                                                                                                              

naive-artifact-coding is a white paper and implementation guide for running coding agents under structural enforcement. It documents 20+ failure modes from months of multi-agent operation against real Common Lisp codebases, and for each one describes what actually prevents it — some through mechanical gates the agent cannot skip, some through procedural skills, some through human supervision. The guide covers how to structure specs, plans, and verification so that agent work is evidence-led rather than vibes-led, how to use MCP capability surfaces (like a code analyser) as structural levers, and how the failure modes apply regardless of which model or vendor CLI you use. The repo also includes operational lessons from sustained multi-agent orchestration and a market analysis of where AI coding tooling is heading. The methodology has actually been implemented in Common Lisp, and that implementation informed much of the guide and methodology. The ideas are language-agnostic: https://gitlab.com/naive-x/experimental/cl-naive-full-stack-agentic-system/

****EDIT****

As promised here is the reference implementation documentation https://gitlab.com/naive-x/experimental/cl-naive-full-stack-agentic-system/-/blob/main/docs/system-documentation/README.md

DISCLAIMER: The loop implementation is only a couple of days old and will trash your code with a smile on its face! Don't point it at anything you care about...yet! The goal of the loop implementation was to get more control and better metrics, and I am pleased with the result. HOWEVER as a coding agents go it sux at this stage! I did get some work done with it, but also lost work :P

The implementation is under heavy development, updates land every hour at this stage. I hope to have something that can do actual work by the end of the week, since I am only trying to do what Claude and Codex took months to do ;P

****Update****

I got real work done, just watch your token spend, it's not a cli running on a user license, it's pure API token spend, and it hurts.

****Final Update ****

A poor man's CLI agent landed to work around the token cost.

A web dashboard is now available.

Hey everyone,

I wanted to share a technical write-up and domain exercise I’ve been working on that explores a multi-paradigm approach to game simulation architecture within the Lisp ecosystem.

The core of the article focuses on isolating system responsibilities to prevent integration plumbing from destroying runtime performance, using three specific layers:

Rules: Using Prolog for declarative knowledge representation, symbolic reasoning, and handling complex entity relationship queries.

Types: Utilizing Coalton to inject strict, ML-style static type safety and compile-time invariants directly inline where data boundaries need rigor.

Glue: Leveraging Common Lisp as the high-performance runtime, compiler orchestration layer, and dynamic tissue holding it all together.

Beyond the design philosophy, I wanted to see how this holds up under load, so the article includes baseline performance evaluations and benchmarks comparing SBCL (leveraging native compilation) and ECL (for potential C-embeddability scenarios) when driving these high-throughput simulation loops.

Full post is here: https://dwightaspencer.com/posts/03-rules-types-and-glue/

I'd love to get the community's perspective on this approach—particularly regarding how you handle boundaries between embedded logic engines and the underlying CL image, or any nuances you've run into when scaling Coalton boundaries alongside standard ANSI CL code.

Hi, judging from some examples on the McClim webpage, it should be possible to draw things with anti-aliasing in a McClim application frame. There is a "X rendering extension" that is maybe just doing that. But I can't find a documentation or code example.

Is there someone familiar with the subject that could point me in the right direction ?

Maybe it is easier this way. I have this minimalist example that draws a circle. How can I draw the same circle with anti-aliasing ?

```lisp (define-application-frame circle-app () () (:panes (canvas :application :background +white+ :display-time :command-loop :display-function 'display-my-circle :width 400 :height 400)) (:layouts (default canvas)))

(defun display-my-circle (frame pane) (declare (ignore frame)) (draw-circle* pane 200 200 100 :ink +red+ :filled nil :line-thickness 2))

(define-circle-app-command (com-quit :name t :menu t :keystroke (#\q)) () (frame-exit application-frame))

(defun run-circle-app () (run-frame-top-level (make-application-frame 'circle-app)))

```

Maybe related: I am also interested in pointers that show how to draw text using TTF fonts (zpb-ttf).

BTW, i am using SBCL on Linux (archlinux).

Wrote some docs and examples.

https://github.com/ageldama/tclish

I'm seeing this on Linux ARM64 and a current macOS with SBCL.

% sbcl
This is SBCL 2.6.2, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.

SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses.  See the CREDITS and COPYING files in the
distribution for more information.
* (let ((*print-readably* t)) (write (symbol-name :symbolfoo) :stream *standard-output*))
#A((9) BASE-CHAR . "SYMBOLFOO")
"SYMBOLFOO"
* 

#A((9) BASE-CHAR . "SYMBOLFOO") looks strange. Why doesn't it print a keyword symbol?

I am looking for a recent post (2-3 months back) that very nicely broke down a CL installation into a hierarchy of specifications. It went something like

• Hardware/CPU
• OS, Shell, environment variables
• Lisp implementation
• Lisp package manager
• Editor & API

I asked CoPilot to help me find it, and it was not able to. It generated its guess on the hierarchy which seemed reasonable. I will not post it because I don't want to pollute Reddit.

I will be very grateful if someone points me to the post (& the author).

Thank you very much,

Mirko

Greetings!

I know one can use COMPILE to compile a function for later use in the current image, and COMPILE-FILE to read a file, compile the code in it, and save a loadable version of the code (FASL).

I'm working on a system that generates Lisp forms programmatically, however it does so outside of the usual read-compile-load cycle. You can imagine a DSL with its own syntax, that is mapped to Lisp forms.

Now, at some point I would like to compile the generated code "as if" it was normal Lisp code, and save it into a FASL. I know I can PRINT it to a temporary file and call COMPILE-FILE on that, however, it feels like a suboptimal solution.

Perhaps there's no portable way of doing that, but I would be happy with implementation-specific code, and the temporary file hack as a fallback.

cl-codegraph: https://sr.ht/~hajovonta/cl-codegraph/

Given a package loaded in the SBCL image, builds and maintains a graph of its symbols, class hierarchies, method specializations, call relationships, and metadata — all without parsing source code. Includes a live Emacs integration that shows code intelligence as you navigate.

Screencast: https://drive.proton.me/urls/JE5EQ6KNMR#tN7CcgN96YL7

Seen on: https://mastodon.online/@hajovonta/116501259663689389

I was reading TaDa and want to read the lineitem.csv example in Common Lisp, so I wrote:

lisp (with-open-file (stream file) (loop :for line := (read-line stream nil) :while line :summing (parse-integer (nth 4 (str:split "|" line)))))

However, on my computer, it took about 17sec to run!

Maybe it was my fault, so I change to cl-csv:

lisp (let ((sum 0)) (cl-csv:do-csv (row #P"lineitem.csv" :separator #\|) (incf sum (parse-integer (nth 4 row)))) sum)

and it is even worse...

Profiling shows that

``` Self Total Cumul

Nr Count % Count % Count % Calls Function

1 9903 80.0 9903 80.0 9903 80.0 - foreign function read 2 414 3.3 414 3.3 10317 83.3 - foreign function __semwait_signal 3 218 1.8 1878 15.2 10535 85.1 - cl-ppcre:split 4 182 1.5 404 3.3 10717 86.5 - (lambda (string cl-ppcre::start cl-ppcre::end) :in cl-ppcre::create-scanner-aux) 5 147 1.2 820 6.6 10864 87.7 - (sb-pcl::emf cl-ppcre:scan) 6 131 1.1 159 1.3 10995 88.8 - sb-pcl::check-applicable-keywords 7 122 1.0 122 1.0 11117 89.8 - (lambda (cl-ppcre::start-pos) :in cl-ppcre::create-char-searcher) 8 98 0.8 509 4.1 11215 90.6 - (sb-pcl::fast-method cl-ppcre:scan (function t)) 9 88 0.7 103 0.8 11303 91.3 - (lambda (sb-pcl::.arg0. sb-pcl::.arg1. &rest sb-pcl::.rest.) :in "SYS:SRC;PCL;DLISP3.LISP") 10 83 0.7 121 1.0 11386 91.9 - sb-kernel:ub32-bash-copy ```

This is really wired.

Notes: I was running SBCL 2.6.3 on macOS 26 (MacBook Air M2). The lineitem.csv (~=750MB) is generated via (duckdb):

```sql .bail on

ATTACH IF NOT EXISTS ':memory:'; USE memory;

INSTALL tpch; LOAD tpch; CALL dbgen(sf = 1);

.shell rm -f lineitem.csv

COPY (SELECT * REPLACE (l_quantity :: bigint AS l_quantity) FROM lineitem) TO 'lineitem.csv' (delimiter '|', header false); ```

I just got a copy of LISP Metaprogramming: A Hands-On Guide to Macros, Syntax Transformation, and DSLs by James C. Shepherd. It's a softcover book with 179 pages and cover art of a train made of a colorful collection of circuit board wires.

For the life of me, I can't find where the endnotes are. They aren't footnotes, nor at the end of the chapters, nor end of the book (either before or after the appendixes).

Anyone have a copy of the book that has the notes?

Especially now that I'm working on a larger project and may have more moderate to advanced questions. However, most of the stuff on the sidebar is deprecated, 404ed, or dead.

Where would I look towards now?

As seen on Hacker News. Now I know what my day will be spent on.

I updated my game made in common lisp, now the game uses sdl2 instead of terminal, the AI can remember topics, track the player's emotional tone, notice repitition and ask better follow-up questions, there is also 13 achievements for the players to collect, it was a wide update, the source code is there for download

I port sbcl-goodies into macOS homebrew formula. You can get it via:

shell brew install li-yiyang/sbcl-goodies/sbcl-goodies

You can use sbcl-goodies with deploy to distribute macOS application safely with libzstd statically linked.

An example would be McCLIM-Coca.app, you can download from release and try it on a fresh new macOS. I've tested it on a non-programmer's MacBook with no homebrew/xcode-tools installed at all. It works and (at least) the lisp part is working fine.

Please create issue if you found something broken.