softwarewright

I built an experimental extensible typed array programming language (with tools, libraries, demos, etc. actively under development). Via meta-programming (macros) and Rust shared library extensions it lets you write code that runs on CPU or GPUs (Apple, NVIDIA so far).

> https://blog.softwarewrighter.com/2026/10/16/array-languages...

I originally wrote gpu extensions that use OpenCL/CUDA. I more recently added a modular mojo backend that allows me to use Metal instead of OpenCL on Apple Silicon.

I tried this in a custom ML array programming language with mixed results. I created a literate programming document about it. https://sw-ml-study.github.io/demo-decision-model/concise-he... -- it has some analysis of the python and some other approaches.

I should mention that I am trying to apply a Jev-inspired approch to a trained-from scratch, in-browser typed decision model that attempts to recreate the deterministic classic Eliza program.

I have been using Claude CLI, Codex, Gemini, and OpenCode (Z.ai GLM-4x/5x) for quite a while. I've seen the code they all produce. I've had to add checks as forcing functions to get them to create more loosely-coupled, readable, maintainable, extensible, testable code. They often get stuck, "complaining" that the rules are too hard to satisfy, and then I show them how, make them take different approaches.

I do not mean to anthropomorphize their work, but I do need to improve what they produce. I think a lot of push-back to vibe-coded projects is that the person asking an AI Agent to make something do not or cannot improve what it produces, which goes back to the question asked. Is it worthwhile to learn programming now. I argue that it is.

So, it would be better if models were trained to produce provably correct code, and agent harnesses are improving to help do this, but the models themselves have been shown to be trained to provide the answer they think you want to hear, and declare a task done as fast as possible. They hallucinate (or lie) about running tests, even about writing code at all (sometimes).

How do cloud models "learn" to write better code? Where are the projects that fine-tune an open/local LLM to "learn" from its mistakes. I have yet to see any model improve on its own.

A lot of the best code I've seen is closed source, and unlikely to be represented in existing training data. A lot of the worse code I've see was online. Maybe newer coding models are getting trained better, but most I've tried are years out of date. Maybe my view is affected by trying so many LLMs. Very few have been great.

My experience working with programmers for decades (as an individual contributor, team lead, architect, release engineer, engineering manager) is that great programmers are rare and most programmers are good enough and a few flunk out. Since AI is trained on "the internet" it sees and learns a lot of bad habits, poor coding examples, shortcuts, oversimplified solutions, and therefore, by default, produces code that can be improved. To use AI coding agents effectively, you must be able to spot bad code, suggest better approaches, add guardrails, tests, checks, guidance, etc. to keep the agents on track and improve their output. If you do not deeply understand data structures, algorithms, idioms, best practices, footguns, design patterns, etc., you cannot help the agents provide better code.

Interesting link/content and it seems complimentary.

One thing that is missing from both of our approaches is the ability re-train (fine-tune) coding models "overnight" so that they can "learn" from the prior day and changes since their training cutoff date.

I have found some things I can do to improve my work based on this, thanks.

_Pentad idea_ -/- _MLOS relevance_ -/- _Action_

Closed autonomic loops -/- Very high -/- Adopt architecture vocabulary

Deterministic replay -/- Very high -/- Strengthen event/replay contract

Model minimalism -/- Very high. -/- Extend later to compute-placement ladder

Durable vs active population -/- High -/- Define registered vs resident capacity metrics

Standing queries -/- High -/- Future policy/watch abstraction

Provenance by construction -/- High -/- Record policy decision causality

No model/NLP in hot path -/- High -/- State explicitly as invariant

Are you saying that AI coding agents cannot produce working code? Or are you saying that it produces something that cannot be explained or understood?

If I used a macro to generate code that gets compiled and linked to code someone else provided, how is that different from asking a coding agent to generate similar code and linking to other coding agent code?

Is your concern that the output is probabilistic vs. a macro or code generator producing code deterministically? I apply engineering practices to ensure the results are suitable.

