Other people see all that as an means to an end - and find no joy from the technical aspect of creating something. They're more interested in the end result / product, rather than the process itself.

I think that if you're in group A, it can be difficult to understand group B. In vice versa.

I'm a musician, so I love everything about creating music. From the theory, to the mastery of the instrument, the tens of thousands of hours I've poured into it...finally being able to play something I never thought I'd be able to, just by sheer willpower and practice. Coming up with melodies that feel something to me, or I can relate to something.

On the other hand, I know people that want to jump straight to the end result. They have some melody or idea in their head, and they just want to generate some song that revolves around that idea.

I don't really look down on those people, even though the snobs might argue that they're not "real musicians". I don't understand them, but that's not really something I have to understand either.

So I think there are a lot of devs these days, that have been honing their skills and love for the craft for years, that don't understand why people just want things to be generated, with no effort.

> Other people see all that as an means to an end

I think it's worth pointing out that most people are both these things at different times.

There's things I care about and want a deep understanding of but there's plenty of tasks I want to just "go away". If I had an junior coder - I'd be delegating these. Instead I use AI when I can.

There's also tasks where I want a jump start. I prefer fixing/improving code over writing from scratch so often a bad AI attempt is still valuable to me.

As a manager, say I do hire a junior developer, invest time into them and they level up. I go to the HR department and tell them that they deserve a 30% raise to bring them inline with the other mid level developers.

The HR department is going to say that’s out of policy and then the developer jumps ship.

The tragedy of the commons in a nutshell. Maybe everyone should invest in junior developers so that everyone has mid-level developers to poach later?

There's no doubt about it, there's selfish reasons to teach, mentor, and have a junior under you. We're social creatures. It should be no surprise that what's good for the group is usually good for yourself too. It's kinda as if we were evolutionarily designed to be this way or something ¯\_(ツ)_/¯

Everyone says they don't have time, but you get a lot of time by doing things right instead of doing things twice. And honestly, we're doing it a lot more than twice.

I just don't understand why we're so ready and willing to toss away a skill that allowed us to become the most successful creature on the planet: forethought. It's not just in coding but we're doing it everywhere. Maybe we're just overloaded but you need forethought to fix that, not progressively going fast for the sake of going fast

I leveled up because I practice mentoring others. But it still doesn’t make sense for the organization to hire juniors. Yes I realize someone has to. It’s especially true for managers who have an open req to fill because they need work done now.

On the other hand, my one, only and hopefully last role in BigTech where I worked previously, they could afford to have an intern program and when they came back after college have a 6 month early career/career transition program to get them up to speed. They could afford the dead weight loss.

  > a devil’s advocate/hypothetical question.

I'm not saying "don't ask questions." We should all be asking questions! If anything, we should be asking more! But we're in a thread that's contextualized about a division of people. It is only natural for people to interpret as a continuation of what came before.

But to address your point more directly, my answer is that the scenario you presented would be a surefire way to kill a company. Yes, there are big companies that do this, but you'll recognize that they're also monopolies or close it. A company with competition (big or small) is unable to pull off such shortsightedness. What you do for the company is the same thing you do for society: invest in the future. Sure, you wanna be lean and cost efficient but that has to be balanced with security. You don't want your company to go under just because an employee got hit by a truck. You don't want your company to go under just because an employee decides to retire. You're not doing a good job if you have these vulnerabilities. These are things only small startups should be doing and only because they have no choice.

This isn't "dead weight" and I think it is really bad to frame things this way. Most of the time my firewall isn't doing anything, is it "dead weight"? I often buy stocks while markets are low or falling, are these "dead weight"? I went to school to get an education, was this "dead weight"? It would be silly to call any of those things "dead weight", yet they're identical. A "dead weight" employee is one who has the ability to do but does not. It is the person who gets promoted by being performative, by being close to the manager, by looking like they are doing work more than they are. There's a lot of dead weight in companies, and they stick around because they look like they're useful. And conversely, some of your best workers often look like your worst[0].

It is literally Goodhart's Law in action and what I'm pissed about is we as a society have identified this issue and decided "it is a feature, not a bug" despite all the evidence to the contrary. We've dropped so many sayings and cliques that were common and were warnings of enshitification. When was the last time you heard someone say "you get what you pay for"? Or "if you're gonna do something, do it right"? We normalized the work environment of a fucking Dilbert Comic. And here we are, in this thread, defending our Dilbert world. We could have a lot of nice things, but the inescapable truth is that nice things require work. Worse, I'm tired of living in an environment where all the little issues I face in daily life that can easily be fixed are causally brushed away because "it doesn't create value" while we dump billions into the next vaporware. It is deadly irony and I cannot stand this double speak. I just want to make things that work... You'll say "I'm not stopping you" but every person that frames things like above creates a system that does prevent me (and many others). While it isn't a zero sum game, we sure have limited resources and we're all too happy to light them on fire when promised some magic beans. I don't understand why no matter how many times we watch it happen we still do not learn.

[0] https://news.ycombinator.com/item?id=43452649

You have processes that outlive people. Companies don’t care about society - they care about their bottom line. They aren’t there to make society as a whole better

If you want a society of well trained software engineers ready to work in corporate America, you support your public education system. Just like if you want a society that has universal healthcare, you put the onus on society and not corporate America.

My job is to do what’s best for the company as long as it is not illegal or unethical. My job is not to make society better. I got one open req. I want to hire the best person my budget allows

  >  You don’t invest in your future ... the average tenure of a software developer is 3 years and at any time an employee can leave.

1) Tragedy of the Commons: If we all act like this, then no one gets invested in. If we all invest in our employees then when they leave another company gets the rewards. That's still true when "we" are the "other company". You still benefit regardless. Under the condition that most companies (or rather at least the big companies) collude in this way. They have good reason to as coalitions maximize utility for all parties involved.

2) Why the fuck are we training people and then tossing them away? We do this in many ways but the most obvious one is hiring a new dev and paying them more than the current devs. Guess what? That new dev needs to be trained and now your old devs are pissed that they aren't getting paid as much. So now you not only waste time and money onboarding someone new, you lose your experience.

  > Companies don’t care about society - they care about their bottom line

  > My job is to do what’s best for the company as long as it is not illegal or unethical

