I don't think the "complete PR spanning multiple files" is an issue actually.

I think the issue is if you don't yourself understand what it's doing. If all you do is to tell it what the outcome should be from a user's perspective, you check that that's what it does and then you just merge. Then you have a problem.

But if you just use it to be faster at getting the code you would've liked to write yourself, or make it write the code you'd have written if you had bothered to do that boring thing you know needs to be done but never bothered to do, then it's actually a great tool.

I think in that case it's like IDE based refactorings enabled by well typed languages. Way back in the day, there were refactorings that were a royal pain in the butt to do in our Perl code base. I did a lot of them but they weren't fun. Very simple renames or function extractions that help code readability just aren't done if you have to do them manually. If you can tell an IDE to do a rename and you're guaranteed that nothing breaks, it's simply a no brainer. Anyone not doing it is simply a bad developer if you ask me.

There's a lot of copy and paste coding going on in "business software". And that's fine. I engage in that too, all the time. You have a blueprint of how to do something in your code base. You just need to do something similar "over there". So you know where to find the thing to copy and paste and then adjust. The AI can do it for you even faster especially if you already know what to tell it to copy. And in some cases all you need to know is that there's something to copy and not from where exactly and it'll be able to copy it very nicely for you.

And the resulting PR that does span multiple files is totally fine. You just came up with it faster than you ever could've. Personally I skipped all the "Copilot being a better autocomplete" days and went straight into agentic workflows - with Claude Code to be specific. Using it from within IntelliJ in a monorepo that I know a lot about already. It's really awesome actually.

The funny thing is that at least in my experience, the people that are slower than you doing any of this manually are not gonna be good at this with AI either. You're still gonna be better and faster at using this new tool than they were at using the previously available tools.

Spend time reviewing outputs like a tech lead does when managing multiple developers. That's the upgrade you hust got in your career, you are now bound to how many "team members" you can manage at a single time. I'm grateful to live in such a time.

The code is the mental map. Orchestra conductors read and follow the music sheet as well. They don't let random people comes in and mess with. Neither do film directors with their scripts and their plans.

LLMs lack intentionality, and they lack the ability to hold a series of precepts "in mind" and stick to those precepts. That is, if I say "I want code that satisfies properties A, B, C, D..." at some point the LLM just can't keep track of all the properties, which ones are satisfied, which ones aren't, what needs to be done or can be done to make them all satisfied.

But LLMs aren't "only good at stuff that better languages don't require you to do." In fact they are very good at taking a bad function definition and turning it into an idiomatic one that does what I wanted to do. That's very intelligent, there is no language that can take a bad spec and make it specific and fit for the specified task. LLMs can. (not perfectly mind you, but faster and often better than I can.) The problem is they just can't always figure out when what they've written is off-spec. But "always" isn't "never" and I've yet to meet an intelligence that is perfect.

Are you still going to have the skills to review it a year from now? Or 5 years from now when you’ve become accustomed to only writing <20% of the code? I’m already witnessing my coworkers skills degrading because of this, and it’s only going to get worse. Programming is a language, and when you don’t use it, it fades.

> Why do I need to waste time writing boring code?

Some people actually enjoy that, believe it or not.

> Why do I need to waste time writing boring code?

The better question is: should that boring code be written? Code should only be non-boring.

The boredom of writing the code is not the only problem. The subsequent continued indefinite existence of that code is also a problem.

This reminds me of the phenomenon of competence being inversely correlated with confidence until some inflection point is reached on the journey to mastery.

I think the argument being put forward here is that writing that boring code is part of the journey to mastery. If you haven't crossed the inflection point, a backwards slide in skills will result in less competence and more confidence, which is a scary thought given how software runs the world.

What you shouldn't forget also is that, while AI may be good at coming up with a "first shot" solution, it may be much worse if you want to change/correct parts of it.

In my experience, AI very often gets into a sort of sunk-cost fallacy (sunk prompt?) and then it is very hard to get it to make significant changes, especially architecturally.

I recently wrote an extension for a popular software product and gave AI the same task. It created a perfectly working version however it was 5x the lines of code of my version because it didn't know the extension API as well, even though I gave it the full documentation. It also hard coded some stuff/solutions to challenges that we totally don't want to be hard coded. A big reason why I arrived at a much better solution was that I used a debugger to step through the code and noted down just the API interactions I needed.

The AI also was convinced that some things were entirely impossible. By stepping through the code I saw that they would be possible by using parts of the internal API. I suggested a change to make the public API better for my use case in a GitHub issue and now it is totally not impossible.

At the end of the day I have to conclude that, the amount of time invested guiding and massaging the AI was too much and not really worth it. I would've been better off debugging the code right away and then creating my own version. The potential for AI to do the 80% is there. At this time though I personally can't accept its results yet but that may also be due to my personal flavour of perfectionism.

The fear and pain of writing boring code gave us the processes and systems we have today. i.e. microservices, (I know they have their own problems) were born out of pain from maintaining monoliths. Agile (again, own problems) was born out of pain from waterfall.

What happens when all pain and boredom is taken away? Why do we need to invent new frameworks, systems, design patterns in that scenario?

This comment captures it: https://news.ycombinator.com/item?id=44906987

> AI can do 80% of the work. I can review it later. And I spend much less time reviewing than I would have typing up everything manually

Are you sure you're actually reviewing the code? Deeply, properly reviewing and understanding it? Because from what I've seen people that say they do, don't. That's why they 'speed up' from using LLM-generated code.

The old adage that it's far harder to review code than to write it still holds true.

Its because most people don't have the discipline and obsession of attention to detail to know when one should use an LLM and when one shouldn't.