I do understand that AI is fundamentally different (and I've been studying ML in depth for more than a year). My comparison was in terms of tools increasing productivity, not how they do that.

I was a "10x programmer" on several projects and I am 10x more productive now than I was then (at least). I can create in a few days by myself (with agents) what used to take months (with a team of people).

Maybe I'm producing what some consider "AI slop" but the things I've built this year work to my satisfaction, are fun to make, and I am constantly learning new things. And I am doing this for fun but also to learn by teaching, so I build educational, visual things to share with others.

I'm in a research/prototyping phase with no truly verified results yet, but I have all the hardware I need to do actual testing. I have an OS that boots in a VM, it just isn't verified to have practical value yet. It could be an AI coding agent's fever dream until I use it anger. So far Apple Silicon only, but most of my systems run Linux and most of my GPUs are NVIDIA, so moving development from Mac to Linux soon. It does have tests, demos, docs. Iterating on it daily.

https://github.com/sw-ml-study/sw-os-ml

I also have been implementing small model inference:

https://github.com/sw-ml-study/moe-microscope

I should clarify that by Apple Silicon I mean it boots Rust no_std on ARM. Does not use GPU yet. Plan is to use Rust without CUDA libraries. This project is more likely to use an NPU on a ARM dev board before it can use an NVIDIA GPU, and might never be able to use Apple GPUs. Goal: run on no-longer-supported by CUDA GPUs.

Using agents to micromanage agents is something I ended up doing.

Part of the fun is solving puzzles where the coding agent gets stuck and me then giving it technical direction. Especially when an agent says that something cannot be done in software (I show them how it actually can be done).

I am in the more motivated than ever camp.

But what if I use AI to write live demos where you can write machine code, debug it visually in your browser, punch data on virtual punch cards? What if I used AI to generate videos about this, generate the artwork, backgrounds, narration, intro music, etc. I guess I am just a meta-tinkerer :-)

I am also pursuing something similar (complementary?) to this (recently started writing a Rust-based "distributed OS" that manages ML resources in a network of heterogenous systems: varied cores, system RAM, GPU VRAM, I/O). So my focus is not so much distributed agents, but more distributed inference (and fine tuning) that would benefit agents, distributed or not. I may blog about my work soon.

Your posted link is helpful, thanks.

Thanks for the UX change; it worked well (except for links to relative images).

Is the intent just to use it to view markdown with colors, spacing?

Do you plan to provide ways to export it to something like PDF, html w/css, etc.?

Let's say I wanted to take a README from my github repo and blog about it with the pretty version in a blog post, how would I do that?

serious question: do you program in machine code or assembler or use a higher level language? do you use design patterns and functional approaches? metaprogramming, code generation, templating, app frameworks?

Each tool, abstraction, language feature elevates coding to get more done with less (more concisely). Programming is a social activity, since source code is meant to be read by humans (at least historically) even if it is just yourself later.

I'm not trying to talk you into using AI coding agents, but explain why I find them fun, and I've written a lot of code by hand over decades, from spaghetti assembler code to structureed programming to object oriented to functional, etc. Each advance in the industry has been a new and diiferent kind of fun for me.

having to give clipboard paste permission is less than ideal. Why not also offer a text area to paste into?

I was a hobby programmer in the 80s, but that was after college. I was a hobby programmer in the 70s via my high school's library having a terminal to access a mainframe for self-study programming courses, and I built mail-order computer kits which I programmed in machine language.

I think AI is a great tool, but requires safeguards. I use it every day, but I use a lot of tools to reign it in, keep it on task, check its results, and force it to follow an engineering process.

I don't know about the "as quickly as possible" part, since there needs to be guardrails, but improving AI should be done sooner rather than later. e.g, instead of training to give the answer it thinks you want to hear, it should be trained to give provably correct answers. instead of being trained and fine tuned and then let loose, it should be able to continuously learn and improve.

While people keep chasing tokens/second and vibe-coding, I'm more interested in correct results per kWh, sustainable and ethical AI. Also, I'm worried that there will be an increasing digital divide between the wealthy and the rest of us, so I do want AI to be available and not locked up just for corporations and governments.

To me, the fun is solving problems, and AI let's me solve more problems, harder problems and more quickly. I was happy to move from assembler programming to high level programming languages, to 4GL, to frameworks, tech stacks, etc. Moving to AI coding is just another shift in solving problems at a higher level with more productivity.

hacking microprocessors was fun. building complex systems using AI is fun, too.

