Remix.run Logo
petilon an hour ago

One aspect AI is weak in is controlling complexity. If you tell it to implement something it will go ahead and implement it, without considering how much complexity it adds to the system or weighing alternatives. An experienced engineer on the other hand may decide the feature is too minor relative to the complexity it adds, and may decide to not do the feature. Or he may make some clever compromises to get most of the functionality while keeping the codebase simple. AI is weak in this judgement, it doesn't spontaneously exercise architectural restraint. As a result the code may progressively become too complex even for AI manage, and it becomes whack-a-mole where you can't make a change without breaking something.

bubblebeard 36 minutes ago | parent | next [-]

I feel this mostly is a side effect from lack of domain knowledge. Most of the time this has happened to me, it's because I myself did not cleanly know how a problem should be solved to begin with. If you have a clear picture of what you want, approximately what syntax goes where and why, thats really when LLMs shine in my experience.

jvuygbbkuurx 39 minutes ago | parent | prev | next [-]

I found it follows conventions and documentation well. So if you have a well designed core, it can easily add independent features without increasing overall complexity. Maybe it doesn't work in some very tangled domains like games, but some basic crud and saas stuff is pretty much a solved problem now with agents. They will trivially add features that humans would have pushed to a backlog forever as not worth the effort.

petilon 36 minutes ago | parent | next [-]

Yes, for simple "leaf level" features where there are no big architectural trade-offs to make, AI works well.

skydhash 34 minutes ago | parent | prev [-]

> They will trivially add features that humans would have pushed to a backlog forever as not worth the effort.

More features is always good, right? Let's build dropbox+gmail+netlify+spotify+youtube+hackernews+... \s

orangecat 43 minutes ago | parent | prev | next [-]

If you tell it to implement something it will go ahead and implement it, without considering how much complexity it adds to the system or weighing alternatives.

Recently I asked Claude (Fable) to use multiple threads to speed up a computation that could take several seconds to run while the user was waiting. Instead, it found a way to start the computation earlier in the background while the user was doing other things, so that it would be finished by the time the user was ready.

petilon 35 minutes ago | parent [-]

Yes, at the tactical level, AI is able to find better alternatives.

demibabs an hour ago | parent | prev | next [-]

Yeah but on the other hand, if you asked an LLM to implement a spec and it was like “I skipped this part because I didn’t like the complexity tradeoff” most people would be like “wtf why doesn’t Claude just listen to me”

petilon an hour ago | parent [-]

Right, and that's why humans are still needed in the loop.

technotony an hour ago | parent | prev [-]

Have you found any solutions to this? It would be a big unlock to give it this kind of judgement

AaronAPU 4 minutes ago | parent | next [-]

Just ask it to do it. You can ask it to do a line reduction cleanup pass before each commit. I don’t know why they default to adding complexity because they are capable of doing it better just by asking.

lubujackson 42 minutes ago | parent | prev | next [-]

I have actually found decent success recently (especially with Fable) giving it an "added line budget". This does more than anything else to keep it on task. The trick is knowing an approximate line count beforehand, but sometimes the LLM will push back on what it should cut. But usually it just doesn't add all those "nice to have" redundancies and multipage comments and unit tests that check if a certain phrase is still in the error message.

summarity 42 minutes ago | parent | prev | next [-]

Keeping a simple log of "accepted/rejected" avenues is basically all that's needed, maybe with a root style guide in the project. I've got several multi-day sessions in 5.6 Sol running without going off the rails in terms of complexity. After a while in this loop it actually starts to remind/berate itself to keep things straight-forward.

conception 44 minutes ago | parent | prev [-]

I haven’t used it yet but https://github.com/dietrichgebert/ponytail is somewhat popular.