[0] https://github.com/rspeele/infix.el

[1] https://github.com/rspeele/LicenseToCIL

[2] https://github.com/fsprojects/Rezoom.SQL

[3] https://rspeele.github.io/FParsec-Pipes/Intro.html

Yet, it's utterly hopeless to try to take the same stance visual artists are nobly holding. Of the programs I use daily, how many have I ever even glanced at the source code? I could count them on my fingers. And I'm in the target audience: a programmer, enthusiastic about the trade, one who has contributed to open source...

Conclusion: within a rounding error of NOBODY cares about the code. Of the weavers who were displaced by the automated looms, or the furniture-makers displaced by mass produced pressboard, some of the most skilled could still ply their trade for the rich who wanted to flex their bespoke handmade goods. Programmers writing code by hand will not even have that luxury market. It makes me depressed but I don't see any way around it.

My hope is that I can use my knowledge, willingness to spend long hours fighting with a computer, and industry experience to at least make better software with agents than the average vibecoder. I sadly don't think I'll get anywhere trying to play John Henry vs. the Steam Drill, trying to beat it with my hand-typed code. Maybe somebody who's 10x the dev I am can do that, and Godspeed to them, but I thought I was pretty decent and I don't have a chance.

Hell, it's not even possible to prove any code was written by hand, other than by having uploaded it pre-2024ish. For this reason I really feel bad for those coming up right now, who have the same enthusiasm and fascination for Real Programming that I did, but no way to prove themselves and no motivation to in a world that values that skill less all the time.

I also initially looked around the desk for a physical cartridge, such was the effectiveness of the rest of the “game”.

First job had me using a programming language I wasn't super familiar with and trying to add a feature to a codebase 100s of KLOC, all written by other people. Definitely a sink-or-swim moment. My skills of reading and navigating the dreaded Other People's Code were all honed over the next dozen years.

That being said AI is a lot better at reading code than I am, as demonstrated by its ability to find incredibly subtle bugs in huge codebases. So I'm not even sure those code reading skills are all that useful now. When I have to review somebody else's code I get more mileage from pointing an AI at it and asking targeted questions like "how does this handle when a Foo's approval is revoked" than reading it myself line-by-line. I'm not saying I never use those reading skills but the ability to get the big picture, chase down deep callback chains, know where to look... those skills are likely to atrophy.

It's like using GPS vs. knowing the roads as well as a cabbie. GPS gets you pretty damn far for zero effort.

The sub-agent separation is still valuable to keep context clean for the orchestrator, but I just have no reason to use Sonnet as the grunt-work implementer because I'm finding it hard to run out of tokens with Opus 5.5 on a $200 subscription plan. It's really really good at subjective quality of work per token used.

If they can just keep working on it and make sure to train it on all my past emails, it'll be a perfect simulacrum, and its oily token secretions will be impossible for my friends and colleagues to distinguish from my own writing. I'll have one that's just like me and you'll have one that's just like you. And then we can automate away those pesky distractions that occasionally delay us from consuming content perfectly matched to our interests. Won't that be grand?

It's like Clippy pops up and goes "It looks like you're trying to maintain a shred of human connection in an online interaction. Would you like a smiling skinwalker to do that for you instead?"

In my circles I've noticed it's very easy for us to rationalize why our previous favorite language is also the perfect language for the agent era.

If your favorite language before was Python, why, LLMs are fluent in it! So much training data! So many libraries! Home of machine learning! None of that pesky compile time, agents don't need compile time safety anyway, they write such good test coverage! It's The Perfect Agentic Coding Language.

If it was Rust, by jove, an agent can easily handle the headache of satisfying the borrow checker, and now you get the best of all worlds! Safety! Near-C runtime performance! Abstractions! The only reason people didn't use Rust before was it was Too Hard and there were Too Many Furries and now it's not hard and you don't have to interact with them, so get on board. It's The Perfect Agentic Coding Language.

