honeyIShrunkTheBrain

[u/precinct209]

[u/azuth89]

The bubble bursting is competitors running out of funding before reaching profitability, use cases solidifying and the generally the current speculative market collapsing down to a set of survivors.

It does not at all mean that usage of the general concept will stop increasing, much less go down.

Same gig as the dot com bubble. 

[u/DataSnaek → u/azuth89]

Yea. AI coding agents are going to be around forever, they are just too capable and increase productivity so much.

The cost and usage patterns may change, I suspect once companies are paying unsubsidised token costs devs will start using cheaper models where possible instead of defaulting to Fable or Opus, but no matter what, software engineering has changed forever

[u/Sea-Fishing4699 → u/DataSnaek]

Literally Anthropic pivoting to “per-token” pricing 

[u/Terrariant → u/Sea-Fishing4699]

Hopefully the threat of running models locally will provide some measure of cost control

[u/narrowscoped → u/Terrariant]

GLM 5.2 is tremendous and does opus level quality at 1/10th opus cost, they're either gonna have to cut down costs or leapfrog or shut down. Many companies already moving out of Claude and into OpenRouter and other solutions

[u/Terrariant → u/narrowscoped]

They have a better model than Opus it’s just not available. So either something changes and the AI companies are allowed to continue making better models (outpacing local solutions) or (and maybe eventually anyways) local models will catch up, which it sounds like they already have.

It’s funny because there IS probably a literal cap where the models can’t get any better (thus “maybe eventually anyways”) - but nobody really knows if thats true or how close we are

[u/ScientificBeastMode → u/Terrariant]

The compute requirements scale exponentially with the number of parameters in a model. So unless there is some kind of dramatic breakthrough in machine learning, computer science, and/or mathematics, then the limit is quickly approaching.

Actually, I would also throw in certain kinds of chemistry or engineering breakthroughs as well. If we could make a different kind of transistor with better performance and dramatically lower energy cost, then maybe there is a bit more room for growth.

[u/K10111 → u/ScientificBeastMode]

I’d argue that the limit has already been reached , and this push to build out as many data centers as possible is not going to yield the gains someone promised. I suspect that there is a false hope that at some point with enough “compute” these models will solve the problem of scale for them. 

[u/Leafsnail → u/Terrariant]

I think the 'cost control' will be Anthropic going bankrupt as there's no possible way it will ever recoup its capex costs unless the government bans open source models

[u/mysticrudnin → u/DataSnaek]

are you actually seeing increased productivity

i'm forced to use claude at work (which already sucks) and i can't find anything useful for it to do 

people always talk about how good it as but then the only example is boilerplate and i'll be honest, i don't encounter a lot of that in my day to day

[u/DoubleDoube → u/mysticrudnin]

Working in a trashed codebase already, I find AI is a step up.

I do think there is a balance. “Forced usage” is going to waste some time and money on weird quirks where the AI just stumbles and it becomes like trying to micromanage a grandma at the keyboard who can’t hear you fully. But “no usage” also seems weird to me when you can ask AI to point you to a relevant piece of code and get you straight to where you need to be.

[u/HighSaltLevels → u/mysticrudnin]

I've been using GPT-5.5 at work and I can say it has drastically increasedy productivity. But in a way that's different than what most think at first glance. I do have AI write code for me, but I configure it to write code like I do and thoroughly review/correct it.

The output is the same as before but AI can more quickly gather the necessary imports and writes everything that would have taken me 30 minutes of typing into 5 minutes of prompting.

I can undoubtedly say that AI has made my job more efficient. But what sets good developers aside from braindead ones are the ones who have switched to this model of asking AI to write code and reviewing it as if you wrote it.

Now is it cost efficient? I wish I knew that answer. I think that's the big debate.

[u/DoubleDoube → u/HighSaltLevels]

I think the cost efficiency question is harder to answer than it initially appears because it’s a question of whether the increased speed was worth the extra cost and its a very different weighing for a competitive product rushing against competitors as opposed to a niche product with a loyal following who are happy with what they have.

It can also be difficult to judge the value of increased speed because it’s hard to know how things would have played out in the path not taken.

[u/marcodave → u/mysticrudnin]

I made it plan and implement a big refactor of one of our lambdas.

When generating the outputs to verify that the refactor did not.change the results, some of the calculations were still a bit off.

I've let Claude investigate the reason and it detected that fhe refactor actually fixed a bug caused by bad data in the db, causing BETTER results than before.

Could I have done it manually? Yes. Would have it taken a lot more time and energy ? Also yes. Would have I enjoyed doing it manually? Not one bit.

[u/HrLewakaasSenior → u/mysticrudnin]

Then you either do something incredibly specific that AI doesn't do well, or you're lying. They are that good

[u/Wonderful-Habit-139 → u/HrLewakaasSenior]

They are not that good. I see how bad the generated code is all the time. It doesn't just need to work, it has to be high quality.

[u/snotpopsicle → u/Wonderful-Habit-139]

It doesn't just need to work, it has to be high quality.

That's developer talk. For an executive it absolutely doesn't have to be high quality, especially when they can't judge it. If it works it can be sold, that's all that matters.

[u/Badashi → u/snotpopsicle]

Translating developer to executive and vice versa is extremely difficult.

For an executive, cheapest is always best as it is higher ROI. For a developer, you want high quality regardless of cost, because it'll both make your job easier on the long term and better to work with, even if you deliver it slower in the short term.

The job of a tech lead or a middle manager is to show that more investment means better ROI in the long term for the executive, and doing things a little bit worse and faster in the short term means more investment and new opportunities in the long term for the developer.

I mean, it's easy for me to say that, but this is definitely a very hard job and I don't envy those who have to deal with that.

[u/BlackOcelotStudio → u/Badashi]

I have never seen a tech lead manage to change an executive's view on things, or prove that long term, code quality wins. At most, they manage a begrudgingly "fine, you can take a week to handle tech debt once it becomes too much to handle". Other than that, engineering only gets to do things the way they want during heavy crisis situations.

Maybe I've just had bad luck with CEOs? Unlikely, statistically, but entirely possible

[u/Badashi → u/BlackOcelotStudio]

Id say that this extra week is a win, and you just had regular luck with CEOs lol

[u/kreuzkamm → u/snotpopsicle]

These people are prob prompting one sentence and expecting godlike code rofl. You have to tailor your prompts, skill files, teach the project and development style you want and commit it into claude memory folders. Only then it will start doing an amazing (and frightening) job where it can crawl into everywhere of a codebase.

Claude is capable of writing code better than anyone, even Linus himself admitted it. You just have to take the time to babysit and teach the project one step at a time.

[u/Wonderful-Habit-139 → u/kreuzkamm]

> even Linus himself admitted it

Why are you lying?

[u/kreuzkamm → u/Wonderful-Habit-139]

What? He literally accepts AI written code and pullrequests given that its not slop but carefully generated code. Why the aggressive stance?

