I thought like, canonically, avada kedavra fucks up your soul or whatever everytime you use it and it slowly corrupts you or something

So it has a downside.

Also, to work, you have to be able to mean it and basically be a psychopath for it to even work right.

Isn’t there explanations for why people dont just use it willy nilly?

1. Did you have MCP tooling setup so it can get lsp feedback? This helps a lot with code quality as it’ll see warnings/hints/suggestions from the lsp

2. Unit tests. Unit tests. Unit tests. Unit tests.

I cannot stress enough how much less stupid LLMs get when they jave proper solid Unit tests to run themselves and compare expected vs actual outcomes.

Instead of reasoning out “it should do this” they can just run the damn test and find out.

They’ll iterate on it til it actually works and then you can look at it and confirm if its good or not.

I use Sonnet 4.5 / 4.6 extensively and, yes, its prone to getting the answer almost right but a wrong in the end.

But the unit tests catch this, and it corrects.

Example: I am working on my own fame engine with monogame and its about 95% vibe coded.

This transform math is almost 100% vibe coded: https://github.com/SteffenBlake/Atomic.Net/blob/main/MonoGame/Atomic.Net.MonoGame/Transform/TransformRegistry.cs

The reason its solid is because of this: https://github.com/SteffenBlake/Atomic.Net/blob/main/MonoGame/Atomic.Net.MonoGame.Tests/Transform/Integrations/TransformRegistryIntegrationTests.cs

Also vibe coded and then sanity checked by me by hand to confirm the math checks out for the tests.

And yes, it caught multiple bugs, but the agent automatically could respond to that, fix the bug, rerun the tests, and iterate til everything was solid.

Test Driven Development is huge for making agents self police their own code.

Theres also a massive distinction between consuming something necessary/important, vs consuming something 100% optional.

Harry Potter isnt food, shelter, or any other kind of critical necessity.

Theres literally countless better alternatives to Harry Potter media you can choose to consume from that doesnt directly put money straight into the pocket of someone actively funding direct harm

This isn’t multiple layers of washing here, that money basically goes straight towards actively harming minority groups.

Its not even a good fucking book, and I used to be a fan of it as a kid, but I went back and read my old books and… it just fuckin sucks dawg, its not good lol.

Go pick like, any other fandom at least.

You only skill atrophy if you go and perk off playing video games while the agents cook.

If you actually are productive and spend that freed up time working on tasks the agents cant do fast and easy, aka, the hard stuff, you instead will improve your skill even faster as now you are spending most of your time on the important tasks and not wasting 95% of your workday on easy boilerplate stuff anyone with 2 braincells can pump out.

Have you actually read the study? People keep citing this study without reading it.

To directly measure the real-world impact of AI tools on software development, we recruited 16 experienced developers from large open-source repositories (averaging 22k+ stars and 1M+ lines of code) that they’ve contributed to for multiple years. Developers provide lists of real issues (246 total) that would be valuable to the repository—bug fixes, features, and refactors that would normally be part of their regular work.

They grabbed like 8 devs who did not have pre-existing set up workflows for optimizing AI usage, and just throw them into it as a measure of “does it help”

Imagine if I grabbed 8 devs who had never used neovim before and threw them into it without any plugins installed or configuration and tried to use that as a metric for “is nvim good for productivity”

People need to stop quoting this fuckass study lol, its basically meaningless.

Im a developer using agentic workflows with over 17 years experience.

I am telling you right now, with the right setup, I weekly turn 20 hour jobs into 20 minute jobs.

Predominantly large “bulk” operations that are mostly just boilerplate code that is necessary, where the AI has an existing huge codebase to draw from as samples and I just give it instructions of “see what already exists? implement more of that following <spec>”

A great example is integration testing where like 99% of the code is just boilerplate.

Arrange the same setup every time. Arrange your request following an openapi spec file. Send the request. Assert on the response based on the openapi spec.

I had an agent pump out 120 integration tests based on a spec file yesterday and they were, for the most part, 100% correct, yesterday. In like an hour.

The same volume of work would’ve easily taken me way longer.

More like “why the fuck would I walk all the way across the city now that I own a car”

Once you find out how a bunch of boring bulk tasks can be automated away and 20 hours of work turns into 20 minutes, you really dont wanna go back to the old way.

If someone asks me to code in C# without my IDE in notepad, can I do it? Sure

But it fuckin sucks losing all your hotkeys and refactor quick actions and auto complete and lsp error checking…

Would you find it weird for someone to state they’d rather use an IDE than not when coding, because it saves so much time/effort?

What the fuck are you talking about, thats not what the poster said, you’ve done weird contorting of what they said to arrive at the question you are asking now.

While some tests make sense, I would say about 99% of tests that I see developers write are indeed a waste of time, a shit tonne of devs effectively are writing code that boils down to

Assert.That(2, Is.EqualTo(1+1));

Because they mock the shit out of everything and have reduced their code to meaningless piles of fakes and mocks and arent actually testing what matters.

Do you do code reviews in meetings?

Honestly often… yes lol

Do you think testing and reviewing code was a waste of time before “AI”?

