dcre

Right, agents can just use tmux send-keys. Here's a skill I wrote to have Claude debug plugin code in the Helix editor's experimental plugin system. As usual, the skill is barely necessary, it just saves it some time getting the commands right and tells it where some useful reference material is.

https://github.com/david-crespo/dotfiles/blob/main/claude/sk...

Every Claude Enterprise customer is choosing that. Claude Enterprise bills at API rates (presumably with a discount if you're big enough).

Incredible take. They are selling it.

Bizarre to make claims about how the Claude Code devs work based solely on the leaked source. They have talked plenty about how they work.

I was curious why bun build --compile would be faster. The docs say:

“Compiled executables reduce memory usage and improve Bun’s start time.

Normally, Bun reads and transpiles JavaScript and TypeScript files on import and require. This is part of what makes so much of Bun “just work”, but it’s not free. It costs time and memory to read files from disk, resolve file paths, parse, transpile, and print source code.

With compiled executables, you can move that cost from runtime to build-time.”

https://bun.com/docs/bundler/executables#deploying-to-produc...

OpenRouter is primarily a router. It just proxies requests through to the actual provider.

Anybody want to give an anecdotal take on how good it is?

"Knowing where you are on these axes at any given moment is, I think, the core skill of working with AI effectively."

I like this a lot. It suggests that AI use may sometimes incentivize people to get better at metacognition rather than worse. (It won't in cases where the output is good enough and you don't care.)

It doesn't have to work 100% of the time to be ubiquitous! This is just the strangest point of view. People don't work 100% of the time either, and they wrote all the code we had until a couple of years ago. How did we deal with that? Many different kinds of checks and mitigations. And sometimes we get bugs in prod and we fix them.

I think it's too far to say you need YOLO mode — the author was correctly pointing to the "auto-accept all changes" setting. They should have just turned that on and then reviewed the changes in larger chunks. You don't have to let it go for half an hour and review the mess it cooked up — you can keep an eye on things and even manually make commits to break the work into logical pieces.

With auto-accept edits plus a decent allowlist for common commands you know are safe, the permission prompts you still get are much more tolerable. This does prevent you from using too many parallel agents at a time, since you do have to keep an eye on them, but I am skeptical of people using more than 3-5 anyway. Or at least, I'm sure there is work amenable to many agents but I don't think most software engineering is like that.

All that said, I am reaching the point where I'm ready to try running CC in a VM so I can go full YOLO.

The choice isn't really between all at once and line by line. I always use accept all changes, but I make commits that I can review and consider in bigger pieces, but usually smaller than the full PR.

Indeed, in Freud the word is _Unbewusstsein_, which is literally more like "being-unconscious," but a more natural English translation would be unconsciousness.

No it isn't. Can you give an example?

How exciting, I get to be the pedant: it’s “stream-of-consciousness,” not “stream-of-conscious.” Conscious is an adjective; there can’t be a stream of it.

I call it pseudo-critique — active stupidity in the name of critical thinking — but that’s too general.

This looks really good. Haven't read in full yet, but I was hoping to see him credit Ben Evans's "Office, messaging and verbs" (2015): "In effect, every person on that floor is a cell in a spreadsheet. The floor is a worksheet and the building is an Excel file, with thousands of cells each containing a single person."

https://www.ben-evans.com/benedictevans/2015/5/21/office-mes...

I’ve always meant to write a post about this. Bun is pretty similar and has the `$` helper from dax built in. In the past I would have used Python for scripts that were too complicated for Bash. But the type system in Python is still not great. TypeScript’s is great: flexible, intuitive, powerful inference so you don’t have to do many annotations. And Deno with URL imports mean you can have a single-file script with external dependencies and it just works. (Python does this now too with inline dependencies and uv run.) Deno and Bun also come with decent APIs that are not quite a standard library but help a lot. Deno has a stdlib too.

https://docs.deno.com/runtime/reference/std/

You can see in my other scripts in my dotfiles that between dax for shelling out and cliffy or commander.js as a CLI builder, TS is a great language for building little CLIs.

https://github.com/david-crespo/dotfiles/tree/main/bin

Check this out: https://crespo.business/posts/dq-its-just-js/

You don't have to use my implementation, you could easily write your own.

Funny that everyone is linking the tools they wrote for themselves to deal with this problem. I am no exception. I wrote one that just lets you write JavaScript. Imagine my surprise that this extremely naive implementation was faster than jq, even on large files.

    $ cat package.json | dq 'Object.keys(data).slice(0, 5)'
    [ "name", "type", "version", "scripts", "dependencies" ]

https://crespo.business/posts/dq-its-just-js/

I love jj and think virtually every git user should switch to it, but I don't think it treats text as an AST. What do you mean?

This is a reasonable reaction — pretty sure I felt the same way when I heard about jujutsu's first-class conflicts[0] — but it turns out to be really useful not to be stuck inside an aberrant state while conflicts are in the process of being resolved.

[0]: https://docs.jj-vcs.dev/latest/conflicts/

What here takes them over the complexity threshold?

I looked at the repo and couldn’t even find an example, so it can’t be that many of their commits. But also: this is ridiculous. Whether the commit appears as done by Claude or not is a setting you can change. If they turned it off, you’d never even notice.

These are great developers and they’ve built an incredible tool. I use it a hundred times a day. It is very odd and dogmatic to think that because you saw a commit authored by Claude, whatever skills and qualities let them build something so good are now being thrown out.

Edit: I found one: https://github.com/atuinsh/atuin/pull/3231

Please, tell me where the bad code is in that PR. I see 200 lines of extremely straightforward Rust and 500 lines of tests for it.

It's not about what they wish would happen, it's about what they think will happen. In my view they are acting precisely like they believe they will be making a proportion of developer pay by making them more productive rather than replacing developers. I think they understand that the alternative doesn't really work out for them or anyone.

Even if they believe that their systems will eventually tank employment and replace developers rather than augment meant, the fate of Astral doesn't matter at all in that scenario because a) nobody has a job, and b) you can build your own uv replacement for $20.

They are not. A very large proportion of their revenue comes from developers. A large proportion of their marketing and product work is aimed at developers. You have to work really hard to not see this. Just look at what Altman and Brockman tweet about.

https://xcancel.com/gdb

https://xcancel.com/sama/

Can't blame you for not trusting OpenAI, but it seems to me they would gain very little from fucking up uv (or more precisely doing things that have a side effect of fucking up uv), and they have tons of incentive to cultivate developer good will. Better to think of buying and supporting a project like this as a very cheap way to make developers think they're not so bad.

In jj this is jj diff -f ‘fork_point(trunk() | @)’. I have an alias for it.

Personally, even though performance up to 200k has improved a lot with 4.5 and 4.6, I still try to avoid getting up there — like I said in another comment, when I see context getting up to even 100k, I start making sure I have enough written to disk to type /new, pipe it the diff so far, and just say “keep going.” I feel like the dropoff starts around maybe 150k, but I could be completely wrong. I thought it was funny that the graph in the post starts at 256k, which convenient avoids showing the dropoff I'm talking about (if it's real).

You could put whatever you wanted in the GPT-4 system prompt and it wasn't doing shit.

Curious what language and stack. And have people at your company had marginally more success with greenfield projects like prototypes? I guess that’s what you’re describing, though it sounds like it’s a directory in a monorepo maybe?