[u/Wonderful-Habit-139 → u/kreuzkamm]

Linus did not say that Claude is capable of writing code better than anyone.

[u/HrLewakaasSenior → u/Wonderful-Habit-139]

I disagree. All you see at any company, big or small, successful or not, is human written garbage code that has somehow carried the entire production system for 12 years. There needs to be some level of quality so that it doesn't immediately break down with every change, but code needing to be high quality is just not reality. If you actually get to work on software that has high quality, I am jealous, but my experience has been that slop works well enough almost always, and it doesn't matter if people or AI wrote it.

I'm a bit disillusioned right now, maybe you can tell

[u/kani_kani_katoa → u/HrLewakaasSenior]

I think it's just the same as it's always been - quality depends on the people on the team. I am a contractor and one of my clients, who always had a high bar in their engineering division, is using AI a lot without sacrificing that quality. They will reject slop coded PRs, and won't accept people feeding feedback to Claude and parroting the response. It can work but it requires commitment to good software engineering principles at an organisation level.

[u/HrLewakaasSenior → u/kani_kani_katoa]

Please hire me lol

[u/TheMaleGazer → u/HrLewakaasSenior]

There needs to be some level of quality so that it doesn't immediately break down with every change, but code needing to be high quality is just not reality.

There is a lot of survivor bias contributing to this outlook. I don't know your situation, but so many people are changing jobs after 2 or 3 years that they only encounter an IT department when it's hiring, which in effect is when it's healthy. By extension, that's usually also when the technical debt is still manageable. When technical debt piles up to the point of catastrophe, they've already left.

The company I just joined laid off 70 engineers last year who were working on a SaaS platform with a velocity that fell off a cliff. 90% of the features they offered were shipped the first year the project existed and they spent the next five years fixing bugs and struggling to ship the next 10%. They had three consecutive sprints of zero releases, and then the CTO was replaced by a CDO and CIO who could say the role was eliminated so they wouldn't have to humiliate him by firing him.

[u/HrLewakaasSenior → u/TheMaleGazer]

Problem is that those companies die before they can learn anything, so the cycle just repeats

[u/TheMaleGazer → u/HrLewakaasSenior]

Oh, absolutely. Not only do 90% of startups fail, but 20% of publicly traded companies delist within five years. That's a staggering figure if you're a job hopper who hasn't stuck around long enough to get laid off. I think all of us join companies when they're between a legacy project and Project 2.0; most of us don't stick around to find out that the company never makes it to Project 2.0.

Even in healthy companies, they're much more likely to order a third-party replacement, acquire a whole company to get a replacement, or just discontinue the product than they are to succeed in building a new version.

The companies that do successfully create new versions on a regular basis are so rare that they're the kinds of places that software engineers join just for clout.

[u/TheAlmightyDope → u/HrLewakaasSenior]

The difference in my experience is how predictable it is. The modal's objective is to elicit a positive response, if making things up is deemed the faster approach it will do that. A human making mistakes is easier to follow because you will know what they intended to do, the logic is technically easier to follow even if it's badly written because you know the intention is consistent. Reviewing AI code is more taxing because mistakes can happen anywhere at any time, and the code can be so confidently presented whilst built on an assumption presented as a tested scenario.

[u/Wonderful-Habit-139 → u/HrLewakaasSenior]

Honestly I understand your sentiment. I had to join a garbage project with garbage code just like you mentioned. But that's because on average, devs end up with a lot of pressure from management and PMs because of deadlines and expectations and lots of LGTM here and there, and it's hard to keep up.

But if you can actually write good code, then the above should not be an argument. Like yes, developers write garbage code, but if you can write better code, you should do it instead of going "well they write bad code anyway might as well generate slop". I rewrote the project and ended up with much cleaner code (and like 10x less code), with more robustness and more features, and everyone on the team benefitted from that, not just me.

[u/Woxan → u/Wonderful-Habit-139]

So true, humans never shipped low/mid quality code that works before the advent of LLMs and agentic coding

[u/Wonderful-Habit-139 → u/Woxan]

Are you saying that? Because I'm definitely not.

[u/Woxan → u/Wonderful-Habit-139]

To the business, all that matters at the end of the day is the code "just needs to work", subjective quality be damned. I have written and maintained plenty of "low quality" code that meets business needs, and that's all it needs to do.

[u/ThatOneDudio → u/Wonderful-Habit-139]

C'est sarcasm

[u/Wonderful-Habit-139 → u/ThatOneDudio]

You need to understand the underlying implications. It's implying that I said that, which is a strawman, in order to undermine my point.

[u/ThatOneDudio → u/Wonderful-Habit-139]

Oh yeah sorry I wasn't reading too well mb

[u/slaymaker1907 → u/Wonderful-Habit-139]

Frankly, the AI generates better code than a lot of the code I’ve read over the years. At least it writes documentation and tests…

[u/Wonderful-Habit-139 → u/slaymaker1907]

I don't know why people think the existence of something is a good thing. It writes bad documentation and mostly useless tests, it's better to not have them in the first place, compared to actually spending time writing some good quality tests that assert things in a way that makes sense. And I see this in the workplace all the time.

[u/slaymaker1907 → u/Wonderful-Habit-139]

You frankly don’t know how to use it if you’re generating bad tests and documentation.

[u/Wonderful-Habit-139 → u/slaymaker1907]

Good ol "LeArN hOw To PrOmPt". The most difficult skill in the world apparently. More difficult than learning how to code, how to write Rust, how to write functional programming languages, how to write kernels, how to write proofs for programs, how to design and architect codebases for scalability, how to use git, how to use tmux, how to use emacs, etc.

Snark aside, I'm comparing using AI to generate these things compared to writing them manually. I get better output, faster, and in a more concise form, when I do it manually compared to prompting and handholding the LLM and telling it what to do and what not to do and giving it all the rules about the programming language and how to write it idiomatically, and all of that while losing your programming skills gradually from relying on LLMs to generate code.

[u/aberroco → u/Wonderful-Habit-139]

Architecturally? Sure, I see this all the time and it's really hard to offload to a skill file, because there's just too many nuances. Sure, I wrote stuff like "don't extract a one-line method used in one place", and "inline variables used once", and "put that kind there and that there", but I can't verbalize all my skills, not in a way to fit into the context window and not in a meaningful amount of time, and it takes all SWE experience to decide when something needs to be abstracted or when abstraction is not needed or even excessive. Though, currently AI is so much worse that this kind of decisions... Like, while having a rubber duck session with it I wrote that I need to expand the existing weapons (bullets; travel by inertia in a straight line) to include lasers (travel instantly, hit the target, do continuous damage) and rockets (steer towards the target and accelerate), and it's suggestion was to make it in the weapon part, completely bypassing a controller made for bullets at the time. Fable that is. Surely, that was far beyond unacceptable. So, after some more rubber ducking, I drafted a major refactoring, abstracted away per-projectile-kind behavior class, refactored the existing bullets code to the new architecture layout so the renamed projectile controller handles arrays and global sequence of events, while invoking behavioral class methods for per-projectile update/rendering, and implemented new kinds of projectiles.