I don't understand why you think we're in disagreement about this. Every single one of my points has come down to this. I've said it explicitly. My very first message stated that there were selfish reasons to do these things. The selfishness and foresight doesn't apply just to yourself.

  >  My job is not to make society better

But it is just a weird argument all together anyways. Your job isn't to make society better? Read that again. Your job isn't to make your life better? Certainly a paycheck makes your life better, right? I really hope it isn't making it worse. But we're social creatures too. Your job isn't to make your family's lives better? Your job isn't to make your friends' lives better? If it isn't to better yourself, your family, and your friends, then what the fuck are we even doing here? You have autonomy. And here's the fun part, if we care about our local groups and improve our local groups, this usually improves broader groups by extension. We're interconnected. I'm not saying you need to care about some dude on the opposite side of the country, but I sure as hope you don't think your job is to do harm. The "not illegal or unethical" part really is concerning. Frankly, I'd call doing harm unethical, even if it is small. It's more unethical to steal someone's wallet than to snatch a penny, but both are still unethical.

So I really don't get where you're trying to go with this. Because frankly, the selfish act improves society. It's just you have to consider that other people exist. If you're selfish and you model a world where you're alone, then yeah, maximize yourself at all costs. But when there are other agents in the world, the way to maximize your utility is through coalitions, through improving the group.

Yes I know it’s insane that a manager can’t get the budget to give raises. But can get one to hire someone new at prevailing market rates.

Given those are the facts, I had to aggressively job hop between 6 jobs between 2008-2020 to get the money I wanted after staying at my second job for nine years getting 3% raises.

Now at 50 on my 10th job, I can optimized for different things.

How are you going to convince HR or the PHB that their policies are insane? As a manager or a team lead, your job is to create processes to make developers interchangeable “resources”.

I recognize that and I kind of agree, but I think I don't entirely. Writing the "boring" boilerplate gives me time to think about the hard stuff while still tinkering with something. I think the effect is similar to sleeping on it or taking a walk, but without interrupting the mental cruncing that's going in my brain during a good flow. I piece together something mundane that is as uninteresting as it is mandatory, but at the same time my subconscious is thinking about the real stuff. It's easier that way because the boilerplate does actually, besides being boring, still connect to the real stuff, ultimately.

So, you're kind of working on the same problem even if you're just letting your fingers keep typing something easy. That generates nice waves of intensity for my work. My experience regarding AI tends to break this sea of subconsciousness: you need to focus on getting the AI to do the right thing which, unlike typing it yourself, is ancillary to the original problem. Maybe it's just a matter of practise and at some point I can keep my mind on the domain in question eventhough I'm working an AI instead of typing boilerplate myself.

IMHO there's no joy in doing the same thing multiple times. DRY doesn't help with that, you end up doing a lot of menial work to adapt or integrate previous code.

Most of the for-profit coding is very boring.

Of course, everything is on a scale so it's not either/or.

But, like you, how I get there matters to me, not just the destination.

Outside the context of music, a project could be super successful but if the journey was littered with unnecessary stress due to preventable reasons, it will still leave a bad taste in my mouth.

I find it very unlikely anyone who only likes the results will ever pick up the craft in the first place

