Comment by BatteryMountain | Hacker News Reader

Comment by BatteryMountain | Hacker News Reader

Parent Full thread

BatteryMountain

When you change a single setting in the IDE to make something more strict and you have 1M+ lines of code, you will get 30K items to fix, via red/yellow/blue squiggles in the IDE. Most of those can be simple refactorings, but the performance & UI of the IDE makes it incredibly unwieldy and it will sometimes fight you back, sometime crash internal processes which leave refactorings half baked and so. Now imagine you change 50 such settings, to make the compiler force you to write better code. Changing 200K+ lines of code yourself is a nightmare (and to prove it still does the same thing afterwards). Instead, claude systematically approaches whole classes of errors and convert them to cleaner variants (either using our custom skills or it writing new scripts to do it). I consider myself an advanced user of IDE's, know how to do bulk refactoring and renames and so on (esp with JetBrains tools), and I would say it would be a near impossible task to do as a human. Then there are other developers - so you flip a setting and now 5 other people's IDE's are forcing them to work a specific way which will make you unpopular very quickly and revert the changes. So, since most of us no longer use IDE's as our main tool to build/diagnose, we can more easily flip compiler settings without destroying someone else's week. Hope that makes sense.

Oh it also helps to split refactoring work into three buckets: business logic changes, performance changes (same output as before but faster) and cosmetic changes (rename files/folders/classes, breaking large files up, add logging/comments, domain layering etc). We tend to focus on performance and cosmetic changes for bulk refactors and leave logic changes to more dedicated sessions as to avoid changing what the system do (our domain is fairly complex and we cannot afford breakages). We also managed to port ALL of our code to dotnet 10 lts and have clean boundaries between projects (we have a mono-repo with about 50 projects in it), so we can wholesale upgrade dependencies without a sweat.

IIUC, your point is that changing IDE settings will affect other developers. But can't you enable an inspection locally, apply all or some of the quickfixes and revert the setting before committing? In the longterm, you want to enable the inspection anyway because the point is to prevent developers or agents from comitting new code that violates it (agents can access JetBrains IDEs' MCP Server to get inspection results).

Of course, crashes and bugs can happen when applying quickfixes, which isn't nice. Ideally, they should be reported and fixed. You can also ask an agent to fix the occurences instead of using the IDE quickfixes if that's blocking you.

I guess what I'm trying to say is that IDEs shouldn't make that process harder, they can actually improve agents' results. For example, you don't need to write custom skills to prevent agents from writing some class of bugs if the IDE can detect it and agents have access to the results.

> Changing 200K+ lines of code yourself is a nightmare (and to prove it still does the same thing afterwards).

If an agent does it, you still have no proof, but okay.

Full disclosure, I work at JetBrains, but not in the IDE department.

The problem is, even if I only enforce some rules locally, another developer has a different set of rules. So when we git commit, we ping-pong changes and fix each others stuff over and over again, bloating commits. We used editor config files + analyzer configs in the past (that gets checked into version control too), but there were still too much friction.

Where now, the compiler flags & strict analyzer settings forces claude to do the right things (we explicitly tell claude not try and bypass or lower the barrier). I think it only works because we don't spend 95% of our time in the IDE anymore like a couple of years back, so we as developers no longer feel that friction, as claude tries to satisfy the compiler instead. Its a massive mental load that is just gone, we haven't had any conversations in meeting about this kinda stuff anymore (remember in the past we would have flameouts in meetings or code reviews about linter settings...).

> it also helps to split refactoring work into three buckets: business logic changes, performance changes (same output as before but faster) and cosmetic changes (rename files/folders/classes, breaking large files up, add logging/comments, domain layering etc).

Do you have a specific skill to guide an agent to scope the work of an agent so it stays in one particular bucket? Would you mind sharing it?

State of the art agents don't usually need such fixed guidance anymore. I've been using Opus 5.5 with Xcode and simply prompting things like "make sure all of our test Suites use the .dependencies modifier, but only if they use dependencies internally" or "make sure none of our test methods are @MainActor, just access the necessary state using standard concurrency constructs". For larger changes, providing the examples you want is often enough to get it most of the way, or even all the way, there. I've had simples prompts for things like "move all standalone SwiftUI view that seem reusable to our Design framework, and create a list of those which can't be moved without effort, listing by complexity".

Overall, there's much less need for prompt skills anymore. They're still very useful for things like best practices, or things you need to make as reproducible as possible, but big skill and planning sessions aren't nearly as necessary anymore.

Reply on news.ycombinator.com