If it was Golang, oh my goodness, what a choice. Pretty fast compile time and pretty fast runtime. Agents get a tight feedback loop with build->run->test->edit. Not very complicated, code has to be written in a straightforward banging-rocks-together way. Good stable ecosystem! Rob Pike designed the language for people he said were "not capable of understanding a brilliant language but we want to use them to build good software." That's an arrogant, demeaning way to describe your colleagues but if they're LLM agents it's dead on! It's The Perfect Agentic Coding Language.

I could go on and on. I'm not immune either! My own favorite language is F# and when I feel like self-justifying, I play the same game:

It has access to the .NET ecosystem like C#, but I don't have to constantly remind the agents to prefer a style with immutable data and pure functions, they idiomatically do that in F#. Files have to be in order and can only refer to symbols defined "earlier" in order, if you want mutually-referential types or functions they have to be declared as such in a joint statement, so spaghetti is hard to create: each project's codebase naturally ends up in a layered bottom-to-top architecture. The language is terse enough to be token efficient, without being symbol soup. FSX scripts can be generated during agentic code reviews to demonstrate repros for discovered issues. If there's any type of code that still warrants me jumping in and writing some myself, that code would be data type definitions/domain modelling, and F# is a joy to write those in. It's The Perfect Agentic Coding Language.

If your favorite language before was Python, why, LLMs are fluent in it! So much training data! So many libraries! Home of machine learning! None of that pesky compile time, agents don't need compile time safety anyway, they write such good test coverage! It's The Perfect Agentic Coding Language.

If it was Rust, by jove, an agent can easily handle the headache of satisfying the borrow checker, and now you get the best of all worlds! Safety! Near-C runtime performance! Abstractions! The only reason people didn't use Rust before was it was Too Hard and there were Too Many Furries and now it's not hard and you don't have to interact with them, so get on board. It's The Perfect Agentic Coding Language.

If it was Golang, oh my goodness, what a choice. Pretty fast compile time and pretty fast runtime. Agents get a tight feedback loop with build->run->test->edit. Not very complicated, code has to be written in a straightforward banging-rocks-together way. Good stable ecosystem! Rob Pike designed the language for people he said were "not capable of understanding a brilliant language but we want to use them to build good software." That's an arrogant, demeaning way to describe your colleagues but if they're LLM agents it's dead on! It's The Perfect Agentic Coding Language.

I could go on and on. I'm not immune either! My own favorite language is F# and I play the same game:

It has access to the .NET ecosystem like C#, but I don't have to constantly remind the agents to prefer a style with immutable data and pure functions, they idiomatically do that in F#. Files have to be in order and can only refer to symbols defined "earlier" in order, if you want mutually-referential types or functions they have to be declared as such in a joint statement, so spaghetti is hard to create: each project's codebase naturally ends up in a layered bottom-to-top architecture. The language is terse enough to be token efficient, without being symbol soup. FSX scripts can be generated during agentic code reviews to demonstrate repros for discovered issues. If there's any type of code that still warrants me jumping in and writing some myself, that code would be data type definitions/domain modelling, and F# is a joy to write those in. It's The Perfect Agentic Coding Language.

For an example, see my MSPaint drawings in the README (scroll near the bottom) for this tiny little project: https://github.com/rspeele/meshorient

I redrew those for the README but IIRC, I drew something similar when explaining how the feature would work to the agent.

And in reverse, after describing an architecture or an algorithm to it, I'll sometimes ask it to draw a diagram for me to demonstrate its understanding. If it draws the picture in line with what I intended, I conclude that it has gained the necessary context to proceed. If not, I know I explained something wrong or at least insufficiently and need to provide clarification. There are some domains where a picture is worth a thousand words.

It also helps cut through the Claudese. "Your decision is needed for one edge case, found by the gate. When a T-joint meets an endcap that the mesher solves by a fan, should this bisect a fan slice or raise a warning?" I'm sorry Claude, I am not from Missouri but you are going to have to Show Me this one with a picture.

Of course you can save pictures to files and open them with external tools, but it's nicer to have them inlined into the chat history when that's exactly what they are: part of the conversation.

My biggest conclusion from this test was: the most efficient use of my weekly Astra budget is as a reviewer/consultant for work done by Opus. I don't have Astra write much code right now, but I do have it reading a lot of what Opus writes. Of course with the way the AI landscape shifts the balance could be the exact opposite 2 weeks from now, but either way having 2 "smart" models available from 2 different companies is a boon.