It takes a very specific sort of person to push through learning a craft they dislike (or don't care about) just because they want a result badly enough

Seems to me that "the result" is "the money" and not "the product".

Because I'd argue those that care about the product, the thing being built, the tool, take a lot of pride in their work. They don't cut corners. They'll slog through the tough stuff to get things done.

These things align much more with the "loves coding" group than "the result". Frankly, everyone cares about "the result" and I think we should be clear about what is actually meant

Nope, your code might look excellent. Why the hell isn't it running though? Three hours later you find you added a b when you closed your editor somewhere in the code in a way your linter didn't pick up and the traceback isn't clear about, maybe you broke some all important regex, it doesn't matter. One second, it's fixed, and you just want to throw the laptop out the window and never work on this project again. So god damned stupid.

And other things are frusterating too. Open a space deliminated python file, god forbid you add a tab without thinking. And what is crazy about that is if the linter is smart enough to say "hey you put a tab here instead of spaces for indent" then why does it even throw the error and not just accept both spaces and tabs? Just another frustration.

Really I would love to just go at it, write code, type, fly, be in the flow state, like one does building something with the hands or making music or doing anything in the physical world. But no. Constant whack a mole. Constantly hitting the brakes. Constant blockers. How long will this take to implement? I have no fucking idea man, could be 5 seconds or 5 weeks and you don't often know until you spend the 5 seconds and see that didn't do it yet.

Programming is similar to music. (A great many software innovators in the 70s and 80s had musical roots). But AI prunes away all the creativity and stylistic expression from the composition and the performance when designing and building software, reducing the enterprise to mere specification -- as if the libretto of the opera were merely an outline, and even that was based on Cliff Notes.

The case for using AI to code is driven strictly by economics and speed. Stylistically and creatively, AI is a no-brainer.

I don't really get any joy from the act of coding, but I also take a lot of pride in doing a good job.

Cutting corners and producing sloppy work is anathema to me, even when I don't really enjoy the work itself

Any work worth doing is worth doing a good job on, even if I don't enjoy the work itself

- A singer might learn to play guitar to sing along to it. Guitar is a means to an end; it is simply a tool to them.

- A guitarist learns to play guitar due to love of the instrument.

Some like proving and deriving, for others it's a tool to solve other problems

So if someone generates their music with AI to get their idea to music you don’t look down on it?

Personally I do, if you don’t have the means to get to the end you shouldn’t get to the end and that goes double in a professional setting. If you are just generating for your own enjoyment go off I guess but if you are publishing or working for someone that’ll publish (aka a professional setting) you should be the means to the end, not AI.

If you're talking about a person using an LLM, or some other ML system, to help generate their music then the LLM is really just a tool for that person.

I can't run 80 mph but I can drive a car that fast, its my tool to get the job done. Should I not be allowed to do that professionally if I'm not actually the one achieving that speed or carrying capacity?

Personally my concerns with LLMs are more related to the unintended consequences and all the unknowns in play given that we don't really know how they work and aren't spending much effort solving interoperability. If they only ever end up being a tool, that seems a lot more in line with previous technological advancements.

Right, but if you use a chess engine to win a chess championship or if you use a motor to win a cycling championship, you would be disqualified because getting the job done is not the point of the exercise.

Art is (or should be) about establishing dialogues and connections between humans. To me, auto-generated art it's like choosing between seeing a phone picture of someone's baby and a stock photo picture of a random one - the second one might "get the job done" much better, but if there's no personal connection then what's the point?

If you drive a car 80mph you don't get to claim you are a good runner

Similarly if you use an LLM to generate 10k lines of code, you don't get to claim you are a good programmer

Regardless of the outcome being the "same"

Then you get to the place and they say "now load all of the things in the garage into the truck"

But oops. You didn't bring a truck, because all they told you was "please be at this address at this time", with no mention of needing a truck

My point is that the purpose of commercial programming is not usually just to get to the goal

Often the purpose of commercial programming is to create a foundation that can be extended to meet other goals later, that you may not even be remotely aware of right now

If your foundation is a vibe coded mess that no one understands, you are going to wind up screwed

And yes, part of being a good programmer includes being aware of this

At the same time human ran 'feature' applications like you're talking about often suffer from "let the programmer figure it out" problems where different teams start doing their own things.

What has always held true so far: abstracts challenging parts of a task away. The only people you will outcompete are those, who now add little over .

But: If in the future people are just using to create a product that a lot of people can easily produce with , then, before long, that's not enough to stand out anymore. The floor has risen and the only way to stand out will always be to use in a way that other people don't.

I understand your point, but I think it is ultimately rooted in a romantic view of the world, rather than the practical truth we live in. We all live a life completely inundated with things we have no expertise in, available to us at almost trivial cost. In fact it is so prevalent that just about everyone takes it for granted.

It depends entirely on how they're using it. AI is a tool, and it can be used to help produce some wonderful things.

- I don't look down on a photographer because they use a tool to take a beautiful picture (that would have taken a painter longer to paint)

- I don't look down on someone using digital art tools to blur/blend/manipulate their work in interesting ways

- I don't look down on musicians that feed their output through a board to change the way it sounds

AI (and lots of other tools) can be used to replace the creative process, which is not great. But it can also be used to enhance the creative process, which _is_ great.

Look at popular music for the last 400 years. How is that any different than simply copying the previous generations stuff and putting your own spin on it?

If you heard a CD in 1986 then in 2015 you wrote a song subconsciously inspired by that tune, should I look down on you?

I mean, I'm not a huge fan of electronic music because the vast majority of it sounds the same to me, but I don't argue that they are not "real musicians".

I do think that some genres of music will age better than others, but that's a totally different topic.

My entire management chain - manager, director and CTO - are all technical and my CTO was a senior dev at BigTech less then two years ago. But when I have a conversation with any of them, they mostly care about whether the project I’m working on/leading is done on time/within budget/meets requirements.

As long as those three goals are met, money appears in my account.

One of the most renown producers in hip hop - Dr. Dre - made a career in reusing old melodies. Are (were) his protégés - Easy-E, Tupac, Snoop, Eminem, 50 cent, Kendrick Lamar, etc - not real musicians?

i say this as someone who cut my teeth on this stuff growing up and seeing the evolution, it's both. and at some point it's honestly elitism and gatekeeping. i sort of cringe when it's called a "craft" because it's not like woodworking or something. the process is both full of joy but so is the end result, and the nature of our industry is that the process is ALWAYS changing.

you accumulate a depth of knowledge and watch as it washes away in a few years. that kind of change, and the big kind of change that AI brings scares people so they start clinging to it like it's some kind of centuries old trade lol.

Programming something more sophisticated with AI? AI is pretty much useless if you're doing anything somewhat novel. What it excels at is vomiting code that has already been written a million times so you can build yet another Electron cross-platform app.

Even when I'm stuck in hell, fighting the latest undocumented change in some obscure library or other grey-bearded creation, the LLM, although not always right, is there for me to talk to, when before I'd often have no one. It doesn't judge or sneer at you, or tell you to "RTFM". It's better than any human help, even if its not always right because its at least always more reliable and you don't have to bother some grey beard who probably hates you anyway.

Even more so, I remember making a Chrome extension and feeling intimidated. I knew that I'd be comfortable with most of it given that JS is used but I just didn't know how to start.

With an LLM it is way faster to spin up some default config and get going versus reading a tutorial. What I've noticed in that respect is that I just read what it does and then immediately reason why it's there. "Oh, there's a manifest.json file with permissions and a few other things, fair, makes sense. Oh, so you have the HTML/CSS/JS of the extension, you have the HTML/CSS/JS of the page you're injecting some code into and you have the JS of a background worker. Ah yea, I get that."

And then I just get immediately on coding.

How if it hallucinate and gives you wrong code and explanation? It is better to read documentations and tutorials first.

Then the code won't compile, or more likely your editor/IDE will say that it's invalid code. If you're using something like Cursor in agent mode, if invalid code is generated then it gets detected and the LLM keeps re-running until something is valid.

> It is better to read documentations and tutorials first.

I "trust" LLM's more than tutorials, there's so much garbage out there. For documentation, if the LLM suggests something, you can see the docstrings in your IDE. A lot of the time that's enough. If not, I usually go read the implementation if I _actually_ care about how something works, because you can't always trust documentation either.

As for my editor saying it is invalid..? That is just as untrustworthy as an LLM.

>I "trust" LLM's more than tutorials, there's so much garbage out there.

Yes, rubbish generated by AI. That is the rubbish out there. The stuff written by people is largely good.

I interpreted the "hallucination" part as the AI using functions that don't exist. I don't consider that a problem because it's immediately obvious.

Yes, AI can suggest syntactically valid code that does the wrong thing. If it obviously does the wrong thing, then that's not really an issue either because it should be immediately obvious that it's wrong.

The problem is when it suggests something that is syntactically valid and looks like it works but is ever slightly wrong. But in my experience, it's pretty common to come across that stuff like that in "tutorials" as well.

> Yes, rubbish generated by AI. That is the rubbish out there. The stuff written by people is largely good.

I pretty strongly disagree. As soon as it became popular for developers to have a "brand", the amount of garbage started growing. The stuff written before the late 00's was mostly good, but after that the balance began slowly shifting towards garbage. AI definitely increased the rate at which garbage was generated though.

To be fair, I as a dev with ten or fifteen years experience I do that too. That's why I always have to through test the results of new code before pushing to production. People act as if using AI should remove that step, or alternatively, as if it suddenly got much more burdensome. But honestly it's the part that has changed least for me since adopting an AI in the loop workflow. At least the AIncan help with writing automated tests now which helps a bit.

Emphatic no.

There were heaps of rubbish being generated by people for years before the advent of AI, in the name of SEO and content marketing.

I'm actually amazed at how well LLMs work given what kind of stuff they learned from.

Hallucinations are a thing. With a competent human on the other end of the screen, they are not such an issue. And the benefits you can reap from having LLMs as a sometimes-mistaken advisory tool in your personal toolbox are immense.

[0]: https://knowyourmeme.com/memes/how-to-draw-an-owl

Also something are meant to be approached with the correct foundational knowledge (you can’t do 3D without geometry, trigonometry, and matrixes. And a healthy dose of physics). Almost every time I see people strugling with documentation, it was because they lacked domain knowledge.

1. Code doesn't compile. This case is obvious on what to do.

2. Code does compile.

I don't work in Cursor, I read the code quick, to see the intent. And when done with that decide to copy/paste it and test the output.

You can learn a lot by simply reading the code. For example, when I see in polars a `group_by` function call but I didn't know polars could do that, now I know because I know SQL. Then I need to check the output, if the output corresponds to what I expect a group by function to do, then I'll move on.

There comes a point in time where I need more granularity and more precision. That's the moment where I ditch the AI and start to use things such as documentation and my own mind. This happens one to two hours after bootstrapping a project with AI in a language/library/framework I initially knew nothing about. But now I do, I know a few hours worth of it. That's enough to roughly know where everything is and not be in setup hell and similar things. Moreover, by just reading the code, I get a rough idea on how beginner to intermediate programmers think about the problem space the code is written in as there's always a certain style of writing certain code. This points me into the direction on how to think about it. I see it as a hint, not as the definitive answer. I suspect that experts think differently about it, but given that I'm just a "few hours old" in the particular language/lib/framework, I think knowing all of this is already really amazing.

AI helps with quicker bootstrapping by virtue of reading code. And when it gets actually complicated and/or interesting, then I ditch it :)

