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.

I mean for what its worth, if the dude has a partner they couldve just picked the kid up, its not exactly unheard of for one partner to do drop off and the other do pick up… kind of a lukewarm take here.

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?

At absolute worst, bare minimum, these tools function as incredibly fast fuzzy intent based searchers on documentation

Instead of spending 10 minutes on “where the hell is (documentation) Im trying to find” these tools can hunt them down for me in a matter of seconds.

That already makes them useful just for that, let alone all the other crazy shit they help with now.

People malding but its the truth.

You are living under a rock if you think any major software now doesnt have AI written pieces to it in some manner.

Its so common now its a waste of time to label it, you should just assume AI was involved at this point.

Mario64 does have kind of a creepy liminal vibe to it.

Long ass empty hallways, rooms with just a giant mirror, no sound except kind of haunting/enchanting music and the echo of your footsteps.

It is objectively a pretty creepy / empty vibe to it, because in the game bowser has taken over the castle, so its supposed to be a bit spooky/creepy in a bunch of spots.

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.

As a Canadian, like how this only goes down to -20c, meanwhile we went below -40c in plenty of areas this winter.

… Proceeds to use Svelte cuz it has the exact features I want

React is popular but I honestly don’t care about llm weenie vibe coder junior devs being biased towards react. Lions don’t concern themselves with the opinions of sheep.

The majority of shit apps are being made with react sure.

But skilled seniors who intend to make something robust don’t even tend to have an llm enabled that will even influence their opinion on the first place. The majority of senior devs keep repeating the same sentiment: llms primarily are slowing them down more than helping.

Junior devs that crutch on llms are falling behind and the quality of their output shows. They grow slower and produce worse output.

It’s one thing to use it for monotonous tasks, but if it influences your higher level important decisions you are probably already cooked.

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.

The fact anon used IPA as an example in the context of “acronyms they had to go look up the meaning of” says a lot about them, ngl.

The tacked on casual transphobia finishes painting the picture of the sorta person they are.

If it makes you feel better, lego is actively chasing this out and switching to paper packaging! I’ve started to see it more and more on newer sets.

At least they’ve stuck with cardboard + paper packaging on everything else from the start.

Though, the fact lego is in of itself plastic sorta will always be an inherent problem… lol

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.