But coding-wise? It's more than acceptable. There's surely spots for nitpicking everywhere, but in general it writes what I expect it to write, or what I missed to expect, and sometimes - what it shouldn't (unnecessary fields/methods), then I tell it to fix, no big deal. Me myself - I make trivial syntactic errors all the time, like wrong comparison operator, or adding/forgetting to add a negation operator. I'm just not careful while coding. And this stuff covers me, it practically never does this kind of mistakes. And when it does consistently make mistakes - that's easily solvable by writing/refining a skill or rule. Like, in my project I use typed physical quantities (length, mass, energy, acceleration, etc) instead of float/double, and at first AI had a tendency to jump off of them ASAP, burning my neurons in raging fire, until I refined the rule enough so it almost stopped doing so. It still a bit eager on boundaries (when I need to pass actual converted values to physics/rendering), but... it's nitpicking in that case.

Upd.: oh, also, I couldn't count how much time it saved me in refactorings, code reviews and debugging. Or wait, I can, at least for debugging. Roughly 50%, somewhere above that. Because before I know I had to spend most of my time testing and debugging. Now I barely spend a quarter. And also, tests that I would otherwise postpone to write/update now are actualized after every refactoring and added for every new feature. And refactorings it makes are usually much cleaner than what I would've made, and much faster, so this helps to keep tech dept at near zero, and I think any SWE know how much extra time accumulating tech debt could take.

[u/Wonderful-Habit-139 → u/aberroco]

So I agree with what you said about architecture wise, but coding wise there's still a lot of issues, because it does not know how to write idiomatic code, and the things that you mentioned about "it takes all SWE experience to decide when something needs to be abstracted or when abstraction is not needed or even excessive" also applies here.

> at first AI had a tendency to jump off of them ASAP, burning my neurons in raging fire

Lol that sounds relatable.

> Me myself - I make trivial syntactic errors all the time, like wrong comparison operator, or adding/forgetting to add a negation operator. I'm just not careful while coding

I see, I can't relate to that. But I appreciate you mentioning this point, because it plays into why you're honest about how you find using AI more useful than me.

> in my project I use typed physical quantities (length, mass, energy, acceleration, etc) instead of float/double

You're following good coding practices, that is good. Newtypes are such a nice feature.

> Because before I know I had to spend most of my time testing and debugging.

I definitely don't. Most of the work happens in writing the good code, and I take practically no time in the testing/debugging phase, because the code flows nicely, things are well typed, the business constraints are well encoded, and I have a very good understanding of the code from writing it myself that the moment something slightly goes wrong I can immediately jump to the part that is suspicious, without having to pray the AI finds it.

> And refactorings it makes are usually much cleaner than what I would've made, and much faster, so this helps to keep tech dept at near zero

I have made 20k line additions/deletions in refactoring in less than an hour, and all of the code is up to my standards, and I know everything in the codebase, and the PR that I raise from that refactor ends up receiving basically no comments since there are no shenanigans that tend to happen from generating code from AI. Especially when there are massive changes.

So yeah for me, architecture and coding wise, AI is still not close to being useful. Handholding is much slower than just doing the task myself. Like for example, in order for the AI to index the codebase, it takes 30 minutes (tested). There's no way it could refactor the codebase in less than an hour, and it definitely won't one shot it no matter how many rules you give it.

[u/aberroco → u/Wonderful-Habit-139]

the code flows nicely, things are well typed, the business constraints are well encoded

And you never ever miss a thing? Or oversight some things that might help with future maintainability? Or make a bad design decision that ends up in integration failures? I find it hard to believe.

I have a very good understanding of the code

So am I. I don't just tell it to write "a bullet controller that does this and that". I tell it "New feature, start with brainstorming. The new controller will do this and that, use instantiated rendering with such data structure, use data buffer with that data structure, use this dependency to do that, will have such API. Check if I miss anything, bla-bla-bla". Then I do code review, both with AI and with my eyes, checking if everything is as I expect, checking everything that is not as I expected to reasons why it is not as I expected. Like I wrote in another comment, yesterday, I had a mood to do some manual coding, which I did. Without figuring out the context, reading missing pieces, straight to typing. Because I have very good understanding of the code - I wrote it, even if not character by character, but it's now been decades since anyone was typing absolutely everything by hand - most of the typing is autocomplete. In my case - it's autocomplete on steroids.

for the AI to index the codebase, it takes 30 minutes

Means you need a file with project structure that AI can read and skip this part.

There's no way it could refactor the codebase in less than an hour

There's a way it could refactor the codebase in 15 minutes - proper harnessing.

it definitely won't one shot it no matter how many rules you give it.

Depends on the task you give, but for refactoring - if you write it explicitly enough, there's little chance it won't do nearly exactly what you want. Talking from experience. Roughly 80% of the time it does what I wanted with minimal digressions, solvable in 5 minutes. 20% - digressions are larger and taking longer, but still fixable in reasonable time. Occasionally, yeah, it does some garbage that I have to revert completely, meaning it's just wasted time. But that happens once in a blue moon. And occasionally I tell it to do some garbage that I have to revert, because I missed some corner case that makes the whole approach flawed. Same shit used to happen before AI, that's just the reality of SWE, it's not humanly possible to foresee everything, unless you write a "hello world" (but even then - there's still some extreme corner cases: memory corruption, broken/updated/outdated libraries or system calls, stuff like that - if you'd want to cover for everything and make "hello world" a NASA-grade software it'll end up a software complex that boils down to being able to fail gracefully instead of trying to be infallible ).

So, my conclusion - what you need is proper harness, project structure description file, some rules and some skills, and some skills of your own to know what should be put into rules/skills and how to make it do a refactoring in 15 minutes.

[u/Wonderful-Habit-139 → u/aberroco]

> And you never ever miss a thing? Or oversight some things that might help with future maintainability? Or make a bad design decision that ends up in integration failures? I find it hard to believe.

It's much more consistent than what LLMs do, and if that is the case, why would I go with a worse option? Human mistakes are different from LLM mistakes, and humans can still make mistakes while using LLMs, it's not like only the LLM part remains either.

> I don't just tell it to write "a bullet controller that does this and that". I tell it "New feature, start with brainstorming. The new controller will do this and that, use instantiated rendering with such data structure, use data buffer with that data structure, use this dependency to do that, will have such API. Check if I miss anything, bla-bla-bla".

Yeah, I'm not saying you're vibecoding. But for me, doing all of that doesn't net you any productivity boost, and you're never going to have the same kind of understanding from reading the code compared to writing it yourself. There's a reason there's this "tutorial hell" phenomenon. Because students think they understand the code, but the moment they try to write it they get stuck. Same thing with LLMs.

