David Crespo

It doesn't know that the test pass, doesn't know that CI passes.

But you can get quite a lot that way.

It can find a mismatch between your SQL migration and your main code.

DB init sequel I can find inconsistencies really well and inconsistencies even between like your human readable stuff like your PR description and the actual code There's a lot you can do there even without net what we now have which is like the tools that can go and vacuum up anything that they need to and to validate their hypotheses about why the PR is broken and

With Cloud Code, it can write a new test that validates that the code as written doesn't do something.

And there's a lot of low-hanging fruit there that we're not really touching at all.

Hmm.

I've been thinking a lot about this because if you think about where our intuitions come from about what is worth abstracting or what is too much repetition, they're so tied up with the expected reader of the code, whether that's ourselves or the people that we know.

They're tied in very, very tightly with our intuitions about what people can handle and what's reasonable to expect of other people.

And what is reasonable to expect of an LLM is radically different from what is reasonable to expect of other people.

And so the amount of repetition that is tolerable in a code base or is manageable seems to me way higher.

And it's not just in a code base.

We were thinking about API design, API response shapes earlier, and I was working with Adam on this, that we erred on the side of making a response shape more flat and less nested, even though we lost a little bit of type information that way, just because the flat one was a little easier to read, and the type information we decided was not really worth it keeping in that particular case.

But I think...

When you assume that future developers will have LLMs at their disposal, I think that it must tilt the calculus toward encoding more type information at the expense of readability, because that type information is what is going to keep LLMs on the rails in the future.

and just say if a more elaborate type system lets you put more of that work in upfront to sort of constrain the program further,

you could say that LLMs allow you to tolerate an even more elaborate type system.

Maybe now dependent types are going to be feasible for people to learn and work with.

Maybe you'll see Idris take off.

Yeah.