That's not a jab, but a serious question. We act like people don't "hallucinate" all the time - modern software engineering devops is all about putting in guardrails to detect such "hallucinations".

I work as a consultant assessing other people's code and it's hard not to lose my religion, sort of speak.

Sadly, I find it sorely lacking at dealing with build systems and that particular type of boilerplate, mostly because it seems to mix up different versions of things too much and gives you totally broken setups more often than not. I’d just as soon never deal with the he’ll that is front end build/lint/test config again.

AI generated tests are a bad idea.

I've been writing Python for 20+ years and I still can't use unittest.mock without looking up the details every time. ChatGPT and Claude are great at that, which means I use it more often because I don't have to deal with the frustration of figuring it out.

I’ve been on projects with multiple languages, but the truly active code was done in only two. The other languages were used in completed modules where we do routine maintenance and rare alterations.

LLMs. I've expanded the circle of languages I use on a frequent basis quite dramatically since I started leaning on LLMs more. I used to be Python, SQL and JavaScript only. These days I'm using jq, AppleScript, Bash, Go, awk, sed, ffmpeg and so many more.

I used to avoid infrequently used DSLs because I couldn't hold them in my memory. Now I'll happily use "the best tool for the job" without worrying about spinning up on all the details first.

Haven't much used AI to assist. After all, hard enough finding authentic humans capable and willing to voluntarily review/critique one's code. So far AI doesn't consistently provide that kind of help. OTOH seems almost certain over time AI systems will improve in terms of specific and comprehensive "insights" into the particular types of code one is writing.

I think an issue is that human creativity is hard to measure. Likely enough AI is even tougher to assess. Probably AI will increasingly be assigned tasks like constructing project skeletons, assuring parts can be joined together without undue strain, handling "boilerplate" and other routine chores. To be sure the landscape will look different in 50 years, I'm certain we'd be amazed were we able to see what future systems will be doing.

In any case, we shouldn't hesitate to use tools that genuinely boost our creativity. One badly needed role would be enabling development of higher reliability software. Still that's a far cry from the contributions emanating from the best of human originality, talent and motivation.

I keep seeing people saying to use an LLM to write boilerplate, but like... do you not just copy that from another project where you already wrote it?

Also, I know that people love to joke on modern software and JS in particular. But if you take react code from 2020 and drop it into a new react codebase it still works. Even class based components work. Yes, if you jumped on the newest framework bandwagon every time stuff will break all the time, but AI won’t be able to help you with that either. If you went for relatively stable frameworks, you can re use boilerplate completely or with relatively minimal adjustments

If you take a project from 2020 it's a bit of a pain to upgrade it.

I ran this prompt (and others like it) and it actually worked!

  This code needs to be upgraded to the new
  recommended JavaScript library from
  Google. Figure out what that is and
  then look up enough documentation to
  port this code to it

If you keep re-using boilerplate once in a while copying it from elsewhere is fine. If you re-use it all the time, just get a macro setup in your editor of choice. IMHO that is way more efficient than asking AI to produce somewhat consistent boilerplate

So yes, boilerplate, but also yes, there is definitely something to be gained from using ai assistants.

Source: Generative Deep Learning by David Foster, 2nd edition, published in 2023. From “Tokenization” on page 134.

“If you use word tokens: …. willnever be able to predict words outside of the training vocabulary.”

"If you use character tokens: The model may generate sequences of characters that form words outside the training vocabulary."

“If you use word tokens: …. willnever be able to predict words outside of the training vocabulary.”

"If you use character tokens: The model may generate sequences of characters that form words outside the training vocabulary."

That’s a lot of trauma you’re dealing with.

Of course, it all depends how you use the LLM. While the same can be true for StackOverflow, the LLMs just scale the issues up.

  > The rest is boiler plate, cargo-culted, Dockerfile, build system and bash environment variable passing circle of hell that I really could care less about.

