ebcode

But you wrote: "There are now multiple posts from vuln research teams all of whom have working RCE POCs against unmodified PHP applications." ? Are those "multiple posts" top secret?

Look up the paradox of tolerance. The tolerant should tolerate everyone except the intolerant. Trump and his cronies are clearly intolerant. Same reason you can’t let the neo-nazis hang out in your bar. They ruin it for everyone else.

“It pays to keep an open mind, but not so open your brain falls out.” — Carl Sagan

Planets are spaceships. Mars is a dead planet either because its shields[0][1] were disabled, or it never had shields to begin with.

So the first thing we'd want to do is activate a magnetosphere on Mars. I rarely see anyone talking about that[2].

[0] https://en.wikipedia.org/wiki/Van_Allen_radiation_belt

[1] https://www.nasa.gov/science-research/heliophysics/real-mart...

[2] https://astrobiology.nasa.gov/news/how-to-give-mars-an-atmos...

> In present reality, AIs don't do anything a human doesn't tell them to do. This seems unlikely to change.

Not in my reality. I ask AIs to do things (write code, mainly), and they do. But sometimes they go ahead and do something I didn't ask them to do, like deleting a file. I only asked them to write code, and yet they decided on their own to delete a file.

I think the distinction is that, in their current form, AIs have the agency that we give them (--dangerously-skip-permissions), and they use that agency in unexpected ways.

A more correct statement would be: AIs can decide to do things on their own, within the limits of agency that they've been given.

A moral imperative would be: With an understanding of how random we know an LLM's output can be, we should exercise extreme caution when we grant them agency.

On the other hand, we can't all exercise "extreme" caution all the time. But we expect it of our civil engineers when they build bridges, and our architects when they build houses.

Computer Science needed to become Computer Engineering some time ago, where it would have enforced the same kind of ethics training that the other established engineering professions require[0].

[0] https://en.wikipedia.org/wiki/David_Parnas#Technical_activis...

Mostly I was thinking about environmental damage, honestly. There's plenty in the historical record about damages from nuclear testing.

https://en.wikipedia.org/wiki/Starfish_Prime

https://storymaps.arcgis.com/stories/3f62c90925f64fc09425be8...

Of course there is/was plenty of human damage as well.

https://www.msn.com/en-us/news/world/4-000-000-early-deaths-...

While I have my reservations about Amodei and his company, I'm nevertheless a happy user of their software. And I'm in agreement with him (and Sanders) that we should all. slow. down.

To my mind, the last great arms race between nation states was a misdirected love triangle between USA, Russia, and The Bomb, and look at all the damage that did.

Since AI is the new arms race between USA and China, slowing down may just give the humans involved enough time to realize they should be loving one another, instead of the machines.

Maybe saying, "let's slow down", is another way of saying, "I love you."

Or, maybe it's just: "let's not all of humanity kill ourselves like some bad ending to a Shakespearean tragedy."

Either way, it's a better note than, "We must achieve sea/air/nuclear/quantum/AI/spiritual supremacy before those other bastards do!"

Thanks for asking the question.

Preface: I do think the nature of the work is changing, now that LLMs are capable code generators. And I'll admit that I started working with LLMs because of FOMO, but also to keep my skills sharp in an evolving market. I'm not 100% certain this will pan out, but I do think that working with LLMs is a skill unto itself, and I feel that I'm much better at it now than I was when I started (in earnest, roughly) a year ago.

Q: What's my setup like? A: I'm using both Claude Code and opencode w/ DeepSeek flash. Recently I've started providing the task context to both simultaneously, and then have one act as a real-time reviewer, and one as implementer. I don't consistently use one or the other for implementer, and I'm still learning their capabilities and "who's good at what." But this allows me to get one model to provide an instantaneous code review to the other, as soon as the one model is done writing the code. I set my permissions for both to ask every time on every action: Read, Write, Bash, etc. I grew up playing turn-based RPGs, so I prefer turn-based battle to real-time.

Q: What kind of work I offload, vs do myself. A: Almost all of the code is written by an LLM, but, since I'm reading and rejecting a lot of code, and basically micro-managing them, I feel that the code that's generated is roughly what I would have written myself. Work that I don't offload is any kind of email or communication, or non-code writing, with the exception of README files, and the prose session summaries I have them write.

Q: How do I make it enjoyable? A: I make it enjoyable by finding new ways to work with the LLMs, and specifically, getting them to produce better quality code. The real-time code review process I outlined above is one method, but I've also found that the LLM will write better code when given a "guiding principles" document.

HTH

Let me propose: HNmind.

Culture flows from the top. Bill doesn’t take responsibility in his email, so he’s teaching everyone downstream to pass the buck like he does.

From https://code.claude.com/docs/en/remote-control :

    Feature-flag evaluation: DISABLE_TELEMETRY, DO_NOT_TRACK, CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC, and DISABLE_GROWTHBOOK each
    disable the feature-flag evaluation that Remote Control availability depends on. Unset the variable
    wherever it’s set, in your shell environment or in the env block of a settings.json file, to use Remote Control.

I just discovered the same thing, that my local sessions were sent to claude.ai/code and stored there. I added:

    "env": {
        "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
    },

to my .claude/settings.json file, and the /rc in the corner went away.

I'm only running a few agents in parallel so far, but I don't let them write or read anything w/out my approval. This slows things down quite a bit, but it means that I have exactly the opposite of your problem of stopping them.

I've only started really thinking about developing my own harness, but one of the reasons would be to implement some mechanism where I could give the agent a "turn budget", say, 5 turns, when I can clearly see what the agent is going to be doing for the next few turns, without my needing to allow each turn to go forward.

