I don't think this isa fair critique at all.

Code reviews have always been about primarily reviewing others people code.

Abd knowing your won code better than others people code is a real thing?

I've realized that people have different understandings/definitions of what "simple" means.

Many people think "simple" is equivalent to easy/fast.

It often isn't. Often complexity is actually easy/fast. But simple is hard as it requires deeply understanding the problem, and fitting the right solution to where there is nothing to "simplify".

The irony of this comment.

It may not be a silver bullet, in that it needs lots of low level human guidance to do some complex task.

But looking at the trend of these tools, the help they are requiring is become more and more higher level, and they are becoming more and more capable of doing longer more complex tasks as well as being able to find the information they need from other systems/tools (search, internet, docs, code etc...).

I think its that trend that really is the exciting part, not just its current capabilities.

why is it that so many of you think there's anything meaningfully predictable based on these past trends? what on earth makes you belive the line keeps going as it has, when there's literally nothing to base that belief on. it's all just wishful thinking.

It doesn't have to keep going up forever.

All you have to believe is that there is still room for iterative improvement on the current.

I'm not saying that this is going to lead to AGI or exponential improvements.

All I'm saying is that the iterative progression is there and there are still plenty of room for ideas and improvement.

For example look at something like copilot.

First it was just chat, then inline code editing, then hooking up tools like search.

Then multi file editing, agents.

But there still plenty of space here to improve not with just better models but better tools and integrations. Why stop now?

What else is there?

I feel like all these articles have this issues.

The hard part is in knowing which is which and I don't think anyone real has a tried and true solution for it.

I think because its really about correctly predicting the future in a n continually evolving environment.

Those "simple" solutions can be piled on top of each other turn into an absolute monstrosity over time.

And then engineered solution can be overengineered and overly complex when it turns out the problems it solves never ended up happening.

On top of that people don't even think of simplicity in the same way. One person's simple is another's overly complex.

What seems to work for me is try give yourself outs/alternative paths.

Hedge your bets by overengineering slightly on where you think there is more risk. And keep it simple where there is less risk. Then reevaluate.

At Google we call these probers.

Does anyone know of any tools/saas that do this.

Was thinking it may be a good potential product.

Especially if it was super easy to generate/spin up for side projects.

I have something similar except it was Titus Winters on my final c++ readability change.

I tried to push back on one of his comments as well.

Imo it just feels kinda cool that someone who really really knows what they are doing gave you a stamp of approval on something.

Wrong library version is also a classic.

At some point it would be nice if someone could come up with a way of grounding/adding package docs and/or version as part of the context automatically