With expertise in anything, I'm sorry, but you also got to do the shit work. To be a great musician you gotta practice boring scales. It's true even if you just want to be a sub par one.

But a little grumpy is good. It drives you to fix things, and frankly, that's our job. The things that are annoying and creating friction don't need be repeated over and over, they need alternative solutions. The scripts you build are valuable. The "useless" knowledge you gain isn't so useless. Those little details add up without you knowing and make you better.

That undocumented code makes you frustrated and reminds you to document your own. You don't want to be a hypocrite. The author of the thing you're using probably thought the same thing: "No one is gonna use this garbage, I'm not going to waste my time documenting it". Yet here we are. Over and over again yet we don't learn the lesson.

I'm not gonna deny there's assholes. There are. But even assholes teach you. At worst, they teach you how not to act.

And some people are you telling you to RTM and not RTFM. Sure, it has lots of extra information in it that you don't need to get your specific job done, but have you also considered that it has lots of extra information in it? The person that wrote it clearly thought the context was important. Maybe it isn't. In that case, you learned a lesson in how not to write documentation!

What I'm getting at is that there's a lot of learning done all over the place. Trying to take out all the work and only have "the fun" is harming yourself and has a large potential to make less time for the fun stuff[0]. I'd be surprised if I'm alone in this, but a lot of stuff I enjoy now was stuff that originally frustrated me. IME this is pretty common! It's true for every person I know. Similarly, it's also true for things I learned that I thought I'd never use again. It always has a way of coming back.

I'm not going to pretend it's all fun and games. I'm explicitly saying it's not. But I'm confident in the long run it's better. Despite the lack of accuracy, I use LLMs (and Google, and even the TFM) like I would a solution guide the homework problems when I was in school. Try first, then consult. The struggle is an investment in your future. It sucks, but if all the best things in life were easy then we'd all have them. I'm just trying to convince you that it pays off.

I'm completely aware this is all context dependent. There's a time and place for everything. But given the percentages you mention (even taken as exaggeration), something sounds wrong. It's hard to suggest specific solutions without details but I'd be surprised if there weren't better and more rewarding solutions than having the LLM do it for you

[0] That's the big danger and what drives distrust in them. Because you need to work extra hard to find mistakes, increasing workload, not decreasing, because debugging is most of the job!

While it looks like a productivity boost, there's a clear price to pay. The more you use it, the less you learn and the less you are able to assess quality.

I'm sure it's faster in the short term. Just like copy-paste-from-stack-overflow is. But it is debt. The shit builds and builds. But I think the problem is we're so surrounded by shit we've just normalized it. It is incredible how much bloat and low hanging fruit there is that can be cheaply resolved but there is no will to. And in my experience, it isn't just a lack of will, it is a lack of recognition. If the engineers can't recognize shit, then how do we build anything better? It is literally our job to find problems

What helps me is to think of it like I'm a kid again, learning to code full of ideas but without any pre-conceived notions. Rather than the Microsoft QuickBasic manual in my hands, I've got Gemini & Claude Code. I would be gleefully coding up a storm of games, websites, dubious webcrawlers, robots, and lord knows what else. Plenty of flow to be had.

I guess if you code stuff that had been coded a lot in public repos, it is fine, otherwise AI does not help in any way. Actually, I think I wasted more time trying to make it produce the output I wish for than it took me to do this myself.

If you're somewhere in between (where I am now) it's situationally useful for small sub-components but you need to filter it heavily or you'll end up wasting a day or two going down a wrong rabbit-hole either because you don't know the domain well enough to tell when it's bullshitting or going down a wrong path, or don't know the domain well enough to use the right keyword to get it to cough up something useful. I've found domain knowledge essential for deciding when it's doing something obviously wrong instead of saying "I don't know" or "This is the wrong approach to the problem".

For the correct self-contained class or block of code, it is much faster to specify the requirements and go through a round or two of refinement than it is to write it myself. For the wrong block of code it's a complete waste of time. I've experienced both in the last few days.

Obviously LLMs in this situation will still be insanely helpful, but in the same way that Google searches or stack overflow is insanely helpful.

AI assisted development is no different from managing an engineering team. "How can you trust outsourced developers to do anything right? You won't understand the code when it breaks"... "How can you use an IDE, vim is the only correct tool" etc etc etc.

Nothing has changed besides the process. When people started jumping on object orientation they called procedures the devil itself, just as procedures were once called structured programming and came to banish away the considered harmful goto. Everything is considered harmful when theres something new around the corner that promises to either make development more productive or developers more interchangeable. These are institutional requirements and will never go away.

Embrace AIOP (AI oriented programming) to banish copy and paste google driven development which is now considered harmful.

Having LLMs like 2.5 now are total game changers. I can basically flow chart a program and have Gemini manifest it. I can break up the program into modules and keep spinning up new instances when context gets too full.

The program I am currently working on is up to ~5500 LOC, probably across 10ish 2.5 instances. It's basically an inventory and BOM management program that takes in bloated excel BOMs and inventory, and puts it in an SQLite database, and has a nice GUI. Absolutely insane how much faster SQLite is for databases than excel, lol.

One is a automatic electronics test system that runs tests and collects measurements (50k+ readings across 8-12 channels)(GPT-4, now with a GUI and faster DB thanks to 2.5). One is a QC tool to help quickly make QC reports in our companies standard form (3.7). And the last is a GUI CAD tool for rendering and quickly working through ancient manufacturing automation scripts from the 80's/90's to bring them up to compatibility with modern automation tooling (3.7).

I personally think that there is a large gap between what programs are, and how each end user ultimately uses them. The programs are made with a vast scope, but often used narrowly by individuals. The proprietary CAD program that we were going to use originally for the old files was something like $12k/yr for a license. And it is a very powerful software package. But we just needed to do one relatively simple thing. So rather than buy the entire buffet, buy the entire restaurant, Claude was able to just make simple burger.

Would I put my name on these and sell to other companies? No. Am I confident other LLM junkies could generate similar strongly positive outcomes with bespoke narrow scope programs? Absolutely.

And if something's not obvious I can always fetch the specifics of any particular calls. But at least I didn't have to find the name of that call in the first place.

Thanks for the comment. You articulated how I feel about this situation very well.

Honestly, I suspect the people who would prefer to have someone or something else do their coding, are probably the devs who are already outputting the worst code right now.