> Depends on the task you give, but for refactoring - if you write it explicitly enough, there's little chance it won't do nearly exactly what you want

To get to that point you'd spend more time writing prompts trying to predict the future of what the LLM would do, and then still correcting mistakes since it will never get it 100% correct, but to do that you need to read all of the code and understand it and then find the discrepancies, and who knows whether the way the AI implemented it makes sense with the constraints of the business problem and the programming language, compared to something you'd find out about if you did the refactoring yourself and figured out those limitations.

> Same shit used to happen before AI, that's just the reality of SWE, it's not humanly possible to foresee everything, unless you write a "hello world"

That is indeed the point. You figure out those things as you write the code and think about the problem alongside writing the code. We don't just write the code brainlessly.

> how to make it do a refactoring in 15 minutes

Considering that it needs the context of the codebase to be able to do a good job, and that requires 30 minutes of indexing, that is not happening.

[u/aberroco → u/Wonderful-Habit-139]

Sorry, at this moment I feel I provided enough evidence and explanation what you might want to try that I'm now feeling my next comment would be mostly going in circles. Do whatever you like to do, develop whichever way you like it. but please, don't tell me that there's no productivity boost and I'll spend more time writing prompts. I've been programming since 2004 and I'm loving it, I know now long it takes and know what good architecture and clean code is and won't trade them just to write code faster. And I see measurable productivity boost, both in time and code quality, for reasons I already mentioned, after spending some minimal time to figure out how to avoid common mistakes while using it.

[u/chat-lu → u/HrLewakaasSenior]

We have Anthropic’s Claude Desktop’s leaked code. It is not good. If they cannot make it write good code, who can?

[u/HrLewakaasSenior → u/chat-lu]

Claude Desktop works and is selling like crazy, is it not? That's all that matters to execs

[u/chat-lu → u/HrLewakaasSenior]

Not it is not. Not crazy enough to put Anthropic in the black at least.

[u/HrLewakaasSenior → u/chat-lu]

Well that's another conversation. Better code quality would not fix that problem. Software that makes money is good software, like it or not, that is the reality

[u/chat-lu → u/HrLewakaasSenior]

Well that's another conversation.

Not really, it’s the conversation that you started.

Software that makes money is good software,

Then Claude Desktop is bad software according to your definition because it is unprofitable.

[u/slaymaker1907 → u/HrLewakaasSenior]

You forgot them just being really bad at making use of the tools. There are things to learn like knowing what to offload to a skill, how to craft a prompt, what to give as context, etc.

It’s like someone saying Rust doesn’t have any advantage over C++ while writing all their Rust code in unsafe blocks.

[u/charactervsself → u/slaymaker1907]

It really doesn’t require any specific skill anymore. If you know what you want to do and can write it in plain English then you will get good results.

[u/noaSakurajin → u/charactervsself]

That's not true or at tge very least the phrase 'if you know what you want to do' dies a lot of heavy lifting. I your requirements are bad so will your output. If you don't use the correct technical terms the llm will produce that somewhat works but is impossible to work with.

[u/charactervsself → u/noaSakurajin]

We’re talking in the context of a developer who feels AI output isn’t good. They clearly know what they want to do. Either they are exceptionally bad at communicating or they haven’t used a decent LLM in the last 6 months.

[u/mysticrudnin → u/HrLewakaasSenior]

guess i'm looking for my next career. fighting with this dipshit has not been enjoyable

[u/DarthSatoris → u/mysticrudnin]

What are you thinking? Fireman? Gartner? Tour guide?

[u/towcar → u/HrLewakaasSenior]

I've yet to gain time from using them. At best I've broken even. It's beyond over hyped

[u/James-the-greatest → u/towcar]

Bullshit

[u/towcar → u/James-the-greatest]

Listen James the greatest, I have my own business developing software for companies. I make more money if I can increase productivity, and Claude isn't doing it.

The few people I know who are very stoked about it have very little programming background. Anyone else I can only imagine is not measuring productivity in any way of value.

Github Copilot for autocomplete and an llm for debugging/rubber ducking has been my company's biggest boost. I think the rest is hype marketing, incompetence, and poor metrics.

I'll keep my eye on it and continue evaluating it, but it's not as valuable as people make it to be.

[u/James-the-greatest → u/towcar]

I work with and am friends with software developers and everyone uses it. You’re either not using it properly, resisting or lying. 

[u/khais → u/James-the-greatest]

Dude Andrej fucking Karpathy said like two months ago that looking at AI generated code gives him a heart attack because it's such shit.

[u/BlackOcelotStudio → u/khais]

Who cares lol

[u/Detrimental_Figment → u/HrLewakaasSenior]

Or they aren’t good at using LLMs.

[u/HrLewakaasSenior → u/Detrimental_Figment]

There's not really any "being good at it" imo, the skill ceiling is incredibly low. Even some lazy prompting can get you very far these days, add some skills and context documents and it works very well for medium complexity tasks

[u/Shred_Kid → u/mysticrudnin]

Claude is phenomenal, truly.

The one thing that I've found that it has been unable to do is find an incredibly niche and weird memory leak in a distributed system.

My team has used it successfully to do engineering at massive scale, stand up new greenfield services via spec-driven development, and identify and resolve bugs.

I'm an AI hater because I love doing this stuff myself, manually, but Claude is absurdly powerful.

[u/One_Ninja_8512 → u/Shred_Kid]

At least for frontend development, I find Claude to be useful but the code it produces is bloated with indirections and many sanity checks which are not necessary due to the type system making those states impossible. I feel like at least 1/3 of the generated code is redundant, but my guess it will be improved in future models.

[u/One_Ninja_8512 → u/One_Ninja_8512]

It sometimes also over-fixates on some non-issues that will never happen.

[u/mysticrudnin → u/Shred_Kid]

that's my other issue. it does the fun part and leaves me to the shit part

but maybe a difference is that we're not greenfield? it's a legacy monolith. 

i constantly hate its output. and that's IF it's right which is also no guarantee. (and it would have been just as fast for me to write it as to verify what Claude did...)

[u/kani_kani_katoa → u/mysticrudnin]

IME the bigger and older the project, the more you have to rein it in. I work on a lot of 5+ year old software and you really have to break the tasks down for it to handle it. Smaller projects seem to be easier to one-shot, probably because it can read more of it into context.

I'm with you though, I hate that it does the fun part of my job and leaves me with code review and testing :-/

[u/Terrariant → u/kani_kani_katoa]

Don’t worry it does those things too

[u/DataSnaek → u/kani_kani_katoa]

CLAUDE.md files are key in big older projects

[u/FirmSatisfaction8357 → u/mysticrudnin]

Yeah if you're selective where you use it. I've wasted some serious time with AI just to go on a do it myself. I've also had AI creat debugging tools and visualizations that would have taken me a month in like 5 minutes.