But it sounds like the same thing would be useful for you as well, just in the other direction.

Could you say more about what "certain points" you're trying to get them to stop at?

SQLite doesn't have system-versioned / temporal tables, but a quick search turns up a fairly straightforward approach. Instead of overwriting existing rows, always write new rows with timestamps. https://www.ohnekontur.de/2024/02/19/unlocking-time-harnessi...

I'm thinking now of the hoops you have to jump through to edit a package.json file to update your dependencies, and thinking yeah, what if you could do: "UPDATE dependencies SET version='1.2' where name='madlib';"

Our government is tyrant.

It’s interesting to think of the LLM as a kind of “mirror”.

It reads to me like this person is engaging with the tool in a fairly hostile manner, and the LLM is like, “so you want to play it like that, huh? Well, let’s play it like that then!”

The language that you use to prompt the LLM is the language you’re going to get back.

My personal opinion: all output from LLMs is hallucinations. The idea that it’s “right” or “wrong”, when stating factual information is really in the eye of the beholder/user. What year did astronauts land on the moon? — is a question that may or may not have a factual answer depending on your own beliefs. Philosophically, you would need to also define what a fact is, or what “not hallucinating” is, to define what a hallucination is. My understanding is that this property of the LLM architecture is innate, and until we have “world model” LLMs, or some other model that reasons from first principles, instead of the current “guess the next word” model, this isn’t going away. Just don’t rely on the for facts.

I don’t trust their outputs yet enough to not review everything myself. But I’m happy to be. a QA bottleneck in that way. What I want now is orchestration to get them running in parallel. I’ve looked into Yegge’s beads, but I want something similar that is far simpler, fewer sloc, and database-driven rather than json-file-driven. Probably need to build it myself with a graph database…

I mean, it does feel like we could pause here for a few years, just to give everyone time to adapt to what the current models are capable of. We've seen back-sliding with model releases (anecdotally, but maybe there's published research?) as well. A new model isn't always a "better" model, for a particular task.

If these companies (and countries) believe that they're in an "arms race" with LLMs, then it may be extremely sane to have regulators step in and let all the engines cool down for a bit. Seems like international agreements to pause development will be necessary as well, otherwise the US companies will just say, "but China ...".

Does anyone else here feel the same way? I think most folks default to a kind of cliched, "you can't stop progress" stance. I'd be happy to see more discussion on this topic.

Maybe we could find agreement in the idea that the USA and Russia agreeing to halt nuclear weapons testing was a good thing. Seems like there's a bit of precedent here for cooler heads to prevail, which benefits us all.

Between those two, it's Claude Code. Gemini models are behind in the benchmarks.

I’d say the problem is that, at least in the US, the government was conceived as a democratic republic, but private enterprise wasn’t required to follow the same conceits, and so all our corporations behaved more like small dictatorships. Now that our corporations are megacorporations, and the government has lost the upper hand, the common people are at the mercy of these dictatorships. There’s no reason for Apple or Google to cede any control that they’ve already established, and we only see them grabbing more and more control as time goes by. Until the government regains the upper-hand, and begins to work again on behalf of actual people (with heartbeats), the firmware in our phones will continue to do the bidding of its true owner. Or if maybe, there’s a revolution or something. Maybe we could take public ownership of the phone lines and cell towers. Fat chance, huh?

Can we get that added to the US Constitution and the UN Declaration of Human Rights?

What if a single email cost $0.001 cent to send, and it was paid to the recipient? For $10, you could send 10,000 emails. For recipients, every 1,000 emails they get is a dollar in their wallet. You’d need something like a blockchain for this to work because the traditional payment processors still haven’t figured out micropayments.

Have you tried VirtualBox? That’s my go-to for running un-trusted code. Start with a clean VM/fresh install, and don’t put any secrets in it.

check out David Ackley's work

I tried it on my iPhone but can’t scroll the spreadsheet. still it seems like a fun project.. will check it out on desktop when I get home

Here's the original blog post from last December: https://ebcode.com/blog/2025/12/17/sourceminder/

The 15% number is based on two runs from the ./experiment folder, on an instance from the SWE Bench Pro benchmark. I picked two trajectory logs, from the pro_pilot_openlibrary_haiku_v2 folder, that I consider to be representative of the token savings one can expect. There's huge variance just between individual runs of the same model on the same instance, though, so it's somewhat difficult (and expensive, at API rates) to cut through the noise. But I ran over 80 trials, and I believe that number is accurate.

And I'm publishing the "token science" research in the repo itself, so anyone who's curious about it can review the logs and inspect the python scripts that I used. And if someone out there has the time, inclination, and money, to run some of those experiments themselves, it'd be great to get consensus on some of those results.

And if you'd like to share feedback directly, rather than publicly, my email is on my profile page.

It’s a tie.

And it reads to me like they have some other reason to move on from SWE Bench Pro, but they don't want to say what it is. They say right up top, "~30% of the tasks are broken." But that leaves ~70% un-broken, which seems pretty good to me. It would be nice if they would also say: "Here's the list of instances that are broken: <CSV>". Or, "Here's the subset of SWE Bench Pro we will use going forward." They're letting the perfect be the enemy of the good.

Still plugging away on SourceMinder (https://github.com/ebcode/SourceMinder). I know, I know, everyone and their brother is working on token-saving schemes for LLMs. But I’ve found it to be useful even without the LLM. I’m working on a proper website for it now where you can try it out in the browser (wasm port) — try before you don’t buy (it’s GPL). Feedback welcome.