Seeing how each model preferred its own flavor of code shows that, even from a "blind" fresh context, a same-model reviewer will still often look at the work of another incarnation of itself and go "yep that's how I woulda done it" and not be as likely to realize that there was an alternative path or implicit assumption/mistake in the work.

Astra used 215% of a week's budget (I burned 2 free resets) and took 13 hours. Opus used 20% of a week's budget and took 20 hours. Both were asked to use lesser sub-agents for implementation grunt work at their discretion (Luna, Sonnet) as long as they manage and review the output.

The timing comparison is not that interesting because the wall-clock speed mostly reflects how often they ran the (large, slow) test suite, not their coding speed. Although in the past my gut feeling is that OpenAI models do generally respond faster.

The quality of their implementation was more interesting. There turned out to be a bug in one of the unit tests the agents were trying to pass. Opus interpreted the natural-language requirements from the task packet, found the test bug, and fixed it. Astra tried hard to solve the problem without altering the test suite. In practical terms Opus got much, much farther into a useful implementation. Astra was still stubbing out and faking critical parts of the implementation (B-splines) and since it ultimately couldn't pass the full test suite, finally gave up on its implementation. Astra wrote some useful tooling in the process of its efforts which I ended up integrating into Opus's version of the code, but otherwise its approach was behind.

Now, this is just one comparison in one domain, and arguably Astra's strict adherence to the tests as-given is a good thing. But Opus wasn't merely loosening the rules / moving the goalposts to pass, it spotted an actual bug, and was more successful at doing what I actually wanted. And the cost difference was Astra-nomical.

Out of curiosity for an interpretation free from my personal bias, I gave Astra a hint from Opus and permission to change the test in question, which it did, and got a bit farther, but still ultimately didn't produce a working implementation (to be fair, Opus's was not completely working either, but was closer). I then fired up fresh agents to review the two repos. Predictably, an Opus agent thought the Opus-written repo was the better basis to build on, and an Astra agent thought the Astra-written repo was the one to keep. They were not explicitly told which was which nor did the commit trailers say, but I assume they can tell. However, after doing this twice each, I saved the 4 review reports into another folder and did yet another meta-review of the 4 reports, so each would see the arguments and critiques both directions. In this meta-review both Astra and Opus converged on preferring the Opus implementation.

In no way does this mean LSP is a perfect solution, but anything synchronous would be a step backwards.

I still count myself as "dejected" overall. I'm dejected by the economic shape of AI which seems destined to keep concentrating outsized rewards to the top few who own it or have enough capital to shackle it to their will. I'm fearful that intelligence, once it becomes a commodity you can rent any time you may need it, will be socially devalued in our already anti-intellectual society. I worry that in a couple decades we may resemble the world of "The Machine Stops" (1909), where nobody really knows how things work.