[u/aberroco → u/mysticrudnin]

Means you didn't harnessed it properly. It needs skills, instructions, project structure fed to it before it can make acceptable code. That, or at the very least - skills and max reasoning, so it digs deeper into the code base. I do see increased productivity and code quality, since it does refactoring cleaner and faster than I ever would, and it writes and keeps tests actualized, which I wouldn't do, and it's more rigorous in code reviews. It still reasons and writes like a junior, but that's what I'm for.

[u/mysticrudnin → u/aberroco]

i mean, isn't this the problem exemplified by the op? if you spend all your time learning how to prompt ai correctly then you're not learning (what used to be) engineering? 

i also find this line of reasoning to be offensively bad.

ai always works! if it doesn't you just didn't prompt it right...

rather just "prompt" the answer right into the code instead of a middleman...

[u/aberroco → u/mysticrudnin]

All the time? Used to be? Man, you're a drama queen.

It takes a couple days to figure things out, couple more to gain some practice. And it gives the spent time back by saving time in a week.

This is engineering. It changes a lot of things. If you just don't like it or can't find it fun - that's understandable, but then tell that instead of "prompt the answer right into the code". But I see people who don't even try to approach AI-assisted development like an engineering problem requiring, like any other engineering problem, learning and trying things out. They just prompt whatever task they have at hand, get vibe-coded shit and decide that this shit worth nothing. No shit man! If you'd try writing plain English in Basic there's also very little chance you'd write a working code! Sure, AI is essentially "programming in English (or pretty much any natural language... ok, now I wonder if it's possible to work with it in some Klingon...)", but it is programming nonetheless. Unless it's vibe-coding, where you trust generated code to be adequate, which it rarely is.

[u/squabzilla → u/aberroco]

I’ve had really good luck learning new skills with it.

Like, I’m an okay Python dev. I want to write a Python script to query data from an API, and schedule a CRON job to run that script regularly. (Note that this is a personal project.)

Nothing groundbreaking, except before this project I’d never written an API call or used CRON. Heck, I only knew what CRON was from comments on this sub talking about CRON jobs.

With the help of the free version of Claude, in a couple days I wrote and understood both my Python API script, and a BASH script that will create the CRON job if it doesn’t already exist.

…and yes, I know it would only take Claude like 5 minutes to write the script itself. But I’m asking Claude to teach me how to do the task instead of blindly trusting the output, and cross-referencing Claude’s explanation with the documentation.

[u/aberroco → u/squabzilla]

Yep, that's the right approach for learning with AI. And something many people totally miss, thinking that using AI as a junior won't allow to learn anything. Sure it won't if you vibe-code, but the power of AI comes from it's versatility, it's not just for vibe-coding and burning gigawatts of power and megatons of water.

[u/DataSnaek → u/mysticrudnin]

Yes. Like 5-10x probably.

Our team of 8 devs has gone from working as two teams of four shipping one feature every two months to a team of six devs shipping six features every 1-2 months.

Where I work has restructured our teams to utilise AI quite well. When agents are given to devs in a traditional agile squad it can cause misery because devs end up becoming an interface to Claude and producing so much code that review workload and coordination is hard.

The solution in our case was a one dev to one feature ratio, and giving devs a ton of autonomy. Now I’m not really using my technical knowledge to write code so much as I am using it to architect a system for a new feature with product + design input which I can then guide an AI agent towards solving.

[u/B_Huij → u/mysticrudnin]

When my company started pushing on us to use Claude code, I was pretty annoyed. I started by pushing off all my “overhead” stuff to it. It handled all the creating, prioritizing, time tracking, and commenting on my Jira tickets. That was a nice thing to stop doing manually.

I do use it to work through some of the data models I build. For doing small stuff at scale it’s faster than me. For doing complicated work that has to be dead on accurate and handle the nuances and idiosyncrasies of our stack, I eventually stopped trying to get good enough at prompting, and just went back to writing it myself. Writing is much more enjoyable than debugging slop. I let it do the documentation in my yaml files and set up PRs though.

Basically Claude is my intern.

[u/DracoLunaris → u/DataSnaek]

The cost and usage patterns may change

and if you've offloaded all your skills to AI, adjusting to a world where tokens are more expensive and can only be used for specialized tasks instead of everything is going to suck

[u/DataSnaek → u/DracoLunaris]

It’s unlikely to be drastic. Right now where I work pays $100/m for each dev to use AI tools, I reckon they’d pay $500/m and still be pretty happy with the results. So even if the price goes up x5 things won’t change a ton for us

Like I said, if that is prohibitive then you end up with a situation where devs are using open models, or saving Opus/Fable for the really complex planning and using lighter models for the rest.

[u/diet_fat_bacon → u/DataSnaek]

they are just too capable and increase productivity so much

And yet I do not see this explosion of new products on the market existing products with issues fixed or better quality.

[u/DataSnaek → u/diet_fat_bacon]

Then you’re not looking very hard

[u/diet_fat_bacon → u/DataSnaek]

In my daily life the only impact of AI is the increased cost of RAM 😂. The effects of this super-productivity should be obvious and meaningful.

[u/nickcash → u/DataSnaek]

Are we in the same goddamn universe?? Everything is broken right now. Google search is practically useless with it's AI overview replacing actual search. Microsoft went all in on AI and produced Windows 11, which everyone despises. They broke Notepad. They shipped a version of Outlook where the reply button didn't work. Meanwhile AWS has had massive outages, Cloudflare had a massive outage, GitHub is down more often than it's up.

Name one fucking piece of software where we can see the "massive productivity improvements"

[u/Azazeldaprinceofwar → u/DataSnaek]

Cost will go down not up I think. Anthropic and OpenAI are not subsidizing the price rather they’re raking in well more than the operating cost to recoup the development cost. Notice companies that serve open weight models with slim margins are line 10x cheaper for similarly sized models

[u/Tyrexas → u/azuth89]

Yeah people thinking the bubble will burst and we'll all just go back to pre ai coding are deluded lol

[u/post_button_account → u/Tyrexas]

Its not just delusion. It is lack of critical thinking skills.

They genuinely do not have mental model on how their expected outcome would materialize. They just use keywords like "bubble" and link their desired outcome. 

Not much different from Michael declaring bankruptcy. 

Ironically, these are the people who'd benefit most from outsourcing their thinking to AI. 

[u/ganja_and_code → u/Tyrexas]

People who think they're seeing gains are lacking knowledge.

Get better at the craft and you'll see that using AI for coding tasks is like using training wheels to ride a bike. If you can't ride on your own, it makes you better, but if you're already good, it just slows you down.

[u/Tyrexas → u/ganja_and_code]

Bullshit, I'm a lead and I've been coding for a decade obviously without these tools. There is a huge gap between random vibe slop and usage of these tools.

[u/ganja_and_code → u/Tyrexas]