I am working on developing a distributed operating system for managing machine learning resources (the entire memory hierarchy, networking and compute hierarchy). I worked in O/S development early in my career, now retired and ML is a hobby I've invested in over the past few years.

I'm curious about:

- how to "upcycle" end-of-life NVIDIA GPUs, like K80, M40, P100, etc.

- how to offload MoE expert calculations to MCUs with NPUs, possibly FPGAs

- how to manage a 10G LAN-attached network of older Xeon servers with the above GPUs and USB-attached MCUs as a machine learning "fabric"

- do ideas from IBM's ACP/TPF O/S (now Z/TPF) carry over?

- do ideas from IBM's Workload Manager (business priorities managed resources) carry over?

- can I bypass end-of-life CUDA driver support for older NVIDIA hardware by using Rust/Vulcan?

- can I leverage the architecture of Freetoken (MoE caching/routing, Engram, KV-cache compression) and other approaches like Baby Dragon Hatchlings, Hierarchical Reasoning Models, Tiny Recursive Models, Recurisve Language Models, Multi-token predicion, etc?

- is anyone else intersted in actually building something like this?

I've explored many of these parts individually, now combining them...

forgot to mention: I use my language to run code in a browser, so people can try ML experiments and visualization with no download, no sign up, no colab, no GPU.

Also, I'm working towards running my code on embedded systems, including bare metal (no Linux, no RTOS). I'm looking into custom FPGA circuits, too.

Python isn't great for me, for these uses. Rust is, and my language is a Rust DSL.

But I am creating programs to manage the coding agents for me. Of course I am using coding agents to do that. It's turtles all the way down :-)

me too; and my coding agents are slowed down (from developing features) because I require them to refactor the code to be more readable; my code metrics tests force AIs to leverage functional programming and design patterns).

Yes agents can produce code that compiles and runs, but I had to add tools to keep them on track, document their work, follow a process, check their outputs. I also use other AIs to generate developer documentation and review code.

It is like managing a bunch of idiot savant eager-to-please interns, except unlike interns, coding agents do not (yet) learn and improve on their own.

I have the same "1/30th ... simultaneous" experience with coding agents, and I am having fun. Directing teams of agents to solve many problems (or create many useful things) for me has its own fun challenges/puzzles-to-solve.

Some of the fun is redirecting coding agents when they get stuck, by showing them code or design they could not work out on their own. Some of the fun is designing tools to rein-in AI coding agents, keep them on track, and verify their outputs. Some of the fun is exploring new areas for me: compilers, game dev, language design, emulators, embedded, etc.

So I am having fun at the CTO/PM/Engineering Manager level but also at the lowest coding level.

I've been coding since the early 70s. This brings back the joy I had discovering microprocessors and electronics.

This is interesting. It would be even better if ones coding agent also got better at its coding abilities every night. Otherwise, agents might re-introduce the same class of bugs that your nightly improvements keep reacting to.

This would require logging agent actions during the day, analyzing it at night, identifying things the coding agent could do better, and update its AGENTS.md memory (relatively easy) or fine-tune the agent (if local LLM, and the fine-tuning cost was acceptable).

It would be nice that when a person corrects an agent's mistake this was captured and fed back into a nightly agent improving process.

I picked an ETF so there may have been less analysis (no business to analyze). I will look again for "perspectives"

I like the upgrades and wall repair features. I made it on to the leader board :-)

nice. is there a way to repair burned houses or put out fires?

nice UI, analysis took a while, but results looked very good.

feedback: different users have very different goals, risk tolerance, knowledge, experience. I would wrap this with very focused UIs for different audiences. Many people want growth, some are risk-adverse, some are income oriented (for example)

The analysis output could be customized for the user based on a brief interview about where they are in their investment journey and what their goals are. Without this, the analysis is very general (which if fine for experienced users).

This is a good approach. I am also am trying to integrate ML and AI into a language as first class concepts, but currently more focused on the ML side, but also using inference. https://sw-ml-study.github.io/sw-mlpl/

Nola asks: "What if calling an LLM were a language primitive?"

sw-MLPL asks: "What if the mathematical operations used to build and understand ML were language primitives?"