Of course we already live in such a complex world, no one person has complete knowledge of the "stack" they rely on. I can write software in C or assembler but I can't design a CPU and don't really understand how one is manufactured. (I may someday study that field, but I haven't yet!) But I take solace in the fact that somebody out there, has put the time in to study each of those things and is an expert in them. At every layer and in every niche of our engineering world there are masters of their craft, and there are students learning the fundamentals to keep that knowledge alive and growing. What if in 30 or 40 years that is not the case, and there are whole corners of knowledge the modern world depends on where everybody is reduced to "I dunno how it works, but Claude said..."?

Reduce has an accumulator and a 2-arg function and languages are not very consistent amongst each other as to whether it's reduce(initial_acc, callback(acc, elem)) or reduce(callback(acc, elem), initial_acc) or reduce(callback(elem, acc), initial_acc) or what.

Hard to remember. Also some languages have a version of reduce that doesn't take an initial accumulator at all, which is just a footgun waiting for you to hit an empty collection. Also ALSO, the accumulator can easily become awkward in languages that don't support anonymous types or don't support easy mutation of an anonymous type record. Which is most of them!

[1]https://theonion.com/amazing-new-hyperbolic-chamber-greatest...

If Anthropic can absorb proprietary or GPL code into their models, which they rent usage of for tens of billions of dollars in revenue, and successfully claim that this violates no licenses, then I can also consider the output of those models "clean" for purposes of my software I give away for free.

I think people in (software) tech are currently more prone to overestimate the capabilities, because LLMs in a harness are genuinely excellent at programming. Programming is the perfect LLM task since 1. it's symbolic manipulation, 2. there is a vast corpus of high quality training data, and 3. most mistakes can be harmlessly caught at compile-time or unit-test-time. Especially point 3 makes it so that just throwing more "effort" at a problem, something the machine is endlessly willing to do, virtually guarantees an improved result.

In contrast there is no way for the machine to write a unit test to double-check its work when what it's offering the user is a legal document, or a medical diagnosis, or a recommendation of "yep that mushroom is safe to eat".

I've often seen the "Gell-Mann Amnesia Effect" referenced with respect to LLMs. It is said that most people can tell the LLM is not great at their own subject of expertise, yet they still trust it for other subjects where they can't personally assess the quality of its answers. Imagine how bad this is when the LLM actually is great at the thing you have expertise in.

If you have Foos, and users have permissions that control what they can do to a Foo, you'd like to have a function `GetPermissions : (UserId, FooId) -> Async`. If users can frob Foos you'd like to have a `FrobFoo : (FooId) -> Async` function.

But as soon as you let users select multiple Foos, or god forbid, an entire folder containing Foos, and bulk-frob them now you have to write `FrobFoos : (List) -> Async`. And to avoid the implementation of that causing another 1+N checking permissions, you also need `GetPermissionsBulk : (UserId, List -> Async>`. The singular forms of those functions, to avoid duplication, now become wrappers over the bulk forms.

The logic becomes harder to trace in the rewritten, bulk forms of the functions, but they are efficient.

Next the customer hits you with a request like "let's have a smart-frob function that works on all the selected foos. For foos that are red, it frobs them, if they are blue, it fizzles them". Now you have to bulk-load to select the redness or blueness of all your Foos, build two separate lists, red and blue, then call your bulk-frob and bulk-fizzle functions accordingly on the two lists. Again the machinery to turn the requirement into a batch-shaped thing is not a lot, but it does kind of obscure the original business requirement.

At various times in the life of the project you will have a feature that starts as a "always done on one Foo" thing because it's triggered by a button on the detail screen. Then somebody will possibly come along and want to do it in bulk later and you have to rewrite the implementation. Unless you have very strict code review that everything MUST be written in batch-style taking a list of IDs up to the API layer.

I wrote a library[1] many years ago to solve this problem and allow the straightforward, non-batch versions of the functions to be automatically batchable. The idea is kind of like what React did for frontend dev: React was not faster than mutating the page with jQuery soup, but it was much faster than replacing the entire DOM on every render, and it let you write your code as if that was what you were doing. That was a very simple mental model and much less buggy than jQuery soup.

The idea of my library was basically borrowed from other functional languages with a resumption monad, meaning that instead of an opaque async task to go do a thing, you have a "plan" which could either be a. done or b. waiting on some errand that requires firing off a query. If you have a list of plans like from a loop, you could step all of them to the next errand they are waiting on, then fire those off in a batch. So plans could be composed linearly or "batch-style" depending on your preference[2].

What makes it very powerful is the combination with an F# type provider that could analyze your SQL and automatically determine a caching profile for each query. It knows what tables the query reads from, what tables it writes to, whether it uses any impure functions like random(), etc. So within one transaction, it wouldn't re-run the same pure query again, it would pull the results from a local cache -- except if another command issued in that transaction updates those tables, the cache is automatically invalidated. This solves the other code smell that starts to accumulate as you try to write efficient database code in a complex app -- keeping materialized objects loaded in memory and passing them around to other functions so they don't have to re-query for them.

Anyway, it was a little too weird to catch on, and I was a little too burnt out to maintain it.

[1]https://github.com/fsprojects/Rezoom.SQL

[2]https://fsprojects.github.io/Rezoom.SQL/doc/Rezoom/README.ht...