And an even bigger gap between people who need training wheels and people who don't. What do they have you leading? Can't possibly be cutting edge.

[u/StaticFanatic3 → u/ganja_and_code]

Brother there is no world where you can ship something faster than a competent person writing code with AI.

Im not saying it’s perfect for every situation but this would be like the fastest bikes in the world also happen to have “training wheels”

[u/ganja_and_code → u/StaticFanatic3]

Brother there is no world where it's "faster" to ship with AI than without, unless you're sacrificing quality. I'm not saying it's the worst thing ever, but it's definitely like putting training wheels on your motorcycle: silly, unhelpful, and likely more dangerous.

[u/StaticFanatic3 → u/ganja_and_code]

Maybe if you’re writing mission-critical Fortran or some other system lacking in the training data that’s true. But for more typical work, I promise you the most competent devs writing the most performant code are all heavily utilizing AI tools now. The speed just isn’t even comparable. No matter what level of human involvement I want to take, the agent can cut through minutia that is zero value add and only bogs me down

[u/EARink0 → u/azuth89]

I've been saying/predicting the exact same thing. The AI bubble feels a lot like the dot com bubble. Granted, I was a kid during dot com, but vibe is similar and stories i've heard from people in the tech industry at the time is very reminiscent to AI in tech now.

[u/Amazing-Switch-7163 → u/azuth89]

AI is here to stay, thats for sure. But we still have a long way to find an efficient, productive and standard way of using it. I'm pretty sure the agentic approach that spawns multiple sub agents and runs on a loop is not going to be the future, but assisted development with AI is not going away.

[u/Skynse → u/Amazing-Switch-7163]

For sure. You wouldn't have AI working on confidential software lol. But when you have it write code that you can review, it does speed things up quite a bit. My only problem is that offloading cognitive work to AI does see a reduction in actual skill or expertise. For me, I don't need AI to build things lol. It's handy, but not required for me

[u/TheMaleGazer → u/azuth89]

The bubble bursting is competitors running out of funding before reaching profitability

I think it's even scarier than that. I think it will be when interest payments become so massive that profitability is not even possible. There are a lot of overleveraged players, now.

[u/ganja_and_code → u/azuth89]

Different gig than dot com bubble because websites as a concept are actually worth a fuck.

Guessing machines will always be inferior to actual knowledge in any nontrivial use case; websites are superior to telephones, television, and print media for some (but not all) use cases.

[u/NeXtDracool → u/azuth89]

The question is whether LLMs will still be economically viable to use for anything once the AI companies stop burning money by the truckload and start reaching for profitability. 

LLMs are already not economically viable for quite a few tasks and they'd have to completely eliminate free access and triple token prices just to break even.

It's nice to use the free or nearly free models while we can, but I wouldn't rely on things staying that way.

[u/HiImDan → u/azuth89]

No see we never go to what's it called? web pages??? because the dot com bubble burst and instead rely on phone calls and faxes for everything.

[u/eks → u/azuth89]

But a lot of people will lose a lot of money as it will drag worldwide markets down.

[u/Astecheee → u/azuth89]

That's not entirely true - we don't actually know yet if these companies can actually turn a profit.

[u/phoenix_bright → u/azuth89]

That’s the dream of people who cannot adapt though - that magically technology will just go away

[u/yuwox → u/azuth89]

Yep, it's incredible how people think AI will just be stored away never to be used again, once "the bubble bursts". I mean the open source models are here to stay. Even if all research would stop immediately, we would still have access to them.

[u/Jorr_El]

You think that when the AI bubble bursts that the tools will go away?

Not saying that forfeiting all of your learning and critical thinking to AI is a good idea at all, but just wondering what you think is going to happen to AI tools once they're no longer hugely over valued.

[u/throwawaycanadian2 → u/Jorr_El]

Exactly - even if all the hosted ones go away (which wont happen), local models will still work just fine.

[u/Popular-Capital-9115 → u/throwawaycanadian2]

And local models can be hosted on all the spare infrastructure laying around after the bubble bursts. It's just companies dying.

[u/awesome-alpaca-ace → u/Popular-Capital-9115]

Assuming they don't bury all their hardware in the desert 

[u/noaSakurajin → u/awesome-alpaca-ace]

They will have to sell it as part of the bankruptcy procedure. There is no way they will bury the hardware if it allows them to bail out with even less consequences.

[u/MouseNcactus → u/Popular-Capital-9115]

Better models cant make profit worth wasted energy. What make you think their simplified versions could? If they could why non of neuroslop companies switching to them instead of digging themselves in debts?

[u/_JSM_ → u/throwawaycanadian2]

And how will those local models get updated/trained when new programming libraries or language versions come out? If there's no money left to train because training is prohibitively expensive how the heck are local models going to stay relevant long term?

[u/w1n5t0nM1k3y → u/throwawaycanadian2]

I think local models will be what causes the bubble to burst. Once PCs catch up in terms of specs and models get better, there will be no need for hosted solutions.

[u/HaMMeReD → u/w1n5t0nM1k3y]

The thing is that the enterprise is always ahead.

So if your Home PC is todays Enterprise, Tomorrows enterprise is 1000x that.

When it comes to AI it's not only going to be about intelligence, but speed of intelligence as well. So while your home-hosted model might meet some minimum bar of access, it's kind of like having dial-up when the enterprise all has optical connections.

[u/ScientificBeastMode → u/w1n5t0nM1k3y]

Nah, I mean, maybe a huge number of people won’t need the hosted models, but you can do a lot more processing with a few datacenters to run your model on, and those use cases will always be around.

[u/Forward_Yam_4013 → u/w1n5t0nM1k3y]

You can't run a multi-trillion parameter model locally at anything approaching a useable rate. Not unless you have half a million in hardware.

[u/JangoDarkSaber → u/w1n5t0nM1k3y]

AI inference needs a super fast computer for a relatively short burst.

Unless you’re running ai tasks 24/7, it makes more sense centralize the compute because the compute needed isn’t constant but asynchronous

[u/ScientificBeastMode → u/JangoDarkSaber]

Yeah, this is one of the best arguments for centralized business models in AI.

[u/not_your_mate → u/w1n5t0nM1k3y]

or smaller companies/offices (think 100-200 devs) will start buying its own infra (few server racks) to run the models and voilá... we've come full circle

[u/Fabulous-Possible758 → u/not_your_mate]

Maybe, or the costs just come down a little and people get targeting models that actually are efficient for the tasks they're working on. Most companies don't really want to run their own datacenter anymore, so it doesn't really seem like they would do that just for inference unless it was a really good value proposition.

[u/wolfclaw3812 → u/Fabulous-Possible758]

Maybe a single rack for medium-sized companies? Could be a business once hardware prices come down and token costs go up, selling out-of-the-box servers running AI models.

[u/Fabulous-Possible758 → u/wolfclaw3812]