I highly doubt the best of the best folks are even touching LLMs (barely) because they can see the flaws and the tradeoffs that are not-so-visible to others until they are 50 levels deep, with sunk investments, unwilling to go back to how they used to do things.

> When was the last time you saw someone profile their code?

A year ago. I heavily relied on one to optimize a complex data import that took an hour for a million line Excel file. The algorithm translated it to a graph according to a user-specified definition and would update an existing graph in neo4j, keeping the whole thing consistent.

The only other guy who understood the algorithm (a math PhD) thought it was as optimal as it could get. I used the profiler to find all the bottlenecks, which were all DB checks for the existence of nodes, and implemented custom indices to reduce import time from an hour to 3 minutes.

It did introduce a bunch of bugs that I had to fix, but I also discovered some bugs in the original algorithm.

It was one of my best programming experiences ever. Especially the payoff at the end when it went down from an hour to 3 minutes is a dopamine rush like never before. Now I want to optimize more code.

I don't think users cared, though; originally this work would take days by hand, so an hour was already pretty good. Now I made something fiendishly complex look trivial.

Ah, I'm bookmarking this. Thanks for writing this :)

I love how you put it: "grab a fucking profiler before you optimize". I get complaints sometimes about using FP because of performance, and I think a variant of "grab a fucking profiler before you optimize" is much better response than "avoid premature optimization". Introducing them to a magical thing called as "profiler" is a nice bonus too.

> Problem is we've taken the idea of "minimum viable product" too far. People are saying "Doesn't have to be perfect, just has to work." I think most people agree. But with the current state of things? I disagree that things even work. We're so far away from the question of optimization. It's bad enough that there are apps that require several gigs to just edit a 30kb document but FFS we're living in a world where Windows Hello crashes Microsoft Outlook. It's not the programs are ugly babies that could be better, they are monstrosities begging to be put to death.

LOL. OMG that was beautiful. It almost feels like we are de-evolving software to a state where shit is going to stop working bad. I know this is not full of facts, but this take reminds me of Jonathan Blow's video "Preventing the Collapse of Civilization"[0] Where he talks about how code runs worse than it ever has and I think he was arguing that civilization is collapsing before our eyes in slow time.

[0]: https://youtu.be/pW-SOdj4Kkk?si=LToItJb1Cv-GgB4q&t=1089

I invite your attention to the StatsD telemetry protocol, where:

1. Every single measurement in a timeseries is encoded as a utf-8 string having (roughly) the following format:

  "${name}:${value}|${type}|${tags}"

2. Each and every one of these things is fired off into the ether in the form of a UDP datagram.

3. Whenever the server receives these presumably it gets around sometime to assigning them timestamps and inserts them into a database, not necessarily in that or any other particular order.

"it is the way it is[1]."

[1] https://github.com/statsd/statsd?tab=readme-ov-file#usage

Yep, I don't think you'll ever see AI code near the payment system. Or the code managing the store and the cart systems.

<< you do not know where that missing 25% is wrong

I think there is something to this line of thinking. I just finished a bigger project and without going into details, one person from team supposedly dedicated to providing viable data about data was producing odd results. Since the data was not making much sense, I asked for info on how the data was produced. I was given SQL script and 'and then we applied some regex' explanation.

Long story short, I dig in and find that applied regex apparently messed with dates in an unexpected way and I knew because I knew the 'shape' that data was expected to have. I corrected it, because we were right around the deadline, but.. I noted it.

Anyway, I still see llm as a tool, but I think there is some reckoning on the horizon as:

1. managers push for more use and speed given that new tool 2. getting there faster wronger, because people go with 1 and do not check the output ( or don't know how to check it or don't know when its wrong )

It won't end well, because the culture does not reward careful consideration.

>The analogy falls apart because the quality of an assembly line produced car is higher than the hand crafted one.

What? So Your Jeep Compass is higher quality than a 458?

Because we're not even close to that happening. However I've observed a sort of cognitive decline in a few formerly experienced and extremely knowledgeable developers whom I used to respect. They happen to be the most vocal supporters of LLMs now and sometimes our discussions get so ridiculous I have to practically beg them to put the LLM down and just think about what they're saying for just 5 seconds. I think they're about a year away from believing that the sky is green if the AI says so.

So maybe LLMs will win on a technicality by making us more stupid as a species.

Progress under current paradigms has gotten much slower

Extraordinary claims require extraordinary evidence and if there's one thing we've learned is that progress in AI is not linear nor predictable. We've been a few years away from fully self-driving cars for a really long time now.

Everyone who wants to. Right now the barrier is too high for some people who want to.

Oh sure. But it doesn't need to be everyone; my go-to analogy is how we used to do "cars" vs a lot of them now?

50 years ago, you don't have to be a car guy, but if you know one, that's all you need to save a LOT of money and headache.

Today, that kind of works -- unless you own e.g. a Tesla.

"many people don't want to do this, no matter how easy it is --"

Lol lets get real. Most people want to live life and switch off their brain.

Absolutely nothing wrong with that - you can't fight what the body wants instinctively.

Can you describe how to access this feature? I can't find anything about this online, and I asked Claude on command line and nothing comes up for "learning mode"

Seems very cool.

Ah, cool. Is this meant to be used for learning specifically, or just something that can be toggled whenever you're using Claude to help you with anything?

This doesn't just apply to software development - it applies across the board in any form of knowledge.

An example would be economics - an LLM can spit out a bunch of words about an economic model. But if you don't take the time to learn, visualise and understand it for yourself - it means nothing to you. And in that case, if you already possess mastery why would you waste your resources playing around with an inferior tool to you?

You wouldn't.

Most people have only one chance to learn reading and writing, when they are kids. After that it gets exponentially harder.

When has that ever happened?