jes5199

I find that ChatGPT’s Codex reviews - which can also be set up to happen automatically on all PRs - seem smarter than Copilot’s, and make fewer mistakes. But these things change fast, maybe Copilot caught up and I didn’t notice

can it read code review comments? I've been finding that having claude write code but letting codex review PRs is a productive workflow, claude code is capable of reading the feedback left in comments and is pretty good at following the advice.

yesss, and OpenAI tried this first when they were going to do a “GPT store”. But REST APIs tend to be complicated because they’re supporting apps. MCP, when it works, is very simple functions

in practice it seems like command line tools work better than either of those approaches

increasingly, the automated systems have access to the original ticket or bug report, and maybe even the conversation while implementation is happening. They can record the “why”

I think that’s a tooling problem. Maybe we do end up running a lot more versions of things in the future. If we believe that code has gotten cheaper, it should be easier to do so.

I love it when I have a tool that’s “done” but the software I work on in my career is never, ever done. It’s almost like there’s two different things we call “software”. there are tools like, idk, “curl” where you can use and old version and be happy. and there are interactive organizations in the world, like, eg, Hacker News, which mutates as the community’s needs change

for now yes absolutely. but I’m already hearing rumblings that some people are having luck letting multiple agents edit the same directory simultaneously instead of putting changes through PR merge hell. It just needs coordinations tools, see https://github.com/Dicklesworthstone/mcp_agent_mail as one (possibly insane) prototype

for example it’s not out of the question that we could end up with tooling that does truly continuous testing and integration, automatically finding known-good deployments among a continuously edited multiplayer codebase

we’d have to spend a lot more energy on specifications and acceptance testing, rather than review, but I think that’s inevitable - code review can’t keep up with how fast code gets written now

I could imagine that in ten years git will feel strangely slow and ceremonial. Why not just continuously work and continuously deploy live-edited software

I just remembered, in those days, there was an alias called `ubygems` so you could pass `-rubygems` (ie, `-r` with `ubygems` as the argument) on the command line as if it was a first-class feature

it's so typical of ruby culture "haha, what if I do this silly thing" and then that gets shipped to production

it’s an america thing

huh okay, so, prediction: similar to how interpreted code eventually was given JIT so that it could be as fast as compiled code, eventually the LLMs will build libs of disposable helper functions as they work, which will look a lot like “writing code”. but we’ll stop thinking about it that way

yeah why would anyone want to run code on a website

no, emulated vim motions annoy me because they’re always slightly wrong, especially for the interesting stuff like multi-line selections. Or, worse, I’ve got stuff in my muscle memory from the `surround.vim` plugin that isn’t emulated. Easier to just open vim in a terminal if I want to do surgery on a file.

I used vim for decades and the sensation is that I can hold the code in my hands and manipulate it directly. Other editors feel like I’m wearing thick gloves, can’t move correctly.

but it’s like learning to play the piano, it only feels natural after years of practice

nowadays I’m faster with Cursor so it doesn’t matter as much

huh, my current ranking is:

1. claude code CLI, generally works, great tool use

2. codex on the web, feels REALLY smart, but can’t use tools

3. codex CLI, still smarter than claude but less situational awareness

4. codex via iphone app, buggier than the web app

5. claude code on the web, worst of all worlds

they build them but they’re mostly not running them, utilization numbers keep falling. It’s either a central-planning failure or some kind of hedge

ohh so basically an ESP32 can be a keyboard… can _two_ ESP32s be two hands of a single keyboard?

codex can actually do useful reviews on pull requests, as of the last few weeks

does DNA/RNA keep state other than the position of the read head?

our relationship to computation got weird when we moved to digital computers. Like, I don’t think anyone was saying “life is like millions of slide-rules solving logarithms in parallel”. but now that computers are de-materialized, they can be a metaphor for pretty much anything

and yet my M1 manages to drain the battery in suspend mode in just a few hours

yeah but then you have to start imagining the earth orbiting the sun by climbing over and under it each year

hell Windows shows ads now on regular computers with nothing installed

well, that’s horrifying! I appreciate the update though

I don't know what it's like now, but GitHub's internal merge queue circa 2017 was a nightmare. Every PR required you to set aside a full day of babysitting to get it getting merged/deployed - there were too many nondeterministic steps.

You'd join the queue, and then you'd have to wait for like 12 other people in front of you who would each spend up to a couple hours trying to get their merge branch to go green so it could go out. You couldn't really look away because it could be your turn out of nowhere - and you had to react to it like being on call, because the whole deployment process was frozen until your turn ended. Often that meant just clicking "retry" on parts of the CI process, but it was complicated, there were dependencies between sections of tests.

probably more than 95% of early internet projects failed, it took like a decade before people really started to have intuitions about what it was good for.

It’s easy to imagine that we’re going to make the AI analog of paypal or amazon, but the vast majority of people flailed at doing anything useful with the web until patterns had been established

if you have a static analysis tool that gives a list of problems to fix, and something like a unit test suite that makes sure nothing got badly broken due to a sloppy edit, then yes. If you don’t have these things, you’ll accumulate mistakes

ads really aren’t all that lucrative, though, they’re just simple. I worked for a company that was trying to figure out an alternative to ad revenue (we failed) and our people did some research and the average internet user ends up being shown (if I remember correctly) like $60/month of ads, total.

things backed by Claude Sonnet can get a little further out than Copilot can, and when it’s in agent mode _sometimes_ it will do things like read the library source code to understand the API, or google for the docs

but the principle is the same: if the human isn’t doing theory-building, then no one is

maybe, but I find that it makes it much faster to do things that _I already know how to do_, and can only slowly, ploddingly get me to places that I don't already have a strong mental model for, as I have to discover mistakes the hard way