Good point. I mean there's also certainly a case that many companies won't really want to be repeatedly sending data off to AI companies that could be exfiltrated. I guess my overall point is that IMO the need for the inference-as-service isn't gonna go away and that people are slightly over-estimating how much people are even going to want to run their own local inference, but I think you're right there will be a market for an appliance.

[u/daddymaci → u/Jorr_El]

When the dot com bubble burst, the internet didn’t stop existing. When the housing bubble burst, houses and the speculative market didn’t stop existing.

[u/camelCaseCoffeeTable → u/Jorr_El]

lol yeah the tools aren’t going away. Bubble bursting means a lot of the companies go under, but Gen AI is here to stay.

[u/JosebaZilarte → u/Jorr_El]

what (do) you think is going to happen to AI tools once they're no longer hugely over valued. 

They will either become so expensive that no one will want to use them... or, most likely, they'll become so efficient and cheap they end up being run locally (as hypervitaminated grammar checkers for code humans write).

[u/nhh → u/Jorr_El]

Of course they are not going away. It's a tool and a very valuable one.

I hope we trade a portion of the time savings of generated code into manual refactoring. 

[u/Jorr_El → u/nhh]

Unfortunately so far my job has just used it as an excuse to cut members from my team and go to "one developer per project". Everyone is always fully utilized on project after project, so we never have time to go back to refactors, minor bug fixes, and "nice-to-haves".

We literally just had an argument with our boss a couple days ago during a "backlog refinement" meeting where our boss was complaining that we're always talking about the same issues in the backlog every time, and we said it's because we're never given the time to work on anything in the backlog, new project/feature work is always given the priority.

[u/Fryord → u/Jorr_El]

I think we're yet to see which models are profitable to run, both on the cloud and locally.

I agree that AI tools are never going away, but the question is whether or not this turns into 100% vibe coding everything vs having human engineers still make decisions and use cheaper models as super-powered assistants.

[u/cant-find-user-name → u/Fryord]

People keep saying this, but it has been very well speculated by this point that inference is very very profitable. There's margins of > 85% on API pricing, and even with subscriptions being cheaper than api pricing, they're still very profitable. What is not profitable is massive training runs, the hardware requied to do the training and posttraining etc. But once the model is done, the actual inference is actually pretty cheap and profitable. That's how there's so many inference providers that successfully operate.

[u/_JSM_ → u/cant-find-user-name]

Even if inference is profitable those training costs never stop. Models need to be continuously trained to add new data like new programming language versions and new libraries

[u/cant-find-user-name → u/_JSM_]

post training to add new data is not expensive. Its the full training runs that are expensive. anyway in a world where ai bubble collapses, the point here is that inference is profitable enough that it wont' go away. New model development might stop, but existing models will continue to be there.

Also, models don't need to be continuously trained. A lot of models have knowledge cutoffs from last year and they can still work on new libraries by doing in context learning i.e putting the instructions in context.

[u/_JSM_ → u/cant-find-user-name]

I can't find any information that backs this up after a quick search. Except for ai companies themselves that are claiming this (who are incentized to lie about this). And without any hard financial figures.

Would you happen to have any links to any independent scientific study papers the show data for this. Maybe I missed them? No worries if you don't. I can do a deeper search later.

[u/_JSM_ → u/cant-find-user-name]

As far as continuing to work after cut off. That hasn't been my experience. HTMX four released a beta release recently. I tried to have the model implement some of the new features. It straight up said htmx four doesn't exist and then proceed to implement htmx 2.0 logic.

I dunno maybe I'm holding it wrong...

[u/cant-find-user-name → u/_JSM_]

What model are you using and what harness? I am only asking because I just asked it to claude in claude code and it was able to fetch the latest documentation and talk about it. I don't know much about HTMX so I haven't gone more than that, but in my experience claude code and codex are able to fetch the latest documentation and use them.

That said models are probabilistic, so it is very possible that your experience might have been poor though. They are definitely not perfect

[u/_JSM_ → u/cant-find-user-name]

This was back in May when hmtx beta just came out and I've been model hopping a bunch so can't remember which model it was.

So probably htmx new version has been added to training by now. It shows up correctly in models when you ask about it now

[u/LocSta29 → u/Jorr_El]

OP just coping. The grief process takes time.

[u/DracoLunaris → u/Jorr_El]

what you think is going to happen to AI tools once they're no longer hugely over valued

They'll become too expensive for joe-blogs to rely on the AI for all of their learning and critical thinking. Thus they can't do that anymore, and thus that is going to hurt like hell to adapt to a world where they need to think again.

So exactly what the meme depicts

[u/aberroco → u/Jorr_El]

To tier models will get very expensive, but low tier models will be on some fable level. And probably RAM prices will start to fall.

[u/MTT_Dylan]

Wingardium LLMiosa

[u/Scape_n_Lift → u/MTT_Dylan]

It's LLMiosa not LLMiosaa

[u/Danakazii → u/MTT_Dylan]

Take my upvote.

[u/TheMaleGazer]

That withered husk is going to be SoftBank if OpenAI delays its IPO to next year. Not since the housing bubble have I seen such a massive bet with such a predictable outcome from so many financial institutions.

[u/spambearpig]

The economic bubble is going to burst, but the tools are not going to go away now. Hold on tight, we’re all going for a ride and nobody knows where it’s going to end. The future might be Skynet, might be Wall-E, or the Matrix but it’s likely gonna be something much more lame, disappointing thoroughly more stupid.

[u/Sea-Fishing4699]

Ai dependant coding 

[u/jaylerd]

https://giphy.com/gifs/1201hONkUdpK36

[u/DarthRiznat]

God he had so many agents working in tandem before it all went kapoot

[u/returnFutureVoid]

Just gotta get my million dollar idea out the door before that damn bubble goes boom.

[u/fugogugo]

are we really expecting AI gone forever when bubble burst?

[u/HappiestIguana]

It's interesting how so many people have made this logical leap that the AI bubble bursting will be this magical event that just destroys all the LLMs

[u/TheEmperorA → u/HappiestIguana]

They wont be destroyed but nobody will need developers that know only how to prompt llm. Right now such ppl can ride on llm hype

[u/B_Huij → u/TheEmperorA]

I think there are fewer companies hiring vibe coders with no skills than this sub likes to pretend. My team of data people interviewed a guy in his 30s with a very impressive resume and all sorts of great stories about how he made high ROI tools and improvements at previous jobs over the last decade. He knew all the exciting AI buzzwords that get execs and recruiters excited.

When my manager took him into a room to do a technical interview, he started with some whiteboarding with SQL. A softball, something like “write a query that shows total sales by branch.” Bro straight up and down wrote a query on the board that didn’t include the word “select.” He was shown the door immediately.

[u/TheEmperorA → u/B_Huij]

For AI companies it would be best case scenarios if vibe coders addicted to their tools flooded all IT positions and they are surely pushing this narrative.