I would say a lot of it is, tbh, not all of it, but a huge amount of time is wasted on this process by humans for humans.

What the poster was getting at is a lot of these processes that USED to be INEFFICIENT now make MORE sense in the context of agents… you have vastly taken their point out of context.

Not really, for humans a lot of this stuff feels like busywork that sorta helps for certain scales of work, but often times managers went WAY too hard on it and you end up with a 2 dev team that spends like 60% of their time in meetings instead of… developing.

But this changes a lot with AI Agents, because these tools that help reign in developers REALLY help reign in agents, it feels… like a surprising good fit

And I think the big reason why is you wanna treat AI Agents as junior devs, capable, fast, but very prone to errors and getting sidetracked

So you put these sorts of steering and guard rails in and it REALLY goes far towards channelling their… enthusiasm in a meaningful direction.

I am vastly prefering copilot over claude, using sonnet 4.5~4.6 for most tasks and then pulling out opus as “the big guns” for tougher stuff sonnet cant handle easy

Copilot is only costing me ~$28 a month, which gets me 1500 premium requests per month

If you set up your flows well, 1 premium request is an entire session, so Im only paying like 2.4 cents for 20 minutes of work

Its serious and this is going to become more and more normal.

My entire workflow has become more and more Agile Sprint TDD (but with agents) as I improve.

Literally setting up agents to yell at each other genuinely improves their output. I have created and harnessed the power of a very toxic robot work environment. My “manager” agent swears and yells at my dev agent. My code review agent swears and tells the dev agent and calls their code garbage and shit.

And the crazy thing is its working, the optimal way to genuinely prompt engineer these stupid robots is by swearing at them.

Its weird but it overrides their “maybe the human is wrong/mistaken” stuff they’ll fall back to if they run into an issue, and instead they’ll go “no Im probably being fucking stupid” and keep trying.

I create “sprint” markdown files that the “tech lead” agent converts into technical requirements, then I review that, then the manager+dev+tester agents execute on it.

You do, truly, end up focusing more on higher level abstract orchestration now.

Opus 4.6 is genuinely pretty decent at programming now if you give it a good backbone to build off of.

• LSP MCPs so it gets code feedback
• debugger MCPs so it can set debug breakpoints and inspect call stacks
• explicit whitelisting of CLI stuff it can do to prevent it from chasing rabbits down holes with the CLI and getting lost
• Test driven development to keep it on the rails
• Leveraging a “manager” orchestrating overhead agent to avoid context pollution
• designated reviewer agent that has a shit list of known common problems the agents make
• benchmark project to get heat traces of problem areas on the code (if you care about performance)

This sort of stuff can carry you really far on terms of improving the agent’s efficacy.

Yeah, and it moreso moves a lot of your work over to other important stuff.

Namely, planning things better, reading, documenting, and coming up with more specific scenarios to test.

Before, because Id spend an extra chunk of my time on that 90%, maybe my documenting would be mid at best, stuff would slip through, my pile of “I prolly should get around to documenting that stuff” keeps growing and growing.

And then while maybe I can vaguely think “yeah I bet theres edge cases for this stuff I didnt make tests for”, its followed by “But I dont got time for that shit, I have to have this done by end of day”

Meanwhile with LLMs, I can set it off to cook on that 90% chunk of work, and while it’s cooking I can chat with another LLM instance and back-and-forth iterate on “what are some possible gotchas in this logic, what are edge case scenarios to test?” and by the time the agent finished coding, I have like 20 edge case test to copy paste over to it “Hey, make tests for all these cases, make sure those all work as expected <big copy paste of scenarios and expected outcomes>”

It shifts my focus over from just monkey work to stuff that matters more, finding and poking holes in the code, trying to break it, making sure it withstands stress and edge cases, and finding possible gaps and flaws in it.

When you focus like that, you definitely become way more productive.

As opposed to people who just give up and, yeah as you said, just are lazy, they hand off the work to the LLM but arent making up for that by redirecting the energy to other places of value, they’re gonna go, I dunno, run a raid in WoW or something fuck knows.

Theres a fundamental minimum amount of boilerplate you just have to write to make a functioning app, even if its simply just describing “this thing does this”

For example, if Im making a web api, theres just fundamentally a chunk of boilerplate that wires up “This http endpoint points to this domain logic over here”

And then theres gonna be some form of pre-amble of describing “it takes in this input, it returns this response, and heres all its validation”

And while its simple code, and its very simple to test, its still a buncha LOC that any half assed dev can write.

Stuff like that AI can shit out very quick given an input requirements doc that you, the dev, were gonna get anyways

And then you, the dev, can fill in the actual logic that matters after all that basic boilerplate stuff.

“Yes, it has a phone number input, its required, and it must fit the phone number regex we defined. So… shocker, you gotta put a string called PhoneNumber on the inptu model, and another shocker, its gotta have the phone number validation on it and required non empty string validation on it”

It doesnt take much trust to put into the LLM to get that sorta stuff right, but it saves me a whole bunch of time.

Pretty much, its the actually important code you wanna pay attention to.

The majority of code is just connecting pipe A up to pipe B, its honestly fine for an LLM to handle.