I don't know if I'm a minority but I'd like to think there are a lot of folks like me out there.

You can compare it to someone who is writing assembly code and now they've been introduced to C. They were happy writing assembly but now they're thrilled they can write things more quickly.

Sure, AI could lead us to write buggier code. Sure, AI could make us dumber because we just have AI write things we don't understand. But neither has to be the case.

With better tools, we'll be able to do more ambitious things.

(The hype merchant, LinkedIn influencer, Twitter thread crowd are super noisy but tend to stick to their own echo chambers, it's rare to have them engage in a forum like Hacker News directly.)

No, there's plenty of top-class engineers who love coding with AI. e.g. Antirez.

I hate the reality of our current AI, which is benefitting corporations over workers, being used for surveillance and censorship (nevermind direct social control via misinformation bots), and is copying the work of millions without compensating them in order to do it.

And the push for coders to use it to increase their output, will likely just end up meaning expectations of more LoC and more features faster, for the same pay.

But FOSS, self-hosted LLMs? Awesome!

How are self-hosted LLMs not copying the work of millions without compensating them for it?

How is the push for more productivity through better technology somehow bad?

I am pro FOSS but can't understand this comment.

Secondly, you are not writing anything you get from an LLM. You prompt it and it spits out other people's code, stripped of attribution.

This is what children do: Ask someone to fix something for you without understanding the result.

No one objects to a human writing code and selling copies.

Apart from that, this is the commercial Picasso who loved money. His early pre-expressionist paintings are godlike in execution, even if someone else has painted a Pierrot before him.

> a far higher intensity

I'm not sure what this is supposed to mean. The code that I've gotten is riddled with mistakes and fabrications. If I were to use it directly, it would significantly slow my pace. Likewise, when I use LLMs to offer alternative methods to accomplish something, I have to take the time to sit down and understand what they're proposing, how to actually make it work, and whether that route(s) would be better than my original idea. That is a significant speed reduction.

The only way I can imagine LLMs resulting in "far higher intensity" is if I was just yolo'ing the code into my program, and then doing frantic integration, correction, and bugfix work afterwards.

Sure, that's "higher intensity", but that's just working harder and not smarter.

You may get to the same destination, but it is not the same activity

It's definitely a personality thing, but that's so much more productive for me, than convincing myself to do all the work from scratch after I had a design.

I guess this means I hate coding, and I only love the dopamine from designing and polishing my work instead of making things work. I'm not sure though, this feels like the opposite of hate coding.

Or are you calling an LLM a "clone" of you? In that case, it's more, "if you create a flawed enough starting premise, anything is possible".

That's where we start to disagree what future looks like, then.

It's not there yet, in that the LLM-clone isn't good enough. But amusingly a not nearly good enough clone of me already made me more productive, in that I'm able to deliver more while maintaining the same level of personal satisfaction with my code.

If I want to spend my time refactoring and bugfixing and rewriting and integrating, rather than writing from scratch and bugfixing, I can definitely achieve that by using LLM code, but the overall time has never felt different to me, and in many cases I've thrown out the LLM code after several hours due to either sheer frustration with how it's written, or due to discovering that the structure it's using doesn't work with the rest of the program (see: anything related to threading).

> This comment section really shows the stark divide between people who love singing and thus hate AI-assisted singing, and people who hate singing and thus love AI-assisted singing.

> Honestly, I suspect the people who would prefer to have someone or something else do their singing, are probably the singers who are already outputting the worst singing right now.

The point is: just because you love something, doesn't mean you're good at it. It is of course positively correlated with it. I am in fact a better singer because I love to sing compared to if I never practiced. But I am not a good singer, I am mediocre at best (I chose this example for a reason, I love singing as well as coding! :-D)

And while it is easier to become good at coding than at singing - for professional purposes at least - I believe that the effect still holds.

And I think we do tend to (rightfully) look down on e.g. singers who lip-sync concerts or use autotune to sing at pitches they otherwise can't, nevermind how we'd react if one used AI singing instead of themselves.

Yes, loving something is no guarantee of skill at it, but hating something is very likely to correspond to not being good at it, since skills take time and dedication to hone. Being bad at something is the default state.

Another analogy would be with sound engineering. I've met sound engineer who hate their job as they would rather play music. They are also the ones whose jobs are likely to be replaced by AI. And I would argue that the argument stand stills. AI Sound Engineers who hate working on sound are often the bad sound engineers.

I tried to cover this particular case with:

> And while it is easier to become good at coding than at singing - for professional purposes at least - I believe that the effect still holds.

---

> Yes, loving something is no guarantee of skill at it, but hating something is very likely to correspond to not being good at it, since skills take time and dedication to hone. Being bad at something is the default state.

I tried to cover this particular case with:

> It is of course positively correlated with it.

---

> Being bad at something is the default state.

Well, skill-wise yes. But being talented at something can happen, even when you hate something.

Autotune is de rigueur for popular music.

In general, I'm not sure that I agree with looking down on people.

AI is like jet fuel for me. It’s the translation layer between specs and code I’ve always wanted. It’s a great advisor for implementation strategies. It’s a way to try new strategies in code quickly.

I don’t need to get anyone else to review my code. Most of this is for personal projects.

I don’t really write professionally, so I don’t have a ton of need for it to manage realities of software engineering (large codebases, peer reviews, black box internal systems, etc). That being said - I do a reasonable amount of embedded Linux work, and AI understands the Linux kernel and device drivers very well.

To extend your metaphor: AI is like a magic microphone that makes all of my singing sound like Tony Rice, my personal favorite singer. I’ve always wanted to sound like him - but I never will. I don’t have the range or the training. But AI allows my coding level to get to that corresponding level with writing software.

I absolutely love it.

Do you love coding, or do you love creating programs?

It seems like the latter given your metaphor being a microphone to make you seem like you could sing well, i.e. wanting the end state itself rather than the achievement via the process.

"wanted to sound like him" vs "wanted to sing like him"

The code is a tool. Nothing more.

I love the shed I built for my family. I don’t have a single feeling for the hammer I used to build it.

For the record: I can sing well. I just can’t sound like Tony Rice. I don’t have his vocal cords or training.

I made a cyber deck several months back, and I opted to carve the case from wood rather than 3d printing or using a premade shell. That hands-on work is something I'm proud of. I don't even use the deck much, it was for the love of building one.

To be fair, I don't have any problem with people who do their jobs for the paycheck alone, because that's the world capitalism has forced us into. Companies don't care about or reward you for the skills you possess, only how much money you make them (and they won't compensate you properly for it, either), so there's no advantage to tying your self-worth up in what you produce for them.