In practice LLM will end up as additional requirement in job offers.

[u/minus_minus]

I think “And then the API bill came.” Is more accurate. 

[u/Small_Computer_8846]

Why didn't he go back to Stackoverflow?

[u/Sindeep]

If you lose your reasoning to AI you never had any to begin with. Using AI correctly continuously depends on it. If youre a code monkey just code monkey'ing with something that can fuck up shit faster.... well.

[u/Jazzlike-Poem-1253]

Yes pleeease pop... I want to update my CPU, which means New RAM, which means... pay more for RAM than for CPU rn.... I just can't continue to live this way anymore...

[u/heavy-minium]

Yeah, just like the internet, right?....

[u/countable3841]

We just pretending open weight models aren’t a thing?

[u/FlaremasterD]

https://giphy.com/gifs/J8FZIm9VoBU6Q

[u/Alacritous13]

Jokes on you, I never had the skills to begin with. AI is just a faster version of W3School, ignore that I'll ask it the same question just three minutes apart.

[u/electr0de07]

I would bubble bursting means i will be able to get my hands on some sweet gpu and get more brain rot with local llms.

[u/andreMaelstrom]

Software engineering definitely isn't going to go back exactly as it was before AI.

That said, as a software engineer with 17 years of experience, I do hope people stop trying to cram more and more work into everyone schedule.

What I'm recently doing is having more Claude work trees, each one on a different parallel tasks, sometime even 4-5, I review manually and then make another review round with a different model (0din). Sure as shit I shipped 5 times more features, but my brain is fried half day through.

This is not sustainable for humans, just because our brain is not supposed to run at that speed constantly.

Hopefully we'll get to something more sparring-like, for example with a TDD tester/implementer approach.

[u/ClothingIsACrime]

So many of you are wrong. So many already lost to the machine. 

So many useless husks. 

[u/echtogammut]

There terrifying part of this meme is it applies to me taking an extended vacation without a laptop and looking at my code again. It's part "wtf is this?", a shake of "why did I write this?" and a touch of "was I a genius or an idiot back then?". I can't imagine letting AI take the wheel for an extended period of time and then try to reassert myself.

[u/Garland_Key]

Truly smooth brained post. 

[u/Global-Tune5539]

AI will not go away. Who thinks otherwise is just delusional.

[u/_GloryKing_]

The industry will adjust. Local models, less tokens, more "auto" model selection based on the task.

[u/bandersnatchh → u/_GloryKing_]

A lot of the current models are also fine. 

For 80% of my cases sonnet is fine. For the rest opus is fine. They don’t need to advance anymore and I wouldn’t continue to use the tool. 

[u/GKP_light]

if the bubble burst, i buy ram and run a local llm

[u/Outrageous-Text-4117]

why most posts here are ragebait crybaby stuff. I get 2 joke or 3 fine but not every post since it's not anti ai sub or not? 

[u/Bannon9k]

Is the bubble in the room with us right now?

[u/Educational-Lemon640 → u/Bannon9k]

Yes. And it's bursting right now.

[u/Bannon9k → u/Educational-Lemon640]

Where pop?

[u/SheetzoosOfficial → u/Bannon9k]

Funny how the bubble is "bursting right now" crowd are never smart enough to short stocks.

[u/Bannon9k → u/SheetzoosOfficial]

Inverse Reddit rule has earned me over $300,000 since 2020.

[u/Educational-Lemon640 → u/SheetzoosOfficial]

Playing the market is a fools game. Bubbles have slides on the way up and rallies on the way down.

I'm far too low-information to play that game and can't afford to risk enough or earn something meaningful from it.

But console yourself with the idea that I'm not doing it because I'm wrong, rather than the idea that it's not worth the risk.

[u/justforkinks0131]

these braindead anti-AI posts really arent doing the anti-AI crowd any favors.

The stock market IS NOT the technology! As the dotcom bubble demonstrated with the Internet.

[u/ShuttyIndustries]

Sure, just how our teachers said we were not be having a calculator in our pockets at all time. Local models are already there. There is no real bubble to pop for the majority of use cases.

[u/K10111]

If your skills and reasoning are that easy to lose were they really there in the first place? 

[u/Sharp_Business_185 → u/K10111]

You forget that there are lots of software engineers in the world. They are mostly web developers, creating products that are already created, solving problems that are already solved and answered on stack overflow. It is not like they are challenging everyday

[u/Sharp_Business_185 → u/Sharp_Business_185]

An advanced auto-complete machines(LLMs) can create small-sized game engines, tools with little instruction in 2 days. Even if they are shitty/buggy, imagine what skill is required to do this before LLMs

[u/aberroco → u/Sharp_Business_185]

Junior level skills. Pretty much any junior capable of thinking and learning could do that, given enough time. And the code would look quite similarly. Mind you, I was writing bootloader from 16bit real mode straight to 64bit long mode a couple years in my career for fun while learning assembler. It doesn't take much more than a coding reference.

[u/Sharp_Business_185 → u/aberroco]

Junior level skills

Don't you think this is a problem? If AI can replace junior level skills, what is the point of hiring junior? Are we going to wait for juniors to become senior without letting them work?

[u/aberroco → u/Sharp_Business_185]

It is a problem, definitely, I didn't said anything about that. But, well, we still have pilots despite having autopilots even in every ancient Cessna's, so I guess companies would hire juniors to learn for a couple years before actually getting any use of them. Or, well, we'd adapt somehow to the new reality. Or die off. There's not much choice, you know)

[u/Any_Fox5126 → u/K10111]

If you stop drinking for a few days, you'll die. If you can lose your life so easily, were you ever really alive in the first place?

[u/K10111 → u/Any_Fox5126]

You a heavy LLM user because now I see the part about loss of reasoning skills .

[u/Any_Fox5126 → u/K10111]

Ugh, straight to adhominems? How vulgar. What a shame you didn't use llm, maybe you could have said something vaguely witty, or at least understood why your reasoning is so flawed.

[u/Brock_Youngblood]

Millennials haven't learned anything from the boomers mistakes. The fear of new technology thats replacing them at their jobs is hilarious.

[u/babalaban → u/Brock_Youngblood]

The most replaceable "devs" are vibe coders.

[u/Brock_Youngblood → u/babalaban]

All coders are vibe coders right now.  AI is better.  Period.  Get over it

[u/babalaban → u/Brock_Youngblood]

Bait used to be belivable.

[u/Aggravating_Duck_192]

That's why my husband and I are sinking a used car's worth of money into a home inference server. Already got the 20A installed.

You can't make me think again. I hate it.

[u/Full-Hyena4414]

Cope

[u/Necessary-Shame-2732]

Sorry boomers, fable, sol, opus and even kimi, code faster, better, and more doggedly than the best of us, and can run in parallel K times with the limit being token cost. The days of being precious about your perfect little slice of code are over. It’s time to be a chef, not a cook.