The job security comes from, as a developer, knowing which code goes in the 90% bin vs which goes in the 10% bin, being able to tell the difference is part of the job now.

Meanwhile everyone I work with is loving the smooth copilot integration with vscode.

Its so good at automating boilerplate stuff.

Especially testing, oh god does it make writing tests faster. I just tell it the scenarios that have to be tested and boom, 1000 lines of boilerplate produced in like 5 minutes.

And when it has existing code to use as a reference on how to do it right, it does a very solid job, especially repetitive stuff like tests, since usually 95% of the code in a test is just arranging and boilerplate setting up the scenario.

Also “hey go add xml docs to all the new public functions and types we made” and it just goes and does it, love that lol

Once you acknowledge like 90% of your code is boilerplate and sonnet/opus are extremely capable at handling that stuff when they have existing references to go off of, you can just focus on the remaining 10% of “real” work.

Getting a later special meeting request with the ceo, at one company, because he wanted feedback on their interview process itself. He then offered me a different job and I had to decline cuz I already accepted another (this was a few weeks after the initial decline I gave)

In another case they just fast tracked me and I ended up declining the job anyways (didn’t like the job)

I’m full time employed but I still do occasiobal interviews to keep feelers out for how the market is. But I typically decline most offers cuz they’re not good enough to get me to actively quit my current job.

Same, I’ve started just stating I have a maximum of 3 interviews I do before I auto-reject the offer.

This has had interesting results.

In the “right” use case, story points should just represent relative effort.

The hours dont matter, its more about ranking how challenging a task is, in order to help the manager rank the priority of tasks.

You should have typically 2~3 metrics:

1. Points, which represent relative effort of the task to the other tasks you are also ranking.

2. Value, how much value does doing this task provide, how important is it

3. Risk, how risky is it that this might break shit though if you make these changes (IE new features typically are low risk since they just add stuff, but if you have to modify old stuff now your risk goes up)

If you have a good integration testing system automated, Risk can be mostly removed since you can just rely on your testing framework to catch if something is gonna explode.

Then your manager can use a formula with these values to basically rank a priority order for every ticket you now scored, in order to assess what the next thing is that is best to focus on.

Sorts? Not tabs in the way you’d expect but it’s default ones can be sufficient

Honestly though once you get pretty good with hotkeys you stop using tabs, for all intents and purposes harpoon is tabs, but better, and without the UI. You just mentally usually pick harpoon keys that make sense to save jump points to, like I’ll harpoon FooController.cs to c and FooService.cs to s and FooEntity.cs to e and so one

And the I jump around with those keys. Usually when working I only need tops 5 harpoon or so for a chunk of work.

I still boot in sub 1s so I don’t know what you mean by “bloated”

Lazy allows you to boot ultra fast by loading stuff in the background later, so “bloat” doesn’t matter

nvim-dap does literally nothing until you trigger it, so it’s only impact on my startup is like 3 hotkey registrations :p

It’s a perfectly fine debugger, works great. The fact I can telescope search to fzf my stack trace actually kind of makes it superior? Like you can’t do that sorta stuff in any other IDE I know of

Also all my navigation stuff like telescope/harpoon/etc still apply when debugging, so I can literally debug faster jumping around the stack trace with hotkeys.

Neovim doesn’t get any less awesome when it comes to debugging, a lot of it’s power still applies just as much haha

A lot of them are dependencies of other plugins.

Stuff like icons support, and every little feature. Neovim is extremely minimalist to start, so you need plugins just to get something as simple as a scrollbar lol

Things like git status of files and file lines, all your LSPs, syntax highlighting (for each language you work with), file explorer, you name it, there’s a lot.

But what’s nice about nvim is for any of these given features, there’s numerous options to pick from. Theres probably a dozen options to choose from for what kind of scrollbar you want in your editor, as an example.

So you end up with a huge amount of plugins in the end, for all your custom stuff you have configured.

You have to setup yourself (though theres a lot of very solid copy pasteable recipes for each feature):

• Scrollbar
• Tabs(if you want em)
• bookmarking
• every LSP
• treesitter
• navigation (possibly multiple of them, I use both a file tree, telescope, and harpoon)
• file history stuff
• git integrations, including integrating it with the numerous other plugins you use (many of them can integrate with git for stuff like status icons)
• Code commenting/uncommenting
• Code comment tags (IE TODO/BUG/HACK/etc)
• your package manager is also a package (I like lazy for wicked fast open speeds, neovim opens in under 1s for me)
• hotkey management (I like to use which-key)
• prose plugins (lots of great options here too, I use nvim for more than just coding!)
• neorg, so I can use nvim for taking notes, scheduling stuff, etc too
• debugger via nvim-dap
• debugger UI via nvim-dap-ui
• lualine, which is a popular statusline plugin people like to have at the bottom of their IDE for general file info
• new-file-template which lets me create templates for new files by extension (IE when I make a .cs file and start editting it, I can pick from numerous templates I’ve made to start from, same for .ts, .lua, etc etc)
• git conflict, which can detect and work with detected git merge conflict sections in any type of file and give me hotkeys to do stuff like pick A / B / Both / Neither, that sorta stuff

The list goes on and on haha