RU version is available. Content is displayed in original English for accuracy.
Advertisement
Advertisement
⚡ Community Insights
Discussion Sentiment
65% Positive
Analyzed from 1713 words in the discussion.
Trending Topics
#code#programming#never#type#part#editor#typing#more#maybe#liked
Discussion (21 Comments)Read Original on HackerNews
There has been a divergence that is quite stark. I have seen it argued that this is a reflection of ability, and that as a skill multiplier those lacking in skill are feeling left behind. I'm not certain that this is accurate. I definitely see people who have made things that impressed me in the past have been more likely to embrace AI. It may just be a measure of a type of personality.
I have noticed that people who have a strong sense of possessiveness over what they create are more resistant, but those who create in order to have the world contain the thing they are making are happy to have anything that will enable them to contribute to the world.
Some people though society was paying them lots of money to type code into an editor. But that was never true - people and businesses were paying them to solve problems.
I'm not sure how you build that sense as well if you're starting out today, though.
This is a very uncharitable take; I see it mostly from devs who are all-in on AI (not saying you are one), not from devs who just use AI while programming. Basically, I see it from devs who want to never touch a keyboard again.
Maybe they never liked programming in the first place, but liked managing instead, so now they can manage instead of programming.
Maybe they never liked programming, but they did like delivering; now they can work as a product manager, delivering only.
Whatever the reason, they never really liked programming[1]. My experience in programming, since the mid-90s, is that my design is refined as I type out the programs. I gain insight into the problem as I create the program. My thoughts are refined as I read what I type (and not just with programs, with prose as well).
Possibly the all-in devs never read what they typed anyway, so the act of programming never caused them to refine their ideas. Maybe they never read what they typed as they typed it in. Maybe they did, but it never triggered introspection.
Whatever the case is, it's a very uncharitable take to trivialise those engaging in more thought, due to actually writing, as simply enjoying the act of typing.
They are not. They are enjoying the iterative process of deep thinking.
TBH, maybe this is why so many of the all-in AI vibers are trying to trivialise the typing part - if they can convince themselves that typing is so trivial and bereft of thought, then they don't have to admit to themselves that they are thinking less, and the thinking they do do, is not as deep.
----------------------------------
[1] All advances in programming, such as in data structures, algorithms, languages, theory, etc came mostly from people who liked programming. As these people can not hone their skills by working at it for money in the future, who knows if we ever get any more advances.
> [...]
>Whatever the reason, they never really liked programming
I agree with this, at least. Because for me the act of typing the code into the editor was never the enjoyable part. It was always just the thing you had to do before you could enjoy the creation. I wanted to build a website, not type HTML into an editor. I wanted to mod Ultima Online, not type C# into an editor. I wanted to make a PWA, not type ruby into an editor. I wanted to interface some bespoke hardware with GPIO pins, not type python into an editor.
>Whatever the case is, it's a very uncharitable take to trivialise those engaging in more thought, due to actually writing, as simply enjoying the act of typing.
I don't understand the vitriol here. Are you saying you just sit down and start writing the code, without planning or designing the application you're writing beforehand?
Nowadays before any code gets written, by me or by an agent, there ends up being several rounds of back-and-forth on the overall architecture and design of whatever is under consideration. I put thought into data structures, ownership and lifetimes, design patterns, overall project context, etc.
That is, IMHO, the hard part of software engineering. That's the part that pays the bills. Once that part is done, is there any actual value to implementing a ring buffer by hand vs having the model do it? Is there materially more thought? I argue there is not.
I write the code that the models don't write well. I let the models write the code they're good at writing because I've got a thousand better uses for my time than implementing a ring buffer, or an API endpoint handler, or whatever, by hand.
>All advances in programming, such as in data structures, algorithms, languages, theory, etc came mostly from people who liked programming.
Pretty sure they came from computer scientists who programmed by hand (because no other method existed at the time). But there's a famous quote about computer science having very little to do with writing code.
https://web.archive.org/web/20260606173815/https://jakegolds...
Whether or not this author wrote it themselves (I strongly suspect at least an AI editor), the specific style that was, for a time, very attractive has become the hallmark of AI-written prose; and, while the content doesn’t seem wrong from a particular view, it also leaves a taste of waste to me - waste that I spent that time reading something they didn’t write, full of -isms that aren’t theirs, when the thesis could have padded out far less paper.
The word count feels unearned, even if the content is fine.
It's one thing to have AI-written software, where the code isn't the consumable; and quite another to have AI-written essays that are intended to engage a human's critical thinking.
I am very tired of it all.
> The learning loop got tighter. Ask a question. Inspect the answer. Run the code. Break it. Read the implementation. Correct the assumption. Try again.
This assumes that you have the resources (time and money/AI usage budget) and the interest/motivation to do that. If you do programming as a job rather than as a hobby, the time you can spend on things like this and the budget you can spare for it will be severely limited. Also, after you have finally coaxed the LLM into generating something that fits all the requirements without breaking in new and surprising ways, has code that's not ridiculously overengineered (that's probably the real reason behind vibe coding: as long as you don't look at the horror beneath the hood, you can tell yourself everything's fine), doesn't break some convention of the codebase and has the required test coverage and other metrics, you're not only out of time for the task at hand, but also more than ready to move on to something else.
This is my favorite part too. With my own project for example, I had the agent integrate libgit into it so I could add source control to my IDE. Yes, I could have done it myself, but it would have taken me months of trying to understand the API, testing various things, and finally implementing it all. Instead, the agent did almost all the work (I still designed the architecture and how it plugged in). It took about two weeks calendar time and most of that time I was doing something else while the agent worked.
The thing is, before AI agents, I wouldn't have even attempted the work. I wouldn't have been able to afford the time.
Before AI agents, what we would have is maybe a line in the changelog, like “git support has been added” and maybe some post if there’s a substantial Ui/Ux improvement or novelty.
Now it’s just: I did something with AI (with no description of why it has been done, just what) and it was pretty fast (compared to an exaggerated estimation).
The machine doesn't give a shit what you think is hard. You still can't throw away any of the code that you don't understand. The machine needs it all and you choose to stay ignorant.
Experience of the topic at hand absolutely still matters, and even moreso with LLMs. The unhealthy approach is to delegate your work and bury your head in the sand. The healthy approach is to use LLMs to learn and do faster.
At it’s core computing is about taking some information, encode it, transform it, and then decode the result. The latter can be interpreted by humans or used to drive some machinery. The value of computers is that they can do encoding/transform/decoding part reliably and really quickly. But it’s up to use to specify how.
One common trait I found with people that dislike formalism is that they have great reluctance to admit they’re wrong, or at least consider the possibility. And a formal system cleanly mark what is correct according to its axioms.
The issue with most AI practice is that they eschew reliability and guarantees of correctness (not there hasn’t been bugs previously). The proponents can talk about their goals, but they can’t explain the projects they’re working on and reason how it should be correct.
For them, it’s like seeing a chess game and deciding it’s ok if a pawn move like a knight to capture the king, because that’s the intended goal. Like “just move the piece with your hands”. Because it’s hard to devise a strategy that respect the rules. The bad play is obvious when it’s a real chess board, but imagine it’s a generic board where all pieces are little puck with a led fave for colors and types. They wouldn’t mind the pawn to change its type to knight for the illegal move and then revert to pawn once that’s done.
So something like Python and Go is pretty generic. You can code various domains with it (servers, games, apps,…), but it’s up to you to really follow the rules of that domain. Using AI code, there’s a non zero chance for a bit of cheating to happens. While it “works”, it’s not correct, and there’s some use cases that are totally wrong.
Fond feelings for punch cards and hanging chads are the result of thick rose-tinted glasses.