I think this is indeed the direction, but am wondering is anyone actually trying it right now? Love to explore it.
I think for now the answer to adaerlangsql+++ is just Rust - but its semantics have always been about human usability.
Humans have this thing where we can only keep 7 things at once and have to juggle our context, but recall seems much more broad than model contexts.
If we were to start designing a language and toolkit based around LLM context sizes, limitations and quirks - how would that look?
Also terseness and operators are one thing, but what if it’s the other way around - English words etc - can have a much bigger vocabulary of things that can be done but can easily be generated on the fly.
For a new LLM language realistically you would need to probably either write or convert a shit ton of software to it first if you are to train an adequate model on top of it …
And also what about “IDEs” for agents? So far they are clumsily using human tools - just looking Claude string along bash loops and greps to try to eek out meaning form code _it itself had written a week ago_ is frankly frustrating.
There must be a better way and some rich agent specific tooling for code exploration and verification.
Anthropic stance has always been “yeah we tested them all, grep is better” but I still am not convinced - just by the fact that it constantly fails one or two attempts before “figuring it out” yeah it’s fast anyway but it could be _faster_ and could allow the agent to “think” in code space more and not have to validate itself at every minute step …
What I want tho would be Rust+Akka for example. There has to be a distributed execution mechanism that is as seamless as Java’s GC. Then the distributed execution mechanism needs to evolve to also be as light weight and “zero cost” while being seamless like Rust’s compile time memory management.
This is why you see my comments regarding the way AI based coding is going to, I have already tasted the future in such tools, and even if they have issues today, they will eventually be ironed out.
Funny how all of this changes with agentic development - once you setup your agents and the initial productivity euphoria , most of the time you spend in deep brainstorming and leave agents to “handle the details”.
Which is both liberating - a lot less punishing mentally and not requiring so much flow focus, but on the other hand you have to keep more loosely held context in your head.
And agents need you attention constantly throughout the day, you leave them working overnight. While you are not in the office etc, and it’s hard to justify when an agent just needs “a quick look” or some confirmation and direction. You leave being paged all the time so you never really relax.
I think a lot of developers will end up feeling what founders actually go through, for better or worse, but also without actually getting the golden ticket option founders usually hold.
It’s just a very different mindset for work, though maybe requiring less chemicals to actually make work
Once everyone is using these tools, the rat race will have caught up and we'll have no choice but to race with the other rats. The punishment will resume.
Isn’t “sandbox capitalism” - real capitalism and what the us is trending towards is the “Wild West” capitalism with monopolies, trusts, and all the other anti competitive things that arise in the free market if there is no external force that tries to keep the market “fair”?
I mean this is not the case for either, but the systems are setup to drift in these directions - a market needs some sort of regulation to keep things sane, otherwise you end up with standard oil and the like.
You want the people with guns controlling things to be at least nominally interested in “the people” and produce more than just “return on investment”.
Not saying that China is like this or that US is bad, but saying that China is bad because it is “controlled capitalism” is kinda missing the point of what it should be in the best case.
I always try to think how product owners deal with this. I used to write a lot of code, so did my colleagues, but the product owner was the one driving the effort - they definitely didn’t know how to code, but they “shipped” results regardless - they develop relationships with individual engineers, make sure to understand their strengths and weaknesses, insist on automated testing and then hand verify results, whenever on assumption the engineer expressed but turned out to be not true they push to extract the uncertainties.
Slowly build understanding of what is possible, push back on engineers suggestions and don’t approve stuff blindly, but relying on results to guide them not the implementation.
It is very very similar feeling. -you need to know your models and harnesses (e.g. your … team). You don’t need to know the specifics of the code but doublecheck with different personalities if the assumptions are correct, test them.
And ultimately shipping bugs is a given , human engineers do it _constantly_ it’s the resilience systems you build around that which saves you, tests, canaries, rollbacks, feature flags, everything we already know how to do - just use that and imagine yourself the product owner.
I apologise for the tangent but doesn’t this “future” feel off?
We’re improving the experience with navigating all of these noisy, nasty, ugly, toxic and dangerous car sewers (aka car streets) that actively robs us from our humanity and leads to isolation?
This all feels kinda like the Soviet Union building a shit ton of concrete “monuments” everywhere, pretending that was what people “wanted”
The tech is truly impressive but I wish we were able to step out of the local maxima of “optimising this shitty experience until it is less shitty” and start taking “optimising live in cities so it feels nice again” as an actual goal?
Some countries seem to have stumbled on it and the science of urbanism is progressing, but man if that amount of ingenuity that went into self driving cars had went into green and efficient cities…
I've had a lisfranc injury, which while not life threatening is very serious and the quicker the surgery is done, the better outcomes.
My podiatrist did X-Rays incorrectly, I told her I'm seeking 2nd opinion just to confirm her findings. I've found a guy that specializes in lisfranc at Rush. He performed correct weight bearing x-rays. It was a bad sprain and not a torn ligament. It took 12 months to completely heal but I was walking mostly normally after 4 months.
Always SEEK 2nd and 3rd opinion if it is something serious. You can also "find" algorithms use for diagnosing and treating suspected condition to make sure your physician is up to speed.
Not all physicians are equal. They also deal with burn out, and have better and worse days.
Hmm I feel like the social media aspect would be way more useful for democracies in general.
I remember reading about Switzerland’s government service that tracks each politician, their political actions - which positions they take, which laws they promote, etc. and comparing that with which companies and investments they, their famalies and their close connections have.
All quantifiable data. I always thought something like this was _essential_ for any democracy in general - follow the money and “qui bono” and all that, thought it would be cool to build one. But of course prohibitively expensive for individuals small teams. But with all the ai - this could definitely be a thing.
If it all boils down to “verifiable corruption rating” as a single sound bite, it could seriously affect public opinion I feel. Hope someone gets on that idea someday.
Hmm how does your custom harness compare to Claude’s?
I’ve tried the various alternatives (opencode, pi.dev) but for “have several physical machines, each running an orchestrator and 5-10 agents, and each agent spawning its own subagents to do work in parallel, all of that on a tanky GitHub project boards” level of work only Claude was doing work dependably.
I can have a few orchestrator leads which I talk to and brainstorm, and let them file tickets, organize them and assemble teams of agents to work of the various problems. And all of that with just a smidge of custom tooling on top of Claude Code’s default.
Plus don’t have a budget to spin all of this on cloud runners so I made sure to do as much as I can with local work on several machines I own. Was quite easy to achieve with Claude.
Do you have something similar built on top of a open source harness, or is it from scratch?
Well I work at BigCo and I have no idea how it compares to Claude Code because I’m not allowed to use Anthropic models outside of our custom company harness. Opus 5.5 works extremely well, it can launch multiple subagents, assign them tasks, use our company’s inscrutable build system (that no one really understands anymore), and run tests, all by exposing harness commands in the system prompt. I don’t think we are lacking in any way.
The switch in mindset I experienced was to go from "Working on a feature" to "curating a board" to "overseeing angets curating boards".
So that I'm not just relying on one or a few agents to accomplish a task. I work on the whole product and just drive the direction of tickets and their "what done looks like" requirements, and let the machine organize things on its own, usually 10-20 independent agents (each spawning their own subagents). I think i might have capacity to handle more, just don't have the subscription tokens to fuel it and the budget for the hardware to run it.
Haven't worked in BigCo so no idea how that compares to their tooling. I'm sure it works much more efficiently and on a bigger scale, just being curious about how it all plays out.
I built http://github.com/brokkai/mjolnir/ to do exactly this cross-harness over ACP. As a bonus it can let Opus drive Luna as a subagent, which is just ridiculously cost effective. (5x clst multiplier means Haiku is much more expensive for realistic task sizes.)
To be honest I’m not sure - the tooling around it has processes to start things, and gourds around tool usage to remind Claude of proper procedure.
But ultimately I find it a silver lining more than a problem. I am building and changing tooling so fast, and the models tooling itself is changing so fast, that by the time I establish a workflow, I either A) have solved the original problem so no longer needed, B) have built other tooling that distorts the picture, or C) the labs have released something new and cool that changes the equation drastically so your previous setup is gone anyway.
For example I built some procedure on how to split work between fable and opus and sonnet to optimise token usage, then opus 5.5 came along and made all of this obsolete.
Not per “token usage” mind you, opus is still expensive, but more “effort per task time finish” kind of metric. If I want to close things faster while still being relatively within budget, it is just easier to send all to opus - it will now just solve thigns quicker so you still use similar amount of tokens / money, but quicker, which is a trade I’ll make any day.
And every time “the system is working” I either just stumble onto the next resource constraint, or I feel uncomfortable and start refactoring to make things better and inevitably destabilise the whole “machine”
I think the new batch of engineers are going to think faster on their feet, but less precise.
We humans are _amazing_ pattern matching machines and learning “if you do this thing this other thing occurs” is literally what our brains were built for.
It’s just the current few thousand years of technical progress that have been a departure from this reality - we found out about analytical thinking and that by deeply analysing something you can do a shit ton more.
If you look at scientific progress before Industrial Revolution it’s all trial and error between patterns. And I feel like the new crop of devs are silently settling in into this very human and familiar pattern.
On the one hand I think it will probably be good for the “mental health” of people in this profession - you become more like an alchemist acquiring bags of tricks on what works, sharing incantations with others, because sitting down and learning _why_ it works in detail would be a time luxury few would be able to afford.
But that would mean the people under the hood that build the LLMs and who debug the really broken system would be charging the premium.
I honestly don’t think that in and off itself would be such a bad thing.
What I personally am really scared about is the price for labour that is sharply declining. I don’t worry about ASI too much, but when you read history it is absolutely full of stories of great human suffering because “labour was cheap” no need to improve working conditions because there is always someone else willing to take it up.
We had the Industrial Revolution _because_ of the plague making labour expensive and driving the benefit for innovation. Before that nobody really cared. With LLMs doing things becomes vastly cheaper, so the labour itself becomes cheap with it.
Now looking at the state of the engineered world - how absolutely shitty everything is (as opposed to what it technically could be) - there is a shit ton of stuff to be done so the work should be there to fill it. But maybe the capital will move in another direction - nobody can predict the future, I just hope we don’t end up in a dystopian hellscape for the sake of my children.
I think for now the answer to adaerlangsql+++ is just Rust - but its semantics have always been about human usability.
Humans have this thing where we can only keep 7 things at once and have to juggle our context, but recall seems much more broad than model contexts.
If we were to start designing a language and toolkit based around LLM context sizes, limitations and quirks - how would that look?
Also terseness and operators are one thing, but what if it’s the other way around - English words etc - can have a much bigger vocabulary of things that can be done but can easily be generated on the fly.
For a new LLM language realistically you would need to probably either write or convert a shit ton of software to it first if you are to train an adequate model on top of it …
And also what about “IDEs” for agents? So far they are clumsily using human tools - just looking Claude string along bash loops and greps to try to eek out meaning form code _it itself had written a week ago_ is frankly frustrating.
There must be a better way and some rich agent specific tooling for code exploration and verification.
Anthropic stance has always been “yeah we tested them all, grep is better” but I still am not convinced - just by the fact that it constantly fails one or two attempts before “figuring it out” yeah it’s fast anyway but it could be _faster_ and could allow the agent to “think” in code space more and not have to validate itself at every minute step …
reply