Your approach shows some added some value that I might try to incorporate into my ML array language.

Nola puts the LLM into the language. sw-MLPL puts the math of ML into the language.

Claude Code, Codex, opencode (Z.ai GLM-5.x), sometimes Gemini -- most of my work is at Mac iTerm2 CLI or Arch Linux terminal. I sometimes use emacs as the coding agent, but rarely JetBrains IDE or vscode (more for reading/debugging code).

I supplement this with my own vibe-coded tools that help agents plan, perform sagas/steps, stay on track, tools that check the code produced, tools that check the produced documentation, tools/process to limit AI coding agent write access to files outside their assigned project, and tools that allow coding agents to collaborate (shared wiki, mailboxes, gh cli issues, etc.). I have written test frameworks that my AI agents use to detect functional regressions.

On top of this I used web-based or Desktop: Claude, ChatGPT, and/or Gemini to do research, architecture, requirements, planning, design, and later review; to suggest improvements, answer questions, etc.

And I am trying to switch to opencode using local LLMs, served by llama.cpp, Freetoken, or vLLM, on 12G, 16G, and 24G VRAM GPUs. So far the cloud LLMs are faster/better, but recent qwen3.x MoE models look very promising.

This IBM Research looks very promising: https://research.ibm.com/blog/northpole-llm-inference-result...

which I found after watching this video: https://www.youtube.com/watch?v=G4nEpY1LYzM - The AI Chip With No Ram (and still 22x Faster)

I am curious about what Rust-based extensions I can add next to my custom machine learning programming language.

> https://github.com/sw-ml-study/demo-extensions shows my first attempt at an extension, desktop graphics. README shows a Conway's Life "Glider" on an interactive view of a 3D torus (and other desktop examples).

The underlying language is implemented in Rust, and supports running in a browser via WASM, but the language itself is an array programming language I created to help me visualize my study of ML. (This is my non-Python response to Jupyter notebooks and Google Colab)

Then I wanted to visualize ML-related Math concepts so I added some demo repos.

And then I added language features to make it a more general purpose application development language, with libraries as a way to share code. So I added I/O, functional programming features, etc. and related demos. Dogfooding!

And more recently the dynamic Rust extension mechanism to add things that cannot be written easily in the array language itself (or for features that would clutter the language).

Maybe I can add a networking extension or an infinite precision math library.

So my curiosity is around what belongs in the base language and what belongs in optional dynamic extensions.

I am a single person LLC so my "production" is just me using AI to build things.

I use MCP for some things, like Playwright; for web UI development, but I also use CLIs, especially custom CLIs I create that have built-in help for the AI coding agent to use. I just to run my command (in the path) with --help and it figures out how to use. This seems more straightforward and efficient than MCP.

I have written MCP servers for all sorts of things, like monitoring remote systems, operating a PvP game as PvAI, others but lately I just create a new CLI with help. I use this with Claude, Codex, Gemini, and opencode (z.ai GLM) instead of dealing with how each agent registers MCPs.

I am trying to make it easier to use LLMs on older, cheaper, smaller GPUs. I'm taking a similar approach (move MoE expert weights to disk, avoid wasting VRAM on these). My goal is also to run models that do not fit. My work also suffers from AI documentation issues. Where my approach differs is that instead of running an LLM that doesn't fit slowly, run many agents in parallel sharing the streams of MoE experts weights, to increase throughput. I envision a team of AI agents sharing a pretty-good-at-coding LLM that does not fit to collaborate on a set of related features, being developed in parallel.

My work is showing promising results (if you can get past the way the AI tries to describe what I am doing). https://sw-ml-study.github.io/emufpga/index.html

I am doing this work initially on a 6-Xeon-cores Linux workstation with an RTX5060-16G to run MoE models larger than that. Then I will be moving this to a server with a lot more cores (Dual 32-cores) and a mix of SAS HD and SSD drives, using older GPUs.

Ultimately, I hope to build some FPGA/MCU "accelerators" that process the expert weights on systems with not enough CPU cores to offload the experts. If I can enable large capable models to run on older hardware, keeping the limited GPU VRAM for context and things that must be in VRAM, I can get useful work out of my old refurbished systems without paying today's RAM and VRAM/GPU prices.