But I do think that it's sad we're seeing creative skills, whether writing coding composing or drawing, be devalued by AI as we are.

> For the record: I can sing well.

That is awesome! It's a great skill to have, honestly. As someone whose body tends to be falling apart more than impressing anyone, I envy that. :)

You don't need a multi-million dollar LLM to give you slightly different boilerplate snippets when you already have a text editor on your computer to save them.

it's not about having the LLM write some "starter pack" toy scaffold. i means when i implement functionality across different classes and need to package that up and adapt, i can just tell the LLM how to approach it and it can produce entire sections of code that would literally just be adaptations of certain things. or to refactor certain pieces that would just be me re-arranging shit.

maybe that's not "boilerplate", but to me it's a collosal waste of my time that could be spent trying to solve a new problem. you can't package that up into a "code snippet" and it's not worth the time carefully crafting templates. LLM can do it faster, better, and cost me near nothing.

> LLM can do it faster, better, and cost me near nothing.

And this is one the thing I'm skeptical about. The above use case is a symptom of all code and no design. It is a waste of time because you're putting yourself in a corner, architecture wise. Kinda like building on a crooked foundation.

I've never done refactoring where I'm writing a lot of code, it's mostly just copy-paste and rebuilding the connection between modules (functions, classes, files, packages,...). And if the previous connections were well understood and you have a clear plan for the new design, then it's a no-brainer to get there. Same when adapting code, I'm mostly deleting lines and renaming variables (regex is nice).

Maybe I'm misunderstanding things, but unless it's for small scripts or very common project types, I haven't seen the supposed productivity gain compared to traditional tooling.

1) refactoring. copy paste, re-arrange, extract, delete and rebuild the connection. i have the mental model and tell the LLM do do it across multiple files or classes. does it way faster and exactly how i would do it given the right prompt which is just a huge file that dictates how things are structured, style, weird edge cases i encountered as time goes on.

2) new features or sections based on existing. i have a service class and want to duplicate and wire up different sections across domains. not easy enough to just be templated, but LLM can do it and understand the nuances. again, generate multiple files across classes no problem.

i can do all these things "fast". i can do them even faster when using the LLM, it offloads the tediousness and i save my brian for other tasks. alot of times i'm just researching my next thing while it chugs away. i come back, lint and review and i'm good to go.

i'm honestly still writing the majority of the code myself, esp if it's like design stuff or new features where the requirements and direction aren't as clear, but when i need to it gives me a huge boost.

keeps me in the flow, i basically recharge while continuing to code. and it's not a small script but a full fledged app, albeit very straightforward architecture wise. the gains are very real. i'm just surprised at the sentiment on HN around it. it's not even just skepticism but outright dogging on it.

I do see more people who seem to be using it to replace coding skill rather than augment it, and I do worry about management's ability to differentiate between those versus just reverting to LoC. And whether it will become a demand for more code, for the same pay.

It’s when you try to use an exotic language, you realize the amount of work that has been done to minimize dev time in more mainstream languages.

Documentation needs to be by humans for humans, it's not a box that's there to be filled with slop.

This is true for producing the documentation but if there is an LLM that can take said documentation and answer questions about it is a great tool. I think I get the answer far quicker with LLM than sifting through documentation when looking for existence of a function in a library or a property on an object.

(And I don't enjoy the value judgement)

Yes, there are tasks or parts of the code that I'm less interested in, and would happily either delegate or negotiate-off to someone else, but I wouldn't give those to a writer who happens to be able to write in a way that approximates program code, I'd give them to another dev on the team. A junior dev gets junior dev tasks, not tasks that they don't have the skills to actually perform, and LLMs aren't even at an actual junior dev level, imhe.

I noted in another comment that I've also used LLMs to get ideas for alternate ways to implement something, or to as you said "jump start" new files or programs. I'm usually not actually pasting that code into my IDE, though- I've tried that, and the work to make LLM-generated code fit into my programs is way more than just writing out the bits I need, where I need. That is clearly not the case for a lot of people using LLMs, though.

I've seen devs submitting PRs with giant blocks of clearly LLM-gen'd code, that they've tried to monkey-wrench into working with the rest of the program (often breaking conventions or secure coding standards). And these aren't junior devs, they're devs that have been working here for years and years.

When you force them to do a code review, they know it's not up to par, but there is a weird attitude that LLM-gen'd code is more acceptable to be submitted with issues than personally-written code. As though it's the LLM's fault or job to fix, even though they prompted and copied and badly-integrated and PR'd it.

And that's where I think there is a stark divide. I think you're on my side of the divide (at least, I didn't get the impression that you hate coding), it just sounds like you haven't really seen the other side.

My personal dime-store psych theory is that it's the same mental mechanism that non-technical computer users fall into of improperly trusting/ believing computers to produce correct information, but now happening to otherwise technical folks too because "AI" is still a black box technology to most of us, like computers in general are to non-techies.

LLMs are really really cool, and really really impressive to me, and I've had 'wow' moments where they did something that makes you forget what they are and how they work, but you can't let that emotional reaction towards it override the part that knows it's just a token chain. When you do, people end up (obviously on the very extreme end) 'dating' them, letting them make consequential "decisions", or just over-trusting their output/code.

Coding is just a means to an end - creating enough business value to convince the company I’m working for to give me money that I can exchange for food and shelter.

If AI can help me do that faster, I’m going to use it. Neither do I want to spend months procuring hardware and managing building out a server room (been there done that) when I can just submit some yaml/HCL and have it done for me in a few minutes.

Just last week it wrote me a whole application and gui to open a webpage at a specific time. Yeah it breaks after the first trigger but it works for what I need.

There's a lot of literature about these concerns and a lot of methodologies to alleviate them. I (and others) are judging LLMs in light of those concerns. Mostly because speed was never an issue for us in prototypes and scripts (and it can be relaxing to learn about something while scripting it). The issue is always reliability (can it do what I want) and maintainability (can I change it later). Performance can also be a key issue.

Aside: I don't know the exact problem you were solving, but based on the description, that could have been done with systemd timers (macOS services are more of a pain to write). Yes, there's more to learn, but time triggering some command is a problem solved (and systemd has a lot more triggers).

But the simple fact is I'm much more productive with AI and I believe this is likely true for most programmers once they get adjusted.

So for production, what I love the most doesn't really matter, otherwise I'd be growing tomatoes and guiding river rafting expeditions. I'm resigned to the fact the age of manually writing "for loops" is largely over, at least in my case.

Alright, please stop using SDK's, google, stackoverflow, any system libraries. You prefer to do it for yourself right?

SDKs and libraries are there to provide common (as in, used repeatedly, by many) functions that serve as BUILDING BLOCKS.

If you import a library and now your program is complete, then you didn't actually make a useful program, you just made a likely less efficient interface for the library.

BUT ALSO-

SDKs and libraries are *vetted* code. The advantage you are getting isn't just about it having been written for you, it's about the hundreds of hours of human code review, iteration, and thought, that goes into those libraries.

LLM code doesn't have that, so it's not about you benefitting from the knowledge and experience of others, it's purely about reducing personally-typed LoC.

And yes, if you're wholesale copy-pasting major portions of your program from stack overflow, I'd say that's about as bad as copy-pasting from ChatGPT.

EDIT: incidentally, Suchir Balaji was 26 when he held those views.

People aren't taking LLM code and then thoughtfully refactoring and improving it, they're using it to *avoid* doing that, by treating the generated code as though it's already had that done.

That's why the pro-LLM-code people in this very thread are talking about using it to automate away the parts of the coding they don't like. You really think they're then going to go back and improve on the code past it minimally working?

There will be no advancement from that, just mediocre or bad code going unreviewed and ignored until it breaks.

Solving problems for real people. Isn't the answer here kind of obvious?

Our field has a whole ethos of open-source side projects people do for love and enjoyment. In the same way that you might spend your weekends in a basement woodworking shop without furnishing your entire house by hand, I think the craft of programming will be just fine.

Now you don't really have to be precise at any level to get something 'working'. You may not be familiar with the generated language or libaries but it could look good enough (like the assembly would have looked good enough). So, sure, if you are very familiar with the generated language and libraries and you inspect every line of generated code then maybe you will be ok. But often the reason you are using an LLM is because e.g. you don't understand or use bash frequently enough to get it to do what you want. Well, the LLM doesn't understand it either. So that weird bash construct that it emitted - did you read the documentation for it? You might have if you had to write it yourself.

In the end there could be code in there that nothing (machine or human) understands. The less hard-won experience you have with the target and the more time-pressed you are the more likely it is that this will occur.

The output of the LLM is determined by the weights (parameters of the artificial neural network) estimated in the training as well as a pseudo-random number generator (unless its influence, called "temperature", is set to 0).

That means LLMs behave as "processes" rather than algorithms, unlike any code that may be generated from them, which is algorithmic (unless instrcuted otherwise; you could also tell an LLM to generate an LLM).

Confused by what you mean. Is this not the case?

You can naturally revert to old ways, by asking for the Assembly manually, and call the Assembler yourself.

No. There are a thousand other ways of solving problems for real people, so that doesn't explain why some choose software development as their preferred method.

Presumably, the reason for choosing software development as the method of solving problems for people is because software development itself brings joy. Different people find joy in different aspects even of that, though.

For my part, the stuff that AI is promising to automate away is much of the stuff that I enjoy about software development. If I don't get to do that, that would turn my career into miserable drudgery.

Perhaps that's the future, though. I hope not, but if it is, then I need to face up to the truth that there is no role for me in the industry anymore. That would pretty much be a life crisis, as I'd have to find and train for something else.

Software development is almost unique in the scale that it operates at. I can write code once and have it solve problems for dozens, hundreds, thousands or even millions of people.

If you want your work to solve problems for large numbers of people I have trouble thinking of any other form of work that's this accessible but allows you to help this many others.

Fields like civil engineering are a lot harder to break into!

There's inertia in the industry. It's not like what you're describing could happen in the blink of an eye. You may well be at the end of your career when this prophecy is fulfilled, if it ever comes true. I sure will be at the end of mine and I'll probably work for at least another 20 years.

And what happened? Programmers make the queries and embed them into code that creates dashboards that managers look at. Or managers ask analysts who have to interpret the dashboards for them... It rather created a need for more programmers.

Compare embedded SQL with prompts - SQL queries compared to assembler or FORTRAN code is closer to English prose for sure. Did it take some fun away? Perhaps, if manually traversing a network database is fun to anyone, instead of declaratively specifying what set of data to retrieve. But it sure gave new fun to people who wanted to see results faster (let's call them "designers" rather than "coders"), and it made programming more elegant due to the declarativity of SQL queries (although that is cancelled out again by the ugliness of mixing two languages in the code).

Maybe the question is: Does LLM-based coding enable a new kind of higher level "design flow" to replace "coding flow"? (Maybe it will make a slightly different group of people happy?)

I don't see why we should seek an explanation if there are thousands of ways to be useful to people. Is being a lawyer particularly better than being an accountant?

Look at the majority of the tech sector for the last ten years or so and tell me this answer again.

Like I guess this is kind of true, if "problems for real people" equals "compensating for inefficiencies in our system for people with money" and "solutions" equals "making a poor person do it for them and paying them as little as legally possible."

(Interesting how people talk about AI destroying programming jobs all the time, but rarely mention the impact of billions of dollars of code being given away.)

Open source software is not just different in the license, it’s different in the design

Linux also doesn’t take jobs away - the majority of contributors are paid by companies, afaik

How true that is depends on what sort of software you write. Very little of what I've accomplished in my career can be fairly described as "automating other people's jobs away".

"Yes, yes... Satellites stay in orbit for a while. What about it?"

"Looks a bit cramped in there."

"Stop complaining, at least it's a real job, now get in, we're about to launch."

I've worked in a medical space writing software so that people can automate away the job that their bodies used to do before they broke.