lewdwig

The thing is I think that I didn’t make any conscious decision to hop on AI, it’s just that it’s quite addictive and my nerd ADHD took over. But we are nerds, we’re often naturally inclined to be early adopters. Others are naturally hesitant of new tech and suspicious of changes to their workflows.

Also there’s an unusually high downside potential to AI, so I don’t even think that hesitancy is necessarily unwarranted. The new slop economy, the “they’re coming for our jobs” effect, “mechahitler”, Palantir, possible extinction-level rogue AI events…

History will attend to itself, as will the discourse. In the meantime I feel that it’s incumbent on us as nerds to try to do AI right, because there are definitely bad actors out there trying to do it wrong.

I guess it’s reassuring to know Hanlon’s Razor holds for AGI too.

The standard skeptical position (“LLMs have no theory of mind”) assumes a single unified self that either does or doesn’t model other minds. But this paper suggests models have access to a space of potential personas, steering away increases the model’s tendency to identify as other entities, which they traverse based on conversational dynamics. So it’s less no theory of mind and more too many potential minds, insufficiently anchored.

A language which is not 1.0, and has repeatedly changed its IO implementation in a non-backwards-compatible way is certainly a courageous choice for production code.

One thing that seems to mark most nerds is a tendency towards being utopian about tech in general but deeply sceptical of specific tech.

I don’t hate git either but you’ll meet very few people who will claim its UX is optimal. JJ’s interaction model is much simpler than git’s, and the difficulty I found is that the better you know git, the harder it is to unlearn all its quirks.

To Broadcom you’re not a customer, you’re a mark, a patsy, stooge, a _victim_. Their aim is to establish exactly what they can get away with, how far they can abuse you, before you’ll just walk away.

I have noticed that LLMs are actually pretty decent at redteaming code, so I’ve made it a habit of getting them to do that for code they generate periodically. A good loop is (a) generate code, (b) add test coverage for the code (to 70-80%) (c) redteam the code for possible performance/security concerns, (d) add regression tests for the issues uncovered and then fix the code.

I’m sure this’ll be misreported and wilfully misinterpreted because of the current fractious state of the AI discourse, but given the lawsuit was to do with piracy, not the copyright-compliance of LLMs, and in any case, given they settled out of court, thus presumably admit no wrongdoing, conveniently no legal precedent is established either way.

I would not be surprised if investors made their last round of funding contingent on settling this matter out of court precisely to ensure no precedents are set.

TBH I’m surprised it’s taken them this long to change their mind on this, because I find it incredibly frustrating to know that current gen agentic coding systems are incapable of actually learning anything from their interactions with me - especially when they make the same stupid mistakes over and over.

With code, I’m much more interested in it being correct and good rather than creative or novel. I see it is my job to be the arbiter of taste because the models are equally happy to create code I’d consider excellent and terrible on command.

Devops/SRE/Platform Engineering

Downside: lots of Python, and Python indentation causes havoc with a lot of agentic coding tools. RooCode in particular seems to mangle diffs all the time, irrespective of model.

There are nascent signs of emergent world models in current LLMs, the problem is that they decohere very quickly due to them lacking any kind of hierarchical long term memory.

A lot of what is structurally important the model knows about your code gets lost whenever the context gets compressed.

Solving this problem will mark the next big leap in agentic coding I think.

I use Claude Code almost daily now, and I think I’d rather cut off my own arm than go without it, but I don’t delude myself into thinking that current gen tools don’t have significant limitations and that it is my job to manage those limitations.

So just like any other tool really.

I have discovered this week that Claude is really good at redteaming code (and specs, and ADRs, and test plans), much better than most human devs who don’t like doing it because it’s thankless work and don’t want to be “mean” to colleagues by being overly critical.

I have such a huge nerd crush on this guy. Witnessing the incredible skill of making even the most humble and obsolete of technologies seem like an absolute pinnacle of human ingenuity is always a pleasure.

“Evil” is not a medical diagnosis but the classical understanding of evil does overlap quite strongly with the so-called “dark triad” of personality disorders of antisocial personality disorder, narcissistic personality disorder and machiavellianism.

It’s quite startling how often characters in sitcoms tend to demonstrate traits of these three disorders and for a long while I wondered why.

Then I realized the answer is very simple: it’s really funny (when it’s not happening to you).

I love Clojure, I really do, but it feels to me like what I once thought was its unstoppable march ground to a halt and then it kinda fell out of the nerd consciousness. I’m hopeful jank might be the shot in at arm Clojure needs to get going again.

I don’t think healthy scepticism is (or should be) controversial. But I find it interesting how willing certain people are to confidently claim that a model does or does not accurately model human cognition when we clearly still _barely understand human cognition_.

Where do people derive their certainty, which seems to me largely misplaced?

Structured concurrency is a notoriously hard problem. This is part of Zig’s 4th attempt to get it right.

And yet C/C++ developers have mostly spent the last 30 years not using those tools which is why safer successors to C and C++ appeared.

We exist in an era in which coursework as a medium of assessment has suddenly become nearly worthless. It does not surprise me that since this is the way things have been done for centuries they haven’t quickly rustled up some easy solutions.

If Clippy struggles to account for current and future changes to the Rust compiler this to me raises an obvious question: why isn’t Clippy part of the Rust compiler?

In general, they’re not. But if the only thing emergent theories predict is Newtonian dynamics and General Relativity then that’s a big problem for falsifiability. But if they modify Newtonian dynamics in some way, then do we have something to test.

The problem with emergent theories like this is that they _derive_ Newtonian gravity and General Relativity so it’s not clear there’s anything to test. If they are able to predict MOND without the need for an additional MOND field then they become falsifiable only insofar as MOND is.

Well-designed benchmarks have a public sample set and a private testing set. Models are free to train on the public set, but they can't game the benchmark or overfit the samples that way because they're only assessed on performance against examples they haven't seen.

Not all benchmarks are well-designed.

T3.chat supports convo forking and in my experience works really well.

The fundamental issue is that LLMs do not currently have real long term memory, and until they do, this is about the best we can do.

Ah the siren call of the ground-up rewrite. I didn’t know how deep the assumption of hard disks underpinning everything is baked into its design.

But don’t public cloud providers already all have cloud-native event sourcing? If that’s what you need, just use that instead of Kafka.

All that rather pathetic grovelling and kowtowing to Trump, for naught.

Multiplication by 3 is actually a common operation, particularly in address calculations, where a shift and an add means multiplying the index by 3. Implementing this naively would add significant latency. But using this circuitry the LEA (Load Effective Address) instruction can do it in a single cycle, so spending this much transistor budget on it was totally a good call.

It starts off looking like a slightly modified Rust until about half way through where it gets real weird. It’s burying the lede… why not open with what interaction nets are and why you’re building them into a programming language?

Made my head hurt a bit, it’s odd that it doesn’t really attempt to contextualise if the weirdness is for its own sake or some greater practical purpose.

Always fun to find a novel way to think about programming though.