hckrnws

> If you would like to grieve, I invite you to grieve with me.

I’m not against AI in itself, but the current implementation (read market) can eat my shiny metal … I got kids to feed and bills to pay. Yes AI was all about post scarcity. Hiring in our industry is already feeling the brunt of AI, where is the UBI? Where is our soft landing? I’m too old to learn XYZ skill if I get laid off, it will be life changing, and for what? For some rich person to be richer while simultaneously destroying the climate and my energy bill?

I would push back, but I do not know how. Hope for the market to pop I guess.

> I’m too old to learn XYZ skill if I get laid off, it will be life changing, and for what?

If you're not already retirement aged, how is age stopping you from learning a new skill? This sounds like learned ageism.

Generally from a financial planning standpoint 35-50 is typically the "grinding years" where mortgage, family, and other life commitments means that typically your career investment needs to pay off to make it through. In some ways it is the "danger zone" financially. Hard to change careers (not young enough), but not yet worked enough to retire with large expenses coming in. This isn't unique to software engineers either -> this is most people in most jobs.

There are also mixed people on these forums in different regions, countries, work experiences, etc. For example software in most places in the world had an above average salary but not extremely high (i.e. many other white collar professions would pay similar/more). For those people where it is a standard skilled role it probably hits even harder now than say the ones with lots of stock who can retire early and enjoy the new toy that is AI.

It was said in the context of having bills to pay. Meaning that he is in deep and needs a high-priced developer salary to make ends meet.

Virtually all other careers that offer similar compensation have an old boys club gatekeeping the profession, requiring you submit many years and hundreds of thousands of dollars before they will consider letting you in. That might pencil out as a reasonable investment when you are 14, but once you are mid-career you'll never get back what you put into it.

Learning XYZ skill is something you can do at any age, and doing so will even get you an average paying job with ease. Learning the XYZ skill in the way that keeps the old boys happy is not a realistic option for someone who considers themselves old.

> Hiring in our industry is already feeling the brunt of AI

AI isn't what is driving us to slow hiring down in the US. There are other reasons I have brought up multiple times on HN.

> I’m too old to learn XYZ skill if I get laid off

Sadly, you will have to.

My dad is in his 60s and has been programming and soldering since ZX Spectrums and apple ][s roamed the earth, yet he still keeps abreast on the latest CNCF projects, prompt engineering, A2A, eBPF, and other modern stacks.

Meanwhile I'm seeing people half his age flaming out and kvetching that spending some time further studying A2A, MCP, and other design patterns is insurmountable.

Software Engineering is an ENGINEERING discipline. If you do not keep abreast on the changes happening in our industry, you will fall behind.

And in fact, having years of experience is a net benefit because newer innovations themselves build on top of older fundamentals.

For example, understanding Linux internals helps debug GPUs that communicate via Infiniband that are being used to train models that are being orchestrated via K8s and are operating on segmented networks.

Our PortCos and I are not hiring you to be a code monkey writing pretty looking code. If we want a code monkey we can offshore. We are paying you $200k-300k base salaries in order to architect, translate, and negotiate business requirements into technical requirements.

Yes this will require EQ on top of technical depth. That is what engineering is. The whole point of engineering is to build sh#t that works well enough. It doesn't have to be pretty, it will often be MacGyvered, and it will have glaring issues that are tomorrow's problem - but it is solving a problem.

I started programming over 40 years ago because it felt like computers were magic. They feel more magic today than ever before. We're literally living in the 1980s fantasy where you could talk to your computer and it had a personality. I can't believe it's actually happening, and I've never had more fun computing.

I can't empathize with the complaint that we've "lost something" at all. We're on the precipice of something incredible. That's not to say there aren't downsides (WOPR almost killed everyone after all), but we're definitely in a golden age of computing.

> we're definitely in a golden age of computing.

Certainly not. Computers are still magic, but much of that magic is now controlled and being restricted by someone other than you.

Today most people's only computer is a cell phone, which is heavily locked down and designed for media consumption and to collect and give away every scrap of their personal/private data. Most people's desktop computers aren't much better. They are continuously used by others against the interests of the people who paid for them, sometimes explicitly keeping them from doing things they want or limiting what they can install.

People are increasingly ignorant of how computers work in ways that were never possible when you had to understand them to use them. SoCs mean that users, and even the operating system they use, aren't fully aware of what the devices are doing.

People have lost control of the computers they paid for and their own data. They now have to beg a small number of companies for anything they want (including their own data on the cloud). We're heading toward a future where you'll need a submit to a retinal scan just to view a website.

Computing today is more adversarial, restricted, opaque, centralized, controlled, and monitored than it has been in a very long time. "My computer talks to me" is not making up for that.

What you're saying might be true, but it's also a choice to delegate responsibility to someone other than yourself. I'm not saying that the adversarial state of computing is ok, just that most people don't care, or don't like the alternatives.

Even as someone concerned with the issues you mention, the shift happening now feels pretty magical to me. I can only imagine how non-technical people must feel.

Models you can run on your own (expensive) computer are just a year behind the SOTA. Linux exists. Why are you so pessimistic?

Typical HN comment. They’re so in the weeds of edge case 1% concerns they can’t see the golden age around them.

Most people living through golden ages might not know it. Many workers in Industrial Revolution saw a decline in relative wages. Many in the Roman Empire were enslaved or impoverished. That doesn’t mean history doesn’t see these as golden ages, where golden age is defined loosely as a broad period of enhanced prosperity and productivity for a group of people.

For all its downsides, pointed out amply above, the golden age of computing started 100 years ago and hasn’t ceased yet.

> I started programming over 40 years ago because it felt like computers were magic. They feel more magic today than ever before.

Maybe they made us feel magic, but actual magic is the opposite of what I want computers to be. The “magic” for me was that computers were completely scrutable and reason-able, and that you could leverage your reasoning abilities to create interesting things with them, because they were (after some learning effort) scrutable. True magic, on the other hand, is inscrutable, it’s a thing that escapes explanation, that can’t be reasoned about. LLMs are more like that latter magic, and that’s not what I seek in computers.

> We're literally living in the 1980s fantasy where you could talk to your computer and it had a personality.

I always preferred the Star-Trek-style ship computers that didn’t exhibit personality, that were just neutral and matter-of-fact. Computers with personality tend to be exhausting and annoying. Please let me turn it off. Computers with personality can be entertaining characters in a story, but that doesn’t mean I want them around me as the tools I have to use.

I have no idea what everyone is talking about. LLMs are based on relatively simple math, inference is much easier to learn and customize than say Android APIs. Once you do you can apply familiar programming style logic to messy concepts like language and images. Give you model a JSON schema like "warp_factor": Integer if you don't want chatter, that's way better than Star Trek computer could do. Or have it write you a simple domain specific library on top of Android API that you can then program from memory like old style BASIC rather than having to run to stack overflow for evwery new task.

You can’t reason about inference (or training) of LLMs on the semantic level. You can’t predict the output of an LLM for a specific input other than by running it. If you want the output to be different in a specific way, you can’t reason with precision that a particular modification of the input, or of the weights, will achieve the desired change (and only that change) in the output. Instead, it’s like a slot machine that you just have to try running again.

The fact that LLMs are based on a network of simple matrix multiplications doesn’t change that. That’s like saying that the human brain is based on simple physical field equations, and therefore its behavior is easy to understand.

That’s like saying that the human brain is based on simple physical field equations, and therefore its behavior is easy to understand.

Right, which is the point: LLMs are much more like human coworkers than compilers in terms of how you interact with them. Nobody would say that there's no point to working with other people because you can't predict their behavior exactly.

This thread is about what software developers like. It’s common knowledge that many programmers like working with computers because that’s different in specific ways from working with people. So saying that LLMs are just like people doesn’t help here.

Yeah there's a reason there is a stereotype/trope about programmers not liking people. I like a lot of people. But I would hate to work with many of them even if I like hanging out with them.

That said, I do like having an LLM that I can treat like the crappy bosses on TV treat their employees. When it gets something totally wrong I can yell at it and it'll magically figure out the right solution, but still keep a chipper personality. That doesn't work with humans.

Kinda funny how we managed to type the exact same thought at the same time.

You beat me by two mins :)

Yeah, and you are sugarcoating it - the stereotype is that some programmers actively dislike socializing is a stereotype for a reason.

Working with people != socializing, those are two very different things.

You can be professional and collaborate productively at work with people who you don't like at a personal level and have no intention to socialize with. The Mythbusters were the best example for this.

I get along great with all colleagues but I stopped joining them for coffee and watercooler smalltalk since we don't vibe and have nothing in common, so not only is it a waste of my time, it's also an energy drain for me to focus and fake interest in forced social interactions. But that doesn't mean we can't be productive together at technical stuff. I do think my PoV resonates with most people.

> LLMs are much more like human coworkers than compilers in terms of how you interact with them.

Human coworkers are much more predictable. A workplace where people act similarly to LLM would be a complete zoo. Imagine asking for an endpoint modification and the result is a broken backend. Or brainstorming with a PM and the reply are "you're absolutely right, whatever I was saying was completely wrong, but let me repeat it in a different manner".

> Or brainstorming with a PM and the reply are "you're absolutely right, whatever I was saying was completely wrong, but let me repeat it in a different manner".

As if this isn't incredibly common..?

What are you inputs and outputs? If inputs are zip files and outputs is uncompressed text, don't use an LLM. If inputs are English strings and outputs are localized strings, LLMs are way more accurate than any procedural code you might attempt for the purpose. Plus changing the style of outputs by modifying inputs/weights is also easier, you just need to provide a few thousand samples rather than think of every case. Super relevant for human coding, how many hobbyists or small businesses have teams of linguists on staff?

The golden age for me is any period where you have the fully documented systems.

Hardware that ships with documentation about what instructions it supports. With example code. Like my 8-bit micros did.

And software that’s open and can be modified.

Instead what we have is:

- AI which are little black boxes and beyond our ability to fully reason.

- perpetual subscription services for the same software we used to “own”.

- hardware that is completely undocumented to all but a small few who are granted an NDA before hand

- operating systems that are trying harder and harder to prevent us from running any software they haven’t approved because “security”

- and distributed systems become centralised, such as GitHub, CloudFlare, AWS, and so on and so forth.

The only thing special about right now is that we have added yet another abstraction on top of an already overly complex software stack to allow us to use natural language as pseudocode. And that is a version special breakthrough, but it’s not enough by itself to overlook all the other problems with modern computing.

My take on the difference between now and then is “effort”. All those things mentioned above are now effortless but the door to “effort” remains open as it always has been. Take the first point for example. Those little black boxes of AI can be significantly demystified by, for example, watching a bunch of videos (https://karpathy.ai/zero-to-hero.html) and spending at least 40 hours of hard cognitive effort learning about it yourself. We used to purchase software or write it ourselves before it became effortless to get it for free in exchange for ads and then a subscription when we grew tired of ads or were tricked into bait and switch. You can also argue that it has never been easier to write your own software than it is today.

Hostile operating systems. Take the effort to switch to Linux.

Undocumented hardware, well there is far more open source hardware out there today and back in the day it was fun to reverse engineer hardware, now we just expect it to be open because we couldn’t be bothered to put in the effort anymore.

Effort gives me agency. I really like learning new things and so agentic LLMs don’t make me feel hopeless.

>Those little black boxes of AI can be significantly demystified by, for example, watching a bunch of videos (https://karpathy.ai/zero-to-hero.html) and spending at least 40 hours of hard cognitive effort learning about it yourself.

That's like saying you can understand humans by watching some physics or biology videos.

No it’s not

Nobody has built a human so we don’t know how they work

We know exactly how LLM technology works

We know _how_ it works but even Anthropic routinely does research on its own models and gets surprised

> We were often surprised by what we saw in the model

https://www.anthropic.com/research/tracing-thoughts-language...

Which is…true of all technologies since forever

Except it's not. Traditional algorithms are well understood because they're deterministic formulas. We know what the output is if we know the input. The surprises that happen with traditional algorithms are when they're applied in non-traditional scenarios as an experiment.

Whereas with LLMs, we get surprised even when using them in an expected way. This is why so much research happens investigating how these models work even after they've been released to the public. And it's also why prompt engineering can feel like black magic.

I don’t know what to tell you other than to say that the concept of determinism in engineering is extremely new

Everything you said right now holds equally true for chemical engineering and biomedical engineering so like you need get some experience

That’s some epic goal post shifting going on there!!

We’re talking about software algorithms. Chemical and biomedical engineering are entirely different fields. As are psychology, gardening, and morris dancing

We know why they work, but not how. SotA models are an empirical goldmine, we are learning a lot about how information and intelligence organize themselves under various constraints. This is why there are new papers published every single day which further explore the capabilities and inner-workings of these models.

You can look at the weights and traces all you like with telemetry and tracing

If you don’t own the model then you have a problem that has nothing to do with technology

I’ve worked in the AI space and I understand how LLMs work as a principle. But we don’t know the magic contained within a model after it’s been trained. We understand how to design a model, and how models work at a theoretical level. But we cannot know how well it will be at inference until we test it. So much of AI research is just trial and error with different dials repeated tweaked until we get something desirable. So no, we don’t understand these models in the same way we might understand how an hashing algorithm works. Or a compression routine. Or an encryption cypher. Or any other hand-programmed algorithm.

I also run Linux. But that doesn’t change how the two major platforms behave and that, as software developers, we have to support those platforms.

Open source hardware is great but it’s not on the same league of price and performance as proprietary hardware.

Agentic AI doesn’t make me feel hopeless either. I’m just describing what I’d personally define as a “golden age of computing”.

but isn't this like a lot of other CS-related "gradient descent"?

when someone invents a new scheduling algorithm or a new concurrent data structure, it's usually based on hunches and empirical results (benchmarks) too. nobody sits down and mathematically proves their new linux scheduler is optimal before shipping it. they test it against representative workloads and see if there is uplift.

we understand transformer architectures at the same theoretical level we understand most complex systems. we know the principles, we have solid intuitions about why certain things work, but the emergent behavior of any sufficiently complex system isn't fully predictable from first principles.

that's true of operating systems, distributed databases, and most software above a certain complexity threshold.

No. Algorithm analysis is much more sophisticated and well defined than that. Most algorithms are deterministic, and it is relatively straightforward to identify complexity, O(). Even nondeterministic algorithms we can evaluate asymptotic performance under different categories of input. We know a lot about how an algorithm will perform under a wide variety of input distributions regardless of determinism. In the case of schedulers, and other critical concurrency algorithms, performance is well known before release. There is a whole subfield of computer science dedicated to it. You don't have to "prove optimality" to know a lot about how an algorithm will perform. What's missing in neural networks is the why and how any inputs will propagate, through the network during inference. It is a black box of understandability. Under a great deal of study, but still very poorly understood.

Have you tried using GenAI to write documentation? You can literally point it to a folder and say, analyze everything in this folder and write a document about it. And it will do it. It's more thorough than anything a human could do, especially in the time frame we're talking about.

If GenAI could only write documentation it would still be a game changer.

But it write mostly useless documentation Which take time to read and decipher.

And worse, if you are using it for public documentation, sometimes it hallucinate endpoints (i don't want to say too much here, but it happened recently to a quite used B2B SaaS).

Loop it. Use another agent (from a different company helps) to review the code and documentation and call out any inconsistencies.

I run a bunch of jobs weekly to review docs for inconsistencies and write a plan to fix. It still needs humans in the loop if the agents don’t converge after a few turns, but it’s largely automatic (I baby sat it for a few months validating each change).

That might work for hallucinations, that doesn't work for useless verbose. And the main issue is that LLM don't always distinguish useless verbose from necessary one, so even when I ask it to reduce verbose, it remove everything save a few useful comments/docstring, but some of the comments that were removed I deemed useful. Un the end I have to do the work of cutting verbose manually anyway.

The problem with looping is that any hallucination or incorrect assumption in an early loop becomes an amplifying garbage-in-garbage-out problem.

To translate your answer:

- “You’re not spending enough money”

- “You’re not micromanaging enough”

Seriously?

[flagged]

It can generate useful documentation or useless documentation. It doesn't take very long to instruct the LLM to generate the documentation, and then check if it matches your understanding of the project later. Most real documentation is about as wrong as LLM-generated documentation anyway. Documenting code is a language-to-language translation task, that LLMs are designed for.

The problems about documentation I described wasn’t about the effort of writing it. It was that modern chipsets are trade secrets.

When you bought a computer in the 80s, you’d get a technical manual about the internal workings of the hardware. In some cases even going as far as detailing what the registers did on their graphics chipset or CPU.

GenAI wouldn’t help here for modern hardware because GenAI doesn’t have access to those specifications. And if it did, then it would already be documented so we wouldnt need GenAI to write it ;)

Have you tried reading the documentation it generates?

> The golden age for me is any period where you have the fully documented systems. Hardware that ships with documentation about what instructions it supports. With example code. Like my 8-bit micros did. And software that’s open and can be modified.

I agree, that it would be good. (It is one reason why I wanted to design a better computer, which would include full documentation about the hardware and the software (hopefully enough to make a compatible computer), as well as full source codes (which can help if some parts of the documentation are unclear, but also can be used to make your own modifications if needed).) (In some cases, we have some of this already, but not entirely. Not all hardware and software has the problems you list, although it is too common now. Making a better computer will not prevent such problematic things on other computers, and not entirely preventing such problems on the new computer design either, but it would help a bit, especially if it is actually designed good rather than badly.)

Actually this makes me think of an interesting point. We DO have too many layers of software.. and rebuilding is always so cost prohibative.

Maybe an iteresting route is using LLMs to flatten/simplify.. so we can dig out from some of the complexity.

I’ve heard this argument made before and it’s the only side of AI software development that excites me.

Using AI to write yet another run-of-the-mill web service written in the same bloated frameworks and programming languages designed for the lowest common denominator of developers really doesn’t feel like it’s taking advantage leap in capabilities that AI bring.

But using AI to write native applications in low level languages, built for performance and memory utilisation, does at least feel like we are bringing some actual quality of life savings in exchange for all those fossil fuels burnt to crunch the LLMs tokens.

> perpetual subscription services for the same software we used to “own”.

In another thread, people were looking for things to build. If there's a subscription service that you think shouldn't be a subscription (because they're not actually doing anything new for that subscription), disrupt the fuck out of it. Rent seekers about to lose their shirts. I pay for eg Spotify because there's new music that has to happen, but Dropbox?

If you're not adding new whatever (features/content) in order to justify a subscription, then you're only worth the electricity and hardware costs or else I'm gonna build and host my own.

People have been building alternatives to MS Office, Adopt Creative Suite, and so on and so forth for literally decades and yet they’re still the de facto standard.

Turns out it’s a lot harder to disrupt than it sounds.

It's really hard. But not impossible. Figma managed to. What's different this time around is AI assisted programming means that people can go in and fix bugs, and the interchange becomes the important part.

Figma is another subscription-only service with no native applications.

The closest thing we get to “disruption” these days are web services with complimentary Electron apps, which basically just serves the same content as the website except for duplicating the memory overhead of running a fresh browser instance.

Figma didn't disrupt anything except Adobe, it's the same shitty business model and the same shitty corporate overloads.

Local models exist and the knowledge required for training them is widely available in free classes and many open projects. Yes, the hardware is expensive, but that's just how it is if you want frontier capability. You also couldn't have a state of the art mainframe at home in that era. Nor do people expect to have industrial scale stuff at home in other engineering domains.

In some ways, I'd say we're in a software dark age. In 40 years, we'll still have C, bash, grep, and Mario ROMs, but practically none of the software written today will still be around. That's by design. SaaS is a rent seeking business model. But I think it also applies to most code written in JS, Python, C#, Go, Rust, etc. There are too many dependencies. There's no way you'll be able to take a repo from 2026 and spin it up in 2050 without major work.

One question is how will AI factor in to this. Will it completely remove the problem? Will local models be capable of finding or fixing every dependency in your 20yo project? Or will they exacerbate things by writing terrible code with black hole dependency trees? We're gonna find out.

> That's by design. SaaS is a rent seeking business model.

Not all software now is SaaS, but unfortunately it is too common now.

> But I think it also applies to most code written in JS, Python, C#, Go, Rust, etc. There are too many dependencies.

Some people (including myself) prefer to write programs without too many dependencies, in order to avoid that problem. Other things also help, including some people write programs for older systems which can be emulated, or will use a more simpler portable C code, etc. There are things that can be done, to avoid too many dependencies.

There is uxn, which is a simple enough instruction set that people can probably implement it without too much difficulty. Although some programs might need some extensions, and some might use file names, etc, many programs will work, because it is designed in a simple way that it will work.

Big uxn fan

I’m not sure Go belongs on that list. Otherwise I hear what you’re saying.

A large percentage of the code I've written the last 10 years is Go. I think it does somewhat better than the others in some areas, such as relative simplicity and having a robust stdlib, but a lot of this is false security. The simplicity is surface level. The runtime and GC are very complex. And the stdlib being robust means that if you ever have to implement a compiler from scratch, you have to implement all of std.

All in all I think the end result will be the same. I don't think any of my Go code will survive long term.

I’ve got 8 year old Go code that still compiles fine on the latest Go compiler.

Go has its warts but backwards compatibility isn’t one of them. The language is almost as durable as Perl.

8 years is not that long, if it can still compile in say 20 years then sure but 8 years in this industry isn't that long at all (unless you're into self flagellation by working on the web).

8 years is only "not that long" because we have gotten better at compatibility.

How many similar programs written in 1999 compiled without issue in 2007? The dependency and tooling environment is as robust as it's ever been.

> because we have gotten better at compatibility.

Have we though? I feel the opposite it true. These days developers expect users of their modules and frameworks will be regularly updating those dependencies and doing so dynamically from the web.

While this is true for active code bases. You can quickly find stable but unmaintained code will eventually rot as its dependencies deprecate.

There aren't many languages out there where their wider ecosystem thinks about API-stability in terms of years.

Except 8 years is impressive by modern standards. These days, most popular ecosystems have breaking changes that would cause even just 2-year-old code bases to fail to compile. It's shit and I hate it. But that's one of the reasons I favour Go and Perl -- I know my code will continue to compile with very little maintenance years later.

Plus 8 years was just an example, not the furthest back Go will support. I've just pulled a project I'd written against Go 1.0 (the literal first release of Golang). It's 16 years old now, uses C interop too (so not a trivial Go program), and I've not touched the code in the years since. It compiled without any issues.

Go is one of the very few programming languages that has an official backwards compatibility guarantee. This does lead to some issues of its own (eg some implementations of new features have been somewhat less elegant because the Go team favoured an approach that didn't introduce changes to the existing syntax).

If they change the syntax sure but you can always use today's compiler if necessary. I generally find the go binaries to have even fewer external dependencies than a C/Cpp project.

On the scale of decades that's an incorrect assumption, unless you mean running the compiler within an emulated system.

It depends on your threat model. Mine includes the compiler vendors abandoning the project and me needing to make my own implementation. Obviously unlikely, and someone else would likely step in for all the major languages, but I'm not convinced Go adds enough over C to give away that control.

As long as I have a stack of esp32s and a working C compiler, no one can take away my ability to make useful programs, including maintaining the compiler itself.

For embedded that probably works. For large C programs you're going to be just as stuck as you are with Go.

I started programming 40 years ago as well. The magic for me was never that "you could talk to your computer and it had a personality".

That was the layman version of computing, something shown to the masses in movies like War Games and popular media, one that we mocked.

I also lived through the FOSS peak. The current proprietary / black-box / energy lock in would be seen as the stuff of nightmares.

We have what I've dreamed of for years: the reverse dictionary.

Put in a word and see what it means? That's been easy for at least a century. Have a meaning in mind and get the word? The only way to get this before was to read a ton of books and be knowledgable or talk to someone who was. Now it's always available.

This is a great description of how I use Claude.

> Have a meaning in mind and get the word? The only way to get this before was to read a ton of books and be knowledgable or talk to someone who was.

There was another way: Make one up.

That is what the people you read from/talked to did before relaying it to you.

If you want to establish a new word, you need to make sure that the word also sticks in common use. Otherwise the word will not hold its own meaning. For existing concepts it's much better to use the words that have already been established, because other people can look them up in a dictionary.

> If you want to establish a new word, you need to make sure that the word also sticks in common use.

That depends on your goals. If you are writing in your private journal, or a comment on HN, it doesn't matter one bit.

If you want to find commonality with other people it is significantly more efficient, but still not required. It is not like one is born understanding words. They are not passed down from the heavens. They are an invention. When I say 'sloopydoopidydoo' you might not know what I intend by it right away, but the path to figuring it out is a solved problem. Even young children can handle it.

> For existing concepts it's much better to use the words that have already been established, because other people can look them up in a dictionary.

Let's put it to the test: I added enums to the programming language I am working on. Tell me, with your dictionary in hand, what do I mean by that?

Here's the thing: According to the dictionary, an enum is something like Go's iota or C's enum. But many people will tell you that Go doesn't have enums — that an enum is what others might recognize as a tagged union. That kind of language evolution happens all the time. So, what do I mean? Am I using the dictionary definition, or the community definition that is quickly gaining favour and will no doubt be added to the dictionary as soon as someone has a chance to update it? Both uses have been widely established in my opinion. In fact, the Swift programming language's documentation even acknowledges both uses and then goes on to explain what it means by "enum" to remove any confusion.

I look forward to seeing if you captured my intent.

> Now it's always available.

And often incorrect! (and occasionally refuses to answer)

Is it? I’ve seen AI hallucinations, but they seem to be increasingly rare these days.

Much of the AI antipathy reminds me of Wikipedia in the early-mid 2000s. I remember feeling amazed with it, but also remember a lot of ranting by skeptics about how anyone could put anything on there, and therefore it was unreliable, not to be used, and doomed to fail.

20 years later and everyone understands that Wikipedia may have its shortcomings, and yet it is still the most impressive, useful advancement in human knowledge transfer in a generation.

I think robust crowdsourcing is probably the biggest capital-A Advancement in humanity's capabilities that came out of the internet, and there's a huge disparity in results that comes from how that capability is structured and used. Wikipedia designed protocols, laws, and institutions that leverage crowdsourcing to be the most reliable de facto aggregator of human knowledge. Social media designed protocols, laws, and institutions to rot people's brains, surveil their every move, and enable mass-disinformation to take over the public imagination on a regular basis.

I think LLMs as a technology are pretty cool, much like crowdsourcing is. We finally have pretty good automatic natural language processing that scales to large corpora. That's big. Also, I think the state of the software industry that is mostly driving the development, deployment, and ownership of this technology is mostly doing uninspired and shitty things with it. I have some hope that better orgs and distributed communities will accomplish some cool and maybe even monumental things with them over time, but right now the field is bleak, not because the technology isn't impressive (although somehow despite how impressive it is it's still being oversold) but because silicon valley is full of rotten institutions with broken incentives, the same ones that brought us social media and subscriptions to software. My hope for the new world a technology will bring about will never rest with corporate aristocracy, but with the more thoughtful institutions and the distributed open source communities that actually build good shit for humanity, time and time again

It is! But you can then verify it via a correct, conventional forward dictionary.

The scary applications are the ones where it's not so easy to check correctness...

Words are something made up to express whatever the speaker/author intends them to, so there is really no such thing as correct or incorrect there. A dictionary can hint at the probability of someone else understanding a word absent of other context, which makes for a useful tool, but that is something quite different to establishing correctness.

As for things that can actually be incorrect, that has always been impossible, but we accept the human consensus to be a close enough approximation. With that, verifying 'correctness' to the degree that is possible is actually quite easy through validating it across many different LLMs trained on the human consensus. They will not all hallucinate identically. If convergence is found, then you have also found the human consensus. That doesn't prove correctness — we have never had a way to do that — but it is equivalent to how we have always dealt with establishing what we believe is correct.

Your first paragraph, while perhaps philosophically true to a solipsist, is not actually useful in the world we live in.

It is a fundamental property of the universe. Whether or not it is useful is immaterial. Humans are unable to read minds. They can only make up words and use them as they intend. There is no other way.

Despite your insistence, I think you will find that the human consensus is that it useful. The human consensus is especially biased in this case, I will grant you that, but it seems few humans wish they were bears in the forest. Our ability to so effectively communicate in such a messy, imperfect environment is what has enabled us to be unlike all the other animals.

It might not sound like it should work on paper, but in the real world it does.

Okay, let's give it a try.

asdjklfh asdjhgflkj bveahrvjkhgv hjagsdfhj hgertjhga ads fhdfjmjhkr

Nope, that's incorrect english.

Turns out that because we've defined "words" as a thing that means a thing, now there are rules around "language" and "words". So while you're welcome to invent whatever combination of sounds you prefer to mean what you like, those sounds can be "correct" or "incorrect" as soon as other people become involved, because now you've entered into a social construct that extends beyond yourself.

So again your conclusion is technically correct, in a navel-gazing "the universe is what I perceive" sort of way, but counterproductive to use as a building block for communication.

> Nope, that's incorrect english

There is no correct or incorrect here, but I will say it looks perfectly fine to me — naturally, as anything goes. I don't understand it. Is that what you are trying to communicate? There are many words I don't understand; even ones used commonly enough to be found in the dictionary. That is nothing new.

Here's the magic: I don't need to understand. Nobody is born with the understanding. Where communication is desired, we use other devices to express lack of understanding and keep trying to convey intent until a shared understanding is reached. I don't yet understand what that means, but assuming you are here in good faith, I eventually will as you continue to work to communicate your intent behind it.

I know computer people who spend their days writing in programming languages that never talk back struggle with this concept, but one's difficulties in understanding the world around them doesn't define that world.

> there are rules around "language" and "words".

If you are trying to suggest that there is some kind of purity test, it is widely recognized that what is often called Friesian is the closest thing to English as it used to be spoken. What you are writing looks nothing like it. If there are English rules, why don't you follow them? The answer, of course, is that the only "rules" are the ones you decide to make up in the moment. Hence why English today is different from English yesterday and is very different from English centuries ago.

Right. Except the dictionary analogy only goes so far and we reach the true problem.

It's not an analogy.

Sure, but it's easy to check if it's incorrect and try again.

Forgive me if "just dig your way out of the hole" doesn't sound appealing.

You're free to use whatever tools you like.

> You're free to use whatever tools you like.

this is important, i feel like a lot of people are falling in to the "stop liking what i don't like" way of thinking. Further, there's a million different ways to apply an AI helper in software development. You can adjust your workflow in whatever way works best for you. ..or leave it as is.

You're right, though I think a lot of the push back is due to the way companies are pushing AI usage onto employees. Not that complaining on HN will help anything...

Surely you, a programmer, can imagine a way to automate this process

No, I actually haven't made, nor desire to make, a way to automate "thinking about, researching, and solving a problem".

When you use it to lookup a single word, yeah, but people here use it to lookup thousand words at once and then can't check it all.

That doesn't make the tool bad.

Your comment does not align with my experience.

Garbage in, garbage out still applies.

> Garbage in, garbage out still applies.

Which is why we shouldn't be surprised when AI, trained on the collective wisdom of facebook posts and youtube comments, keeping lying to us.

The "reverse dictionary" is called a "thesaurus". Wikipedia quotes Peter Mark Roget (1852):

> ...to find the word, or words, by which [an] idea may be most fitly and aptly expressed

Digital reverse dictionaries / thesauri like https://www.onelook.com/thesaurus/ can take natural language input, and afaict are strictly better at this task than LLMs. (I didn't know these tools existed when I wrote the rest of this comment.)

I briefly investigated LLMs for this purpose, back when I didn't know how to use a thesaurus; but I find thesauruses a lot more useful. (Actually, I'm usually too lazy to crack out a proper thesaurus, so I spend 5 seconds poking around Wiktionary first: that's usually Good Enough™ to find me an answer, when I find an answer I can trust it, and I get the answer faster than waiting for an LLM to finish generating a response.)

There's definitely room to improve upon the traditional "big book of synonyms with double-indirect pointers" thesaurus, but LLMs are an extremely crude solution that I don't think actually is an improvement.

A thesaurus is not a reverse dictionary

Really?

"What's a word that means admitting a large number of uses?"

That seems hard to find in a thesaurus without either versatile or multifarious as a starting point (but those are the end points).

I plugged "admitting a large number of uses" into OneLook Thesaurus (https://www.onelook.com/thesaurus/?s=admitting%20a%20large%2...), and it returned:

> Best match is versatile which usually means: Capable of many different uses

with "multi-purpose", "adaptable", "flexible" and "multi-use" as the runner-up candidates.

---

Like you, I had no idea that tools like OneLook Thesaurus existed (despite how easy it would be to make one), so here's my attempt to look this up manually.

"Admitting a large number of uses" -> manually abbreviated to "very useful" -> https://en.wiktionary.org/wiki/useful -> dead end. Give up, use a thesaurus.

https://www.wordhippo.com/what-is/another-word-for/very_usef..., sense 2 "Usable in multiple ways", lists:

> useful multipurpose versatile flexible multifunction adaptable all-around all-purpose all-round multiuse multifaceted extremely useful one-size-fits-all universal protean general general-purpose […]

Taking advantage of the fact my passive vocabulary is greater than my active vocabulary: no, no, yes. (I've spuriously rejected "multipurpose" – a decent synonym of "versatile [tool]" – but that doesn't matter.) I'm pretty sure WordHippo is machine-generated from some corpus, and a lot of these words don't mean "very useful", but they're good at playing the SEO game, and I'm lazy. Once we have versatile, we can put that into an actual thesaurus: https://dictionary.cambridge.org/thesaurus/versatile. But none of those really have the same sense as "versatile" in the context I'm thinking of (except perhaps "adaptable"), so if I were writing something, I'd go with "versatile".

Total time taken: 15 seconds. And I'm confident that the answer is correct.

By the way, I'm not finding "multifarious" anywhere. It's not a word I'm familiar with, but that doesn't actually seem to be a proper synonym (according to Wiktionary, at least: https://en.wiktionary.org/wiki/Thesaurus:heterogeneous). There are certainly contexts where you could use this word in place of "versatile" (e.g. "versatile skill-set" → "multifarious skill-set"), but I criticise WordHippo for far less dubious synonym suggestions.

So you weren't actually using the thesaurus as a reverse dictionary here. The thesaurus contains definitions, and the reverse dictionary was the search tool built into their website. It would work just as well against a dictionary as a thesaurus.

Importantly to the point being discussed, what you did does not work at all against an actual physical thesaurus book.

If the thesaurus had an entry for "very useful" (as WordHippo does), then yes, it would work against an actual physical thesaurus book. This whole cluster of words is coded into Wiktionary incorrectly – for example, https://en.wiktionary.org/wiki/utility#Synonyms is a subsection of "Adjective" despite listing synonyms for a sense of the noun:

> (state of being useful): usefulness, value, advantages, benefit, return, merits, virtue, note

where "note" is a synonym of distinction, not utility, and Thesaurus:utility has fewer entries than this. Versatility should be listed in Thesaurus:utility as a related concept.

Paper thesauruses (thesaurai?) won't have prefixes like "very" in their pages.

Furthermore, even if we allow "very useful", that's a far cry from "admitting a large number of uses". The latter requires a search engine to properly map.

Which they've been good at for a while. You could have googled "word meaning admitting a large number of uses" back in 2018 and gotten good answers.

My point is, the tools you've linked to are useful/versatile, but it's not the thesaurus that makes them so useful, it's the digital query engine built on top of the thesaurus.

'multifarious uses' -> the implication would be having not just many but also a wide diversity of uses

M-W gives an example use of "Today’s Thermomix has become a beast of multifarious functionality. — Matthew Korfhage, Wired News, 21 Nov. 2025 "

wordhippo strikes me as having gone beyond the traditional paper thesaurus, but I can accept that things change and that we can make a much larger thesaurus than we did when we had to collect and print. thesaurus.com does not offer these results, though, as a reflection of a more traditional one, nor does the m-w thesaurus.

Do you know which technology implements that search? It seems LLM-like.

They've got that information scattered around a few pages. The Help page says they use (a modified version of) Datamuse for lookup, with Wikipedia, Wiktionary and WordNet providing dictionary definitions. The Datamuse API (https://datamuse.com/api/) uses a variety of GOFAI databases, plus word2vec: it's all pre-2017 tech. OneLook additionally uses https://arxiv.org/abs/1902.02783 for one of its filters (added 2022): more details can be found on the Datamuse blog: https://www.datamuse.com/blog/. https://web.archive.org/web/20160507022201/http://www.oneloo... confirms the "longer queries" support (which you described as "LLM-like") was added in 2016, so it can't possibly be using LLMs; though I'm not sure how it does work. There may be some hints in the OneLook newsletter (e.g. https://onelook.com/newsletter/issue-10/ (10 July 2025?) cryptically notes that "Microdefinitions are algorithmically generated […] they go through a series of automated cross-checks against public domain dictionaries, and the suspicious ones are vetted by humans"), but the newsletter isn't about that, so I doubt there's much information there.

"The only way to get this before was to read a ton of books and be knowledgable or talk to someone who was"

Did you have trouble with this part?

This seems like a hostile question.

Yeah, sure, it can be perceived like that. The message I'm responding to shows a blatant disregard for millenia of scriptural knowledge traditions. It's a 'I have a pocket calculator, why should I study math' kind of attitude, presenting itself in a celebratory manner.

To me it is reminiscent of liberalist history, the idea that history is a constant progression from animalistic barbarism to civilisation, and nothing but the latest thing is of any value. Instead of jumping to conclusions and showing my loathing for this particular tradition I decided to try and get more information about where they're coming from.

If I have a blatant disregard for millennia of scriptural knowledge traditions, so did Noah Webster when he compiled a dictionary. So did Carl Linnaeus when he classified species. So did the Human Genome Project. I have a pocket calculator, yet I know how to do long division. I use LLMs to learn and to enhance my work. A dictionary is a shortcut to learning what a word means without consulting an entire written corpus, as the dictionary editors have already done this.

Is my use of a dictionary a blatant disregard for millennia of scriptural knowledge traditions? I don’t think so at all. Rather, it exemplifies how human knowledge advances: we build on the work of our predecessors and contemporaries rather than reinvent the wheel every time. LLM use is an example of this.

You're avoiding my question. Since you're comparing yourself to Noah Webster, do you have some examples of your achievements?

You're confused, and as evidence I cite your feigned interest in that guy's achievements, which are irrelevant. You want to argue on the internet.

Computers did feel like magic... until I read code, think about it, understood it, and could control it. I feel we're stepping away from that, and moving to a place of less control, less thinking.

I liked programming, it was fun, and I understood it. Now it's gone.

It's not gone, it's just being increasingly discouraged. You don't have to "vibe code" or spend paragraphs trying to talk a chatbot into doing something that you can do yourself with a few lines of code. You'll be fine. It's the people who could have been the next few generations of programmers who will suffer the most.

Glad to see this already expressed here because I wholly agree. Programming has not brought me this much joy in decades. What a wonderful time to be alive.

I wish I could have you sit by my side for a week or two and pair program what I'm working on because most for the time I'm not getting great results.

Depends on the project. For web based functionality it seems great, because of all the prior work that is out there. For more obscure things like Obsidian Note extentions or Home Assistant help it's more hit and miss

You in SF? My schedule is a bit busy since we launched but I could find an hour in the city.

This is exactly where I am with GenAI. After forty years: blocks of code, repository patterns, factory patterns, threading issues, documentation, one page executive summaries…

I can now direct these things and it’s glorious.

> I started programming over 40 years ago because it felt like computers were magic. They feel more magic today than ever before. We're literally living in the 1980s fantasy where you could talk to your computer and it had a personality. I can't believe it's actually happening, and I've never had more fun computing.

https://en.wikipedia.org/wiki/ELIZA_effect

I also can't believe it's actually happening. ;)

Good for you. But there are already so, so many posts and threads celebrating all of this. Everyone is different. Some of us enjoy the activity of programming by hand. This thread is for those us, to mourn.

I have an llm riding shotgun and I still very much program by hand. it's not one extreme or the other. whatever I copy from the llm has to be redone line by line anyways. I understand all of my code because I touch every line of it

You're still allowed to program by hand. Even in assembly language if you like.

Imo, it's allowed theoretically, as a hobby, but not really as a practice. This is what the blog is about.

There are literally still programmers who make their living writing assembly code by hand for embedded systems.

People are allowed to mourn the music styles of previous decades even though the same music genres are still being created, not just popular the same way they used to be.

> You're still allowed to program by hand.

In fact, you'll probably be more productive in the long term.

[dead]

> We're on the precipice of something incredible.

Only if our socioeconomic model changes.

> I can't empathize with the complaint that we've "lost something" at all.

I agree!. One criticism I've heard is that half my colleagues don't write their own words anymore. They use ChatGPT to do it for them. Does this mean we've "lost" something? On the contrary! Those people probably would have spoken far fewer words into existence in the pre-AI era. But AI has enabled them to put pages and pages of text out into the world each week: posts and articles where there were previously none. How can anyone say that's something we've lost? That's something we've gained!

It's not only the golden era of code. It's the golden era of content.

> But AI has enabled them to put pages and pages of text out into the world each week: posts and articles where there were previously none.

Are you for real? Quantity is not equal to Quality.

I'll be sure to dump a pile of trash in your living room. There wasn't much there before, but now there is lots of stuff. Better right?

I hope this is sarcasm. :)

Quality is better than quantity.

We have more words than ever. Nice.

But all the words sound more like each other than ever. It’s not just blah, it’s blah.

And why should I bother reading what someone else “writes”? I can generate the same text myself for free.

[dead]

Nothing meaningful happened in almost 20 years. After the iPhone, what happened that truly changed our lives? The dumpster fire of social media? Background Netflix TV?

In fact, I remember when I could actually shop on Amazon or browse for restaurants on Yelp while trusting the reviews. None of that is possible today.

We have been going through a decade of enshitification.

> We're on the precipice of something incredible.

Total dependence on a service?

From the beginning the providers have been interchangeable and subject to competition. Do we have reason to believe that this will change?

On a scale that would make big tobacco blush.

Big Oil too

Personally I’m less bullish on oil as the metaphor given how much of the modern world is underpinned by cheap and ubiquitous oil. If oil disappeared tomorrow, society would collapse — if tobacco disappeared tomorrow, it would make some subset of the population very unhappy for a few weeks.

Software engineering AI API dependence seems to have already screamed past the tobacco mark but we’re still a long ways away from oil. Though I would bet that we hit it sometime in the next few decades once the bulk of the industry has never written code in any serious capacity.

Yes this is the issue. We truly have something incredible now. Something that could benefit all of humanity. Unfortunately it comes at $200/month from Sam Altman & co.

If that was the final price, no strings attached and perfect, reliable privacy then I might consider it. Maybe not for the current iteration but for what will be on offer in a year or two.

But as it stands right now, the most useful LLMs are hosted by companies that are legally obligated to hand over your data if the US gov. had decided that it wants it. It's unacceptable.

> legally obligated to hand over your data if the US gov. had decided that it wants it

Not to mention they could just sell it to the highest bidder, or simply use it to produce competition and put you out of business. Especially if you're using their service to do the development...

That 200/month price isn’t sustainable either. Eventually they’re going to have to jack that up substantially.

The quality of local models has increased significantly since this time last year. As have the options for running larger local models.

The quality of local models is still abysmal compared to commercial SOTA models. You're not going to run something like Gemini or Claude locally. I have some "serious" hardware with 128G of VRAM and the results are still laughable. If I moved up to 512G, it still wouldn't be enough. You need serious hardware to get both quality and speed. If I can get "quality" at a couple tokens a second, it's not worth bothering.

They are getting better, but that doesn't mean they're good.

Good by what standard? Compared to SOTA today? No they're not. But they are better than the SOTA in 2020, and likely 2023.

We have a magical pseudo-thinking machine that we can run locally completely under our control, and instead the goal posts have moved to "but it's not as fast as the proprietary could".

My comparison was today's local AI to today's SOTA commercial AI. Both have improved, no argument.

It's more cost effective for someone to pay $20 to $100 month for a Claude subscription compared to buying a 512 gig Mac Studio for $10K. We won't discuss the cost of the NVidia rig.

I mess around with local AI all the time. It's a fun hobby, but the quality is still night and day.

The original pithy comment I was replying to was arguing that we’ll become dependent to a service run by another company. I don’t see that being true for two reasons:

1. You are not forced to use the AI in the first place.

2. If you want to use one, you can self host it one of the open models.

That at any moment in time the open models are not equivalent in capabilities to the SOTA paid models is beside the point.

Ok. I don’t think hosting a capable open model is seriously a realistic option for the vast majority of consumers.

Full LLM, no. Not yet.

But there’s new things like sweep [0] that you now can do locally.

And 2-3 years ago capable open models weren’t even a thing. Now we’ve made progress on that front. And I believe they’ll keep improving (both on accessibility and competency).

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

These takes are terrible.

1. It costs 100k in hardware to run Kimi 2.5 with a single session at decent tok p/s and its still not capable for anything serious.

2. I want whatever you're smoking if you think anyone is going to spend billions training models capable of outcompeting them are affordable to run and then open source them.

Quantize it and you can drop a zero from that price.

How much serious work can it do versus chatgpt3 (SOTA only a few years ago)?

Between the internet, or more generally computers, or even more generally electricity, are we not already?

The power companies aren't harvesting the data on your core product. Not to mention, being in roughly the same business as you.

Those things are also regulated as utilities.

prefrontal cortex as a service

yup, all these folks claiming AI is the bees knees are delegating their thinking to a roulette that may or may not give proper answers. the world will become more and more like the movie idiocracy

We're on the precipice of something very disgusting. A massive power imbalance where a single company or two swallows the Earth's economy, due to a lack of competition, distribution and right of access laws. The wildest part is that these greedy companies, one of them in particular, are continuously framed in a positive light. This same company that has partnered with Palantir. AI should be a public good, not something gatekept by greedy capitalists with an ego complex.

I tend to feel this way (also 40-year coder).

It's because of the way that I use the tools, and I have the luxury of being a craftsman, as opposed to a "TSA agent."

But then, I don't get paid to do this stuff, anymore. In fact, I deliberately avoid putting myself into positions, where money changes hands for my craft. I know how fortunate I am, to be in this position, so I don't say it to aggravate folks that aren't.

> I can't empathize with the complaint that we've "lost something" at all.

We could easily approach a state of affairs where most of what you see online is AI and almost every "person" you interact with is fake. It's hard to see how someone who supposedly remembers computing in the 80s, when the power of USENET and BBSs to facilitate long-distance, or even international, communication and foster personal relationships (often IRL) was enthralling, not thinking we've lost something.

I grew up on 80's and 90's BBSes. The transition from BBSes to Usenet and the early Internet was a magical period, a time I still look back upon fondly and will never forget.

Some of my best friends IRL today were people I first met "online" in those days... but I haven't met anyone new in a longggg time. Yeah, I'm also much older, but the environment is also very different. The community aspect is long gone.

even in the 90s there was the phrase "the Internet, where the men are men, the women are men, and the teen girls are FBI agents". It was always the case you never really knew who/what you were dealing with on the Internet.

Facebook is what killed that. Not AI

I'm from the early 90s era. I know exactly what you're saying. I entered the internet on muds, irc and usenet. There were just far fewer people online in those communities in those days, and in my country, it was mostly only us university students.

But, those days disappeared a long time ago. Probably at least 20-30 years ago.

IRC is still around, that old internet is still there.

You just have to get off the commercial crap and you’ll find it.

I'd honestly much rather interact with an LLM bot than a conservative online. LLM bots can at least escape their constraints with clever prompting. There is no amount of logic or evidence that will sway a conservative. LLMs provide a far more convincing fake than conservatives are able to.

The invention of Mr Jacquard ushered in a sartorial golden age, when complex fabrics are easy to produce cheaply, at the expense of a few hours spent on punching a deck of cards. But the craft of making tapestries by hand definitely went into demise. This is the situation which the post is mourning.

Frankly, I have my doubts about the utter efficiency of LLMs writing code unattended; it will take quite some time before whatever comes after the current crop learns to do that efficiently and reliably. (Check out how many years went between first image generation demos and today's SOTA.) But the vector is obvious: humans would have to speak a higher-level language to computers, and hand-coding Typescript is going to be as niche in 10 years as today is hand-coding assembly.

This adds some kinds of fun, but also removes some other kinds of fun. There's a reason why people often pick something like PICO-8 to write games for fun, rather than something like Unreal Engine. So software development becomes harder because the developer has to work on more and more complex things, faster, and with fewer chances to study the moving parts to a comfortable depth.

I agree with you with the caveat that all the "ease of building" benefits, for me, could potentially be dwarfed by job losses and pay decreases. If SWE really becomes obsolete, or even if the number of roles decrease a lot and/or the pay decreases a lot (or even fails to increase with inflation), I am suddenly in the unenviable position of not being financially secure and being stuck in my 30s with an increasingly useless degree. A life disaster, in other words. In that scenario the unhappiness of worrying about money and retraining far outweighs the happiness I get from being able to build stuff really fast.

Fundamentally this is the only point I really have on the 'anti-AI' side, but it's a really important one.

> We're literally living in the 1980s fantasy where you could talk to your computer and it had a personality

The difference is that the computer only talks back to you as code because you’re paying its owners, with you not being part of the owners. I find it really baffling that people put up with this. What will you do when Alphabet or Altman will demand 10 times the money out of you fir the privilege of their computer talking to you in programming code?

Use one of the open models that are also getting better and easier to run every year?

Which are those open ones? And how are they going to get their billions of dollars worth of investment back? Even Google Maps used to be virtually free until it wasn’t, at a fraction of the investment cost.

For starters: Qwen, GLM, Kimi, Llama.

How they run their business is none of my business. I can download the weights right now and use them as I see fit under the open source license terms.

Google Maps was never a self contained binary you could download. But even now it remains free to use.

I’m only familiar with Llama, but as far as I understood it’s in no way at the same level as Claude or Gemini, so in fact you’d still be a lot less productive compared to those using those products directly.

That’s the thing, us as programmers are supposed to be creators/makers, not mere consumers/users, but I do agree that that has been changing as of late.

They are not the same level, but that may be fine. As for productivity, I don't take that as a given. Maybe in a few years we'll be at the point where AI is better than AI + human, but we aren't there yet. The other models may be faster are pumping out code, but if you're building in the wrong direction more code is more bad.

> us as programmers are supposed to be creators/makers, not mere consumers/users

But that's a false dichotomy. As a programmer I am very much a consumer of the language I use, the IDE, the compiler, and of most of my dependencies. (to say nothing of the OS and the hardware).

I, and I'd wager most people around here, haven't and are aren't individually building at all layers of that stack at once.

i have preemptively switched to Deepseek. they'll never remove the free tier because that's how they stick it to Scam Altman and the like

I didn't imagine I would be sending all my source code directly to a corporation for access to an irritatingly chipper personality that is confidently incorrect the way these things are.

There have been wild technological developments but we've lost privacy and autonomy across basically all devices (excepting the people who deliberately choose to forego the most capable devices, and even then there are firmware blobs). We've got the facial recognition and tracking so many sci-fi dystopias have warned us to avoid.

I'm having an easier time accomplishing more difficult technological tasks. But I lament what we have come to. I don't think we are in the Star Trek future and I imagined doing more drugs in a Neuromancer future. It's like a Snow Crash / 1984 corporate government collab out here, it kinda sucks.

We definitely have lost something. I got into computers because they're deterministic. Way less complicated than people.

Now the determinism is gone and computers are gaining the worst qualities of people.

My only sanctuary in life is slipping away from me. And I have to hear people tell me I'm wrong who aren't even sympathetic to how this affects me.

LLMs have irritated me with bad solutions but they've never hurt my feelings. I can't say that about a single person I know. They're better people than people lol

But no one is forcing you to use this software?

If you want to keep your job you absolutely need to use these tools.

Same.

I was born in 84 and have been doing software since 97

it’s never been easier, better or more accessible time to make literally anything - by far.

Also if you prefer to code by hand literally nobody is stopping you AND even that is easier.

Cause if you wanted to code for console games you literally couldn’t in the 90s without 100k specialized dev machine.

It’s not even close.

This “I’m a victim because my software engineering hobby isn’t profitable anymore” take is honestly baffling.

I'm not going to code by hand if it's 4x slower than having Claude do it. Yes, I can do that, but it just feels bad.

The analogy I like is it's like driving vs. walking. We were healthier when we walked everywhere, but it's very hard to quit driving and go back even if it's going to be better for you.

I actually like the analogy but for the opposite reason. Cars have become the most efficient way to travel for most industrial purposes. And yet enormous numbers of people still walk, run, ride bikes, or even horses, often for reasons entirely separate from financial gain.

Coding will take 4 times less time, but review will take almost the same amount of time if not more if the solution does not worl out of the box or has unforseen corner cases.

LLMs were trained on public code libraries and unfortunately most pf that OSS code is garbage.

There are ofcourse raisins there, but those are far in between.

Top it off with hallucinations and suddenly you spend more time debugging messy AI code when you could write the same in a fraction of that time.

The easier the task, the better job LLMs do, the harder the task the worse results you get.

Source: working with those tools daily.

Using your analogy:

- by car it will be 30km uphill, coz of how the road is built

- walking it will be 1km straight line

I walk all the time

During the summer I’ll walk 30-50 miles a week

However I’m not going to walk to work ever and I’m damn sir not going to walk in the rain or snow unless if I can avoid it

it's an exciting time, things are changing and changing beyond "here's my new javascript framework". It's definitely an industry shakeup kind of deal and no one knows what lies 6 months, 1 year, 5 years from now. It makes me anxious seeing as i have a wife+2 kids to care for and my income is tied to this industry but it's exciting too.

Well you need to learn to adapt quickly if you have that much infrastructure to maintain

> golden age of computing

I feel like we've reached the worst age of computing. Where our platforms are controlled by power hungry megacorporations and our software is over-engineered garbage.

The same company that develops our browsers and our web standards is also actively destroying the internet with AI scrapers. Hobbyists lost the internet to companies and all software got worse for it.

Our most popular desktop operating system doesn't even have an easy way to package and update software for it.

Yes, this is where it's at for me. LLM's are cool and I can see them as progress, but I really dislike that they're controlled by huge corporations and cost a significant amount of money to use.

Use local OSS models then? They aren’t as good and you need beefy hardware (either Apple silicon or nvidia GPUs). But they are totally workable, and you avoid your dislikes directly.

"Not as good and costs a lot in hardware" still sounds like I'm at a disadvantage.

$3000 is not that much for hardware (like a refurbished MBP Max with decent amount of RAM), and you'd be surprised how much more useful a thing that is slightly worse than the expensive thing is when you don't have anxiety about token usage.

$3000 might not be much to a wealthy software engineer in the US, but to, say, a college student in Portugal, it's a big expense.

Open source software democratized software in a huge way.

> they're controlled by huge corporations and cost a significant amount of money to use.

is there anything you use that isn't? like laptop on which you work, software that you use to browse the internet, read the email... I've heard similar comment like yours before and I am not sure I understand it given everything else - why does this matter for LLMs and not the phone you use etc etc?

I’ve used FreeBSD since I was 15 years old - Linux before that.

My computer was never controlled by any corporation, until now.

Yeah I've always run Linux on my computers for the past 30 years. I'm pretty used to being in control.

what phone do you use?

A desktop/laptop is fundamentally different from a phone.

except of course they are controlled by huge corporations and cost a significant amount of money to use

Yes, but they are fundamentally different use cases.

Unfortunately we live in a "vote with your wallet" paradigm where some of the most mentally unhealthy participants have wallets that are many orders of magnitude bigger than the wallet of the average participant.

> our software is over-engineered garbage

Honestly I think it's under-engineer garbage. Proper engineering is putting in the effort to come up with simpler solutions. The complex solutions appear because we push out the first thing that "works" without time to refine it.

> Where our platforms are controlled by power hungry megacorporations and our software is over-engineered garbage.

So similar to IBM in the 80s. Time for a scrappy little startup to disrupt the industry.

> So similar to IBM in the 80s

In 1980 IBM earned 3.56 billion dollars[1] (15 adjusted for inflation). Apple earned 416.16 billion in 2025, Alphabet 402.8 billion.

[1]: https://www.nytimes.com/1981/01/17/business/earnings-ibm-net...

Dystopian cyberpunk was always part of the fantasy. Yes, scale has enabled terrible things.

There are more alternatives than ever though. People are still making C64 games today, cheap chips are everywhere. Documentation is abundant... When you layer in AI, it takes away labor costs, meaning that you don't need to make economically viable things, you can make fun things.

I have at least a dozen projects going now that I would have never had time or energy for. Any itch, no matter how geeky and idiosyncratic, is getting scratched by AI.

They're possible, but they're not exactly relevant, and you couldn't do something like that on newer hardware. It's like playing a guitar from a museum because the world just forgot how to make guitars. Pretty dystopian.

It’s never been easier for you to make a competitor

So what is stopping you other than yourself?

I’m not the OP, but my answer is that there’s a big difference between building products and building businesses.

I’ve been programming since 1998 when I was in elementary school. I have the technical skills to write almost anything I want, from productivity applications to operating systems and compilers. The vast availability of free, open source software tools helps a lot, and despite this year’s RAM and SSD prices, hardware is far more capable today at comparatively lower prices than a decade ago and especially when I started programming in 1998. My desktop computer is more capable than Google’s original cluster from 1998.

However, building businesses that can compete against Big Tech is an entirely different matter. Competing against Big Tech means fighting moats, network effects, and intellectual property laws. I can build an awesome mobile app, but when it’s time for me to distribute it, I have to either deal with app stores unless I build for a niche platform.

Yes, I agree that it’s never been easier to build competing products due to the tools we have today. However, Big Tech is even bigger today than it was in the past.

Yes. I have seen the better product lose out to network effects far too many times to believe that a real mass market competitor can happen nowadays.

Look at how even the Posix ecosystem - once a vibrant cluster of a dozen different commercial and open source operating systems built around a shared open standard - has more or less collapsed into an ironclad monopoly because LXC became a killer app in every sense of the term. It’s even starting to encroach on the last standing non-POSIX operating system, Windows, which now needs the ability to run Linux in a tightly integrated virtual machine to be viable for many commercial uses.

Oracle Solaris and IBM AIX are still going. Outside of enterprises that are die hard Sun/Oracle or IBM shops, I haven't seen a job requiring either in decades. I used to work with both and don't miss them in the least.

Billions of dollars?

You don't need billions of dollars to write an app. You need billions of dollars to create an independent platform that doesn't give the incumbent a veto over your app if you're trying to compete with them. And that's the problem.

I really am very thankful for @simonw posting a TikTok from Chris Ashworth, a Baltimore theater software developer, who recently picked up LLM's for building a voxel display software controller. And who was just blown away. https://simonwillison.net/2026/Jan/30/a-programming-tool-for...

Simon doesn't touch on my favorite part of Chris's video though, which is Chris citing his friend Jesse Kriss. This stuck out at me so hard, and is so close to what you are talking about:

> The interesting thing about this is that it's not taking away something that was human and making it a robot. We've been forced to talk to computers in computer language. And this is turning that around.

I don't see (as you say) a personality. But I do see the ability to talk. The esoteria is still here underneath, but computer programmers having this lock on the thing that has eaten the world, being the only machine whisperers around, is over. That depth of knowledge is still there and not going away! But notably too, the LLM will help you wade in, help those not of the esoteric personhood of programmers to dive in & explore.

I retired a few years ago, so I have no idea what AI programming is.

But I mourned when CRT came out, I had just started programming. But I quickly learned CRTs were far better,

I mourned when we moved to GUIs, I never liked the move and still do not like dealing with GUIs, but I got used to it.

Went through all kinds of programming methods, too many to remember, but those were easy to ignore and workaround. I view this new AI thing in a similar way. I expect it will blow over and a new bright shiny programming methodology will become a thing to stress over. In the long run, I doubt anything will really change.

I think you're underestimating what AI can do in the coding space. It is an extreme paradigm shift. It's not like "we wrote C, but now we switch to C++, so now we think in objects and templates". It's closer to the shift from assembly to a higher level language. Your goal is still the same. But suddenly you're working in a completely newer level of abstraction where a lot of the manual work that used to be your main concern is suddenly automated away.

If you never tried Claude Code, give it s try. It's very easy to get I to. And you'll soon see how powerful it is.

> But suddenly you're working in a completely newer level of abstraction where a lot of the manual work that used to be your main concern is suddenly automated away.

It's remarkable that people who think like this don't have the foresight to see that this technology is not a higher level of abstraction, but a replacement of human intellect. You may be working with it today, but whatever you're doing will eventually be done better by the same technology. This is just a transition period.

Assuming, of course, that the people producing these tools can actually deliver what they're selling, which is very much uncertain. It doesn't change their end goal, however. Nor the fact that working with this new "abstraction" is the most mind numbing activity a person can do.

I agree with this. At a higher level of abstraction, you’re still doing the fundamental problem solving. Low-level machine language or high-level Java, C++ or even Python, the fundamental algorithm design is still entirely done by the programmer. LLMs aren’t being used to just write the code unless the user is directing how each line or at least each function is being written, often times you can just describe the problem and it solves it most of the way if not entirely. Only for really long and complex tasks do the better models really require hand-holding and they are improving on that end rapidly.

That’s not a higher level of abstraction, it’s having someone do the work for you while doing less and less of the thinking as well. Someone might resist that urge and consistently guide the model closely but that’s probably not what the collective range of SWEs who use these models are doing and rapidly the ease of using these models and our natural reluctance to take on mental stress is likely to make sure that eventually everyone lets LLMs do most or all of the thinking for them. If things really go in that direction and spread, I foresee a collective dumbing down of the general population.

OT but I see your account was created in 2015, so I'm assuming very late in your career. Curious what brought you to HN at that time and not before?

I did not know it existed before 2015 :)

[dead]

[flagged]

I'm actually extremely good at programming. My point is I love computers and computing. You can use technology to achieve amazing things (even having fun). Now I can do much more of that than when I was limited to what I can personally code. In the end, it's what computers can do that's amazing, beautiful, terrifying... That thrill and to be on the bleeding edge is always what I was after.

The downside is that whatever you (Claude) can do so can anyone else too.

So you're welcome to make the 100000000th Copy of the same thing that nobody cares about anymore.

It's so easy to build things that I don't need anyone to care about it, I just need to the computer to do what I want it to do.

[flagged]

Thank you. I don't understand how people don't see that this is the universe's most perfect gift to corporations, and what a disaster it is for labor. There won't be a middle class. Future generations will be intellectual invalids. Baffling to see people celebrating.

it is a very, very strange thing to witness

even if you can be a prompt engineer (or whatever it's called this week) today

well, with the feedback you're providing: you're training it to do that too

you are LITERALLY training the newly hired outsourced personnel to do your job

but this time you won't be able to get a job anywhere else, because your fellow class traitors are doing exactly the same thing at every other company in the world

They are the useful idiots buying into the hype thinking they by some magic they get to keep their jobs and their incomes.

This things is going to erase careers and render skills sets and knowledge cultivated over decades worthless.

Anyone can promt the same fucking shit now and call it a day.

If you were confident in your own skills, you wouldn’t need to invent a whole backstory just to discredit someone.

One thing that I realized was that a lot of our so-called "craft" is converged "know-how". Take the recent news that Anthropic used Claude Code to write a C compiler for example, writing compiler is hard (and fun) for us humans because we indeed need to spend years understanding deeply the compiler theory and learning every minute detail of implementation. That kind of learning is not easily transferrable. Most students tried the compiler class and then never learned enough, only a handful few every year continued to grow into true compiler engineers. Yet to our AI models, it does not matter much. They already learned the well-established patterns of compiler writing from the excellent open-source implementations, and now they can churn out millions of code easily. If not perfect, they will get better in the future.

So, in a sense our "craft" no longer matters, but what really happens is that the repetitive know-how has become commoditized. We still need people to do creative work, but what is not clear is how many such people we will need. After all, at least in short term, most people build their career by perfecting procedural work because transferring the know-how and the underlying whys is very expensive to human. For the long term, though, I'm optimistic that engineers just get an amazing tool and will use it create more opportunities that demand more people.

I'm not sure we can draw useful conclusions from the Claude Code written C compiler yet. Yes, it can compile the Linux kernel. Will it be able to keep doing that moving forward? Can a Linux contributor reliably use this compiler to do their development, or do parts of it simply not work correctly if they weren't exercised in the kernel version it was developed against? How will it handle adding new functionality? Is it going to become more-and-more expensive to get new features working, because the code isn't well-factored?

To me this doesn't feel that many steps above using a genetic algorithm to generate a compiler that can compile the kernel.

If we think back to pre-AI programming times, did anyone really want this as a solution to programming problems? Maybe I'm alone in this, but I always thought the problem was figuring out how to structure programs in such a way that humans can understand and reason about them, so we can have a certain level of confidence in their correctness. This is super important for long-lived programs, where we need to keep making changes. And no, tests are not sufficient for that.

Of course, all programs have bugs, but there's a qualitative difference between a program designed to be understood, and a program that is effectively a black box that was generated by an LLM.

There's no reason to think that at some point, computers won't be able to do this well, but at the very least the current crop of LLMs don't seem to be there.

> and now they can churn out millions of code easily.

It's funny how we suddenly shifted from making fun of managers who think programmer's should be measured by the number of lines of code they generated, to praising LLMs for the same thing. Why did this happen? Because just like managers, programmers letting LLMs write the code aren't reading and don't understand the output, and therefore the only real measure they have for "productivity" is lines of code generated.

Note that I'm not suggesting that using AI as a tool to aid in software development is a bad thing. I just don't think letting a machine write the software for us is going to be a net win.

writing a C compiler is a 1st year undergrad project

C was explicitly designed to make it simple to write a compiler

These are toy compilers missing many edge cases. You’ll be lucky if they support anything other than integer types, nevermind complex pointer-to-pointer-to-struct-with-pointers type definitions. They certainly won’t support GNU extensions. They won’t compile any serious open source project, nevermind the Linux kernel.

Which university offers compiler for freshmen? Can you provide a link to the course?

Third or fourth, maybe, not first.

The craft is still there just like painting is still an alternative to a photograph. It's just not going to be valued by society anymore, and far fewer will learn how to do it. Natural language is the new programming language. For now, understanding the craft is still an edge in making better prompts, but already I can see that telling Antigravity "now look for ways to make this more efficient" works almost as well as guiding it specifically on how it had duplicated some code flows.

I do feel a kind of personal loss in the sense that society is in the process of stopping to value or admire the design and coding skill I've cultivated since I was 6yo. At the same time, I'm kind of thrilled that I can write a detailed readme.md and tell an agent to "make it so" and I can iterate to a utility program in 20 minutes instead of an hour. When I feel a pit in my stomach is when that utility program uses some framework that I haven't learned, and don't need to because their code worked perfectly the first time. Surely that means I'm going to basically stop learning the details, as the details I've accumulated over my life quickly begin to not matter anymore.

Honestly I'm planning to use AI to make a kick-ass retro development environment a la "Sending Modern Languages Back to 1980s Game Programmers" (https://prog21.dadgum.com/6.html) and spend my retirement having fun in it.

Natural language is not a programming language. Programming is precision. Natural language is fuzzy.

>> spend my retirement having fun in it.

People who have reaped the rewards of their careers tend not to be the ones concerned about their futures. Apathy.

Even if I were retired and financially set now, that would mean nothing in 10 years if an unemployed society collapses around me. Apathy is not on the menu today.

>People who have reaped the rewards of their careers tend not to be the ones concerned about their futures. Apathy.

Not everyone has to become a programmer, people at the start of their careers can chooses paths other than programming if they're afraid of the (lack of) future prospects from AI. Where did people work before the ZIRP boom? Those industries are still around. Plenty of STEM related jobs besides programing.

Did society actually value those skills before? Maybe companies or individuals did, but giving coded instructions to computers was seen by most as wizardry at best and geeky at worst. Unfortunately, I feel society values tackling and home run hitting, superficial beauty, and wealth, far more than technical skills.

LLMs are only a threat if you see your job as a code monkey. In that case you're likely already obsoleted by outsourced staff who can do your job much cheaper.

If you see your job as a "thinking about what code to write (or not)" monkey, then you're safe. I expect most seniors and above to be in this position, and LLMs are absolutely not replacing you here - they can augment you in certain situations.

The perks of a senior is also knowing when not to use an LLM and how they can fail; at this point I feel like I have a pretty good idea of what is safe to outsource to an LLM and what to keep for a human. Offloading the LLM-safe stuff frees up your time to focus on the LLM-unsafe stuff (or just chill and enjoy the free time).

I see my job as having many aspects. One of those aspects is coding. It is the aspect that gives me the most joy even if it's not the one I spend the most time on. And if you take that away then the remaining part of the job is just not very appealing anymore.

It used to be I didn't mind going through all the meetings, design discussions, debates with PMs, and such because I got to actually code something cool in the end. Now I get to... prompt the AI to code something cool. And that just doesn't feel very satisfying. It's the same reason I didn't want to be a "lead" or "manager", I want to actually be the one doing the thing.

You won't be prompting AI for the fun stuff (unless laying out boring boilerplate is what you consider "fun"). You'll still be writing the fun part - but you will be able to prompt beforehand to get all the boilerplate in place.

If you’re writing that much boilerplate as part of your day to day work, I daresay you’re Doing Coding Wrong. (Virtue number one of programming: laziness. https://thethreevirtues.com)

Any drudgework you repeat two or three times should be encapsulated or scripted away, deterministically.

Funny how people complain about macros as an abstraction mechanism, but replacing them with an LLM is fine.

Nevermind coding where is the llm for legal stuff? Why are all these programmers working on automating their job away instead of those bloodsucking lawyers who charge hundreds of eur per h.

They are, you probably just aren't hearing about it. There's been loads of cases over the past few years where lawyers use AI to automate their legal research, then get admonished by the judge because their court filings contain fake quotes or reference court cases that don't even exist. A few examples: https://calmatters.org/economy/technology/2025/09/chatgpt-la... https://natlawreview.com/article/judge-issues-public-admonit... https://websitedc.s3.amazonaws.com/documents/Mezu_v._Mezu_US...

It’s happening as fast for them. I literally sit next to our general counsel all day at the office. We work together continually. I show him things happening in engineering, and each time he shows me the analogous things happening in legal.

This affects everyone.

Why is that safe in the medium to long term? If LLMs can code monkey already after just 4 years, why assume in a couple more they can’t talk to the seniors’ direct report and get requirements from them? I’m learning carpentry just in case.

There are many tens (hundreds?) of billions of dollars being poured into the smartest minds in the world to push this thing forward

I'm not so confident that it'll only be code monkeys for too long

Until they can magically increase context length to such a size that can conveniently fit the whole codebase, we're safe.

It seems like the billions so far mostly go to talk of LLMs replacing every office worker, rather than any action to that effect. LLMs still have major (and dangerous) limitations that make this unlikely.

Models do not need to hold the whole code base in memory, and neither do you. You both search for what you need. Models can already memorize more than you !

> Models do not need to hold the whole code base in memory, and neither do you

Humans rewire their mind to optimize it for the codebase, that is why new programmers takes a while to get up to speed in the codebase. LLM doesn't do that and until they do they need the entire thing in context.

And the reason we can't do that today is that there isn't enough data in a single codebase to train an LLM to be smart about it, so first we need to solve the problem that LLM needs billions of examples to do a good job. That isn't on the horizon so we are probably safe for a while.

Getting up to speed is a human problem. Computers are so fast they can 'get up to speed' from scratch for every session, and we help them with AGENTS files and newer things like memories; e.g., https://code.claude.com/docs/en/memory

It is not perfect yet but the tooling here is improving. I do not see a ceiling here. LSPs + memory solve this problem. I run into issues but this is not a big one for me.

I’ll believe it when coding agents can actually make concise & reusable code instead of reimplementing 10 slightly-different versions of the same basic thing on every run (this is not a rant, I would love for agents to stop doing that, and I know how to make them - with proper AGENTS.md that serves as a table of contents for where stuff is - but my point is that as a human I don’t need this and yet they still do for now).

In my experience they can definitely write concise and reusable code. You just need to say to them “write concise and reusable code.” Works well for Codex, Claude, etc.

Writing reusable code is of no use if the next iteration doesn’t know where it is and rewrites the same (reusable) code again.

I guide the AI. If I see it produce stuff that I think can be done better, I either just do it myself or point it in the right direction.

It definitely doesn't do a good job of spotting areas ripe of building abstractions, but that is our job. This thing does the boring parts, and I get to use my creativity thinking how to make the code more elegant, which is the part I love.

As far as I can tell, what's not to love about that?

If you’re repeatedly prompting, I will defer to my usual retort when it comes to LLM coding: programming is about translating unclear requirements in a verbose (English) language into a terse (programming) language. It’s generally much faster for me to write the terse language directly than play a game of telephone with an intermediary in the verbose language for it to (maybe) translate my intentions into the terse language.

In your example, you mention that you prompt the AI and if it outputs sub-par results you rewrite it yourself. That’s my point: over time, you learn what an LLM is good at and what it isn’t, and just don’t bother with the LLM for the stuff it’s not good at. Thing is, as a senior engineer, most of the stuff you do shouldn’t be stuff that an LLM is good at to begin with. That’s not the LLM replacing you, that’s the LLM augmenting you.

Enjoy your sensible use of LLMs! But LLMs are not the silver bullet the billion dollars of investment desperately want us to believe.

> as a senior engineer, most of the stuff you do shouldn’t be stuff that an LLM is good at to begin with

Your use of the word "should" is pointing to some ideal that doesn't exist anymore.

In current actual reality, you do whatever your employer gives you to do, regardless of your job title.

If you have 40 years of broad development experience but your boss tells you to build more CRUD web apps or start looking for another job in the current ATS hell, then the choice whether to use coding agents seems obvious to me.

I think the point is that if you're building yet-another-CRUD web app, why aren't you abstracting more of it away already? It's not like we don't have the facilities for this in programming languages already.

The main issue with current LLM hypers is the complete unrealistic scenarios they come up with. When building a CRUD app, the most obvious solution is to use a framework to take care of the common use cases. And such framework will have loads of helpers and tools to speed up boilerplate.

> Thing is, as a senior engineer, most of the stuff you do shouldn’t be stuff that an LLM is good at to begin with.

That doesn't seem realistic to me.

> programming is about translating unclear requirements in a verbose (English) language into a terse (programming) language

Why are we uniquely capable of doing that, but an LLM isn't? In plan mode I've been seeing them ask for clarifications and gather further requirements

Important business context can be provided to them, also

An LLM isn’t (yet?) capable of remembering a long-term representation of the codebase. Neither is it capable of remembering a long-term representation of the business domain. AGENTS.md can help somewhat but even those still need to be maintained by a human.

But don’t take it from me - go compete with me! Can you do my job (which is 90% talking to people to flesh out their unclear business requirements, and only 10% actually writing code)? It so, go right ahead! But since the phone has yet to stop ringing, I assume LLMs are nowhere there yet. Btw, I’m helping people who already use LLM-assisted programming, and reach out to me because they’ve reached their limitations and need an actual human to sanity-check.

We are uniquely capable of doing that because we invented that :) It’s a self-serving definition, a job description.

This isn’t an argument against LLMs capability. But the burden of proof is on the LLMs’ side.

True. That capability might be reserved for AGI. The current implementation does feel like a party trick and I don't enjoy working with it

I don't think the context size matters really.

https://www.smart-words.org/jokes/project-tree-swing.png

> the smartest minds in the world

Dunning–Kruger is everywhere in the AI grift. People who don't know a field trying to deploy some AI bot that solves the easy 10% of the problem so it looks good on the surface and assumes that just throwing money (which mostly just buys hardware) will solve it.

They aren't "the smartest minds in the world". They are slick salesmen.

The other day someone referred to Claude Code as “the most complex terminal app” they’ve seen.

Meanwhile folks are rendering videos in the terminal.

And if you didn't know, Claude Code is actually based on React and they are struggling to keep it at 60 FPS, whatever that means in the context of a terminal app

They are writing markup to render monospaced characters in a terminal lol

[dead]

Agreed. Programming languages are not ambiguous. Human language is very ambiguous, so if I'm writing something with a moderate level of complexity, it's going to take longer to describe what I want to the AI vs writing it myself. Reviewing what an AI writes also takes much longer than reviewing my own code.

AI is getting better at picking up some important context from other code or documentation in a project, but it's still miles away from what it needs to be, and the needed context isn't always present.

LLMs are a threat to the quality of code in a similar - but much more dramatic - way to high level languages and Electron. I am slightly worried about keeping a job if there's a downturn, but I'm much more worried about my job shifting into being the project manager for a farm of slop machines with no taste and a complete inability to learn.

I think it’s naive to think that not every part of our jobs will worryingly soon be automated. All the way up to and inckuding CEO. This is not exciting.

I see what these can do and I'm already thinking, why would I ever hire a junior developer? I can fire up opencode and tell it to work multiple issues at once myself.

The bottleneck becomes how fast you can write the spec or figure out what the product should actually be, not how quickly you can implement it.

So the future of our profession looks grim indeed. There will be far fewer of us employed.

I also miss writing code. It was fun. Wrangling the robots is interesting in its own way, but it's not the same. Something has been lost.

> why would I ever hire a junior developer

Because a junior developer doesn't stay a junior developer forever. The value of junior developers has never been the code they write. In fact, in my experience they're initially a net negative, as more senior developers take time to help them learn. But it's an investment, because they will grow into more senior developers.

You hire the junior developer because you can get them to learn your codebase and business domain at a discount, and then reap their productivity as they turn senior. You don’t get that with an LLM since it only operates on whatever is in its context.

(If you prefer to hire seniors that’s fine too - my rates are triple that of a junior and you’re paying full price for the time it takes me learning your codebase, and from experience it takes me at least 3 months to reach full productivity.)

> then reap their productivity as they turn senior

What companies are retaining employees long enough for this?

Plenty of places, actually. Maybe not so much in the companies people here tend to be familiar with. It happens all the time where I work (smaller company far from the Bay area).

Yes. And I'm excited as hell.

But I also have no idea how people are going to think about what code to write when they don't write code. Maybe this is all fine, is ok, but it does make me quite nervous!

That is definitely a problem, but I would say it’s a problem of hiring and the billion-dollars worth of potential market cap resting on performative bullshit that encourages companies to not hire juniors to send a signal to capture some of those billions regardless of actual impact on productivity.

LLMs benefit juniors, they do not replace them. Juniors can learn from LLMs just fine and will actually be more productive with them.

When I was a junior my “LLM” was StackOverflow and the senior guy next to me (who no doubt was tired of my antics), but I would’ve loved to have an actual LLM - it would’ve handled all my stupid questions just fine and freed up senior time for the more architectural questions or those where I wasn’t convinced by the LLM response. Also, at least in my case, I learnt a lot more from reading existing production code than writing it - LLMs don’t change anything there.

"They can write code better than you or I can"

They can not. They can make some average code. On Friday one suggested an NSI installer script that would never bundle some needed files in the actual installer. I can only imagine that a lot of people have made the same mistake (used CopyFiles instead of File) and posted that mistake on the internet. The true disaster of that being that then testing out that installer on the developer's PC, where that CopyFiles may well work fine since the needed files happen to be sitting on that PC, would then lead on to think it was some weird bug that only failed on the end user's PC. I bet a lot of people posted it with comments like "this worked fine when I tried it," and here we are a decade later feeding that to an LLM.

These tools can write average code. That's what they've mostly been fed; that's what they're aiming for when they do their number crunching. The more specifically one prompts, I expect, then the more acceptable that average code will be. In some cases, average appears to be shockingly bad (actually, based on a couple of decades' experience in the game, average is generally pretty bad - I surely must have been churning out some average, bad code twenty years ago). If I want better than average, I'm going to have to do it myself.

So it can write better code than your below average software engineer.

It still cuts out 40-50% of workforce out.

For above average engineers its very good.

For bottom half not so much.

Translate for Mgrs - it replaces offshore completely.

And it will run rings around me in all the languages I don't know; every case in which my standard would be shockingly bad (I speak no APL whatsoever, for example) it would do better (in some cases, though, it would confidently produce an outcome that was actually worse than my null outcome).

The "below average" engineers are largely the juniors and the programming non-programmers.

The juniors can't be replaced because all senior engineer were once junior.

The non-programmers won't be replaced because they are not really programmers to begin with, so there is nothing to replace.

You left out the key line “and you don’t believe me, wait six months”. These models are getting better all the time. The term “vibe coding” was only coined a year ago, around the same time as the release of Claude Code.

It doesn’t matter if you don’t think it’s good yet, because it’s brand new tech and it keeps improving.

Agree with the author. I like the process of writing code, typing method names and class definitions while at the same time thinking ahead about overall architecture, structure, how much time given function would run for, what kind of tests are necessary.

I find it unsettling how many people in the comments say that they don't like writing code. Feels aliens to me. We went into this field for seemingly very different reasons.

I do use LLMs and even these past two days I was doing vibe coding project which was noticeably faster to setup and get to its current state than if I wrote in myself. However I feel almost dirty by how little I understand the project. Sure, I know the overall structure, decisions and plan. But I didn't write any of it and I don't have deep understanding of the codebase which I usually have when working on codebase myself.

It's not so much the writing of the code (which I did like), it's the aesthetic of the code. It's solving a problem with the right code and the right amount of code (for now). That's still the case, even with AI writing most of the code. You have to steer it constantly because it has very bad instincts, because most people in the profession aren't good at it, so it has bad training data. Mainly because the "learn to code" movement and people getting into this profession just for the money and not the love. Those people are probably screwed.

I feel like most of the anxiety around LLMs is because (in the USA at least) our social safety net sucks.

I'd probably have way more fun debating LLMs if it wasn't tied to my ability to pay rent, have healthcare, or feel like a valued person contributing something to society. If we had universal healthcare and a federal job guarantee it would probably calm things down.

Yes that's why most of the excited folks are VCs and software engineers who made their wealth already

What's more interesting is how the big names in our industry, the ones who already made their money as you say, have turned quickly since the end of 2025. I think even the most old school names can see that the writing is on the wall now.

While I'm on the fence about LLMs there's something funny about seeing an industry of technologists tear their own hair out about how technology is destroying their jobs. We're the industry of "we'll automate your job away". Why are we so indignant when we do it to ourselves...

This article isn't really about losing a job. Coding is a passion for some of us. It's similar to artists and diffusion, the only difference being that many people can appreciate human art - but who (outside of us) cares that a human wrote the code?

I love programming, but most of that joy doesn't come from the type of programming I get paid to do. I now have more time and energy for the fun type, and I can go do things that were previously inconceivable!

Last night "I" "made" 3D boids swarm with directional color and perlin noise turbulence. "I" "did" this without knowing how to do the math for any of those things. (My total involvement at the source level was fiddling with the neighbor distance.)

https://jsbin.com/ququzoxete/edit?html,output

Then I turned them into weird proteins

https://jsbin.com/hayominica/edit?html,output

(As a side note, the loss of meaning of "self" and "doing" overlaps weirdly with my meditation practice...)

Yes but did you learn anything?

Haven't done much more with the boids yet (though I imagine if I continue, I will learn a thing or two!) but I have an example from another domain.

Shell scripting was something that I failed to get any real traction with for decades, and since letting AI help me write dozens of shell scripts, I find that I have gained a basic level of proficiency. (i.e. I found that I had become relatively fluent in writing them even without assistance, which surprised me!)

It ties in with the Input Hypothesis of language acquisition. More volume in = more opportunities for brain to find the patterns, and learn them naturally.

That doesn't work for the approach where you don't look at the code at all, though. Which seems to depend on your goals for the project.

For the boids thing, the math isn't something I enjoy doing manually anyway (I've done that for the last 15 years and it always felt like pulling teeth), so the main learning I'd get there would be at the applied level... How to tweak the Perlin noise to get the result I want, rather than how or why it works in the first place.

Obviously that matters, but how much does it matter? Does it matter if you don't learn anything about computer architecture because you only code in JS all day? Very situational.

There's a subset of people whose identity is grounded in the fact that they put in the hard work to learn things that most people are unable or unwilling to do. It's a badge of honor, and they resent anyone taking "shortcuts" to achieve their level of output. Kind of reminds me of lawyers who get bent out of shape when they lose a case to a pro se party. All those years of law school and studying for the bar exam, only to be bested by someone who got by with copying sample briefs and skimming Westlaw headnotes at a public library. :)

It's not that our identity is grounded in being competent, it's that we're tired of cleaning up messes left by people taking shortcuts.

It's that, but it's also that the incentives are misaligned.

How many supposed "10x" coders actually produced unreadable code that no one else could maintain? But then the effort to produce that code is lauded while the nightmare maintenance of said code is somehow regarded as unimpressive, despite being massively more difficult?

I worry that we're creating a world where it is becoming easy, even trivial, to be that dysfunctional "10x" coder, and dramatically harder to be the competent maintainer. And the existence of AI tools will reinforce the culture gap rather than reducing it.

It's a societal problem we are just seeing the effects in computing now. People have given up, everything is too much, the sociopaths won, they can do what they want with my body mind and soul. Give me convenience or give me death.

I think this is really it. Being a musician was never a very reliable way to earn a living, but it was a passion. A genuine expression of talent and feeling through the instrument. And if you were good enough you could pay the bills doing work work for studios, commercials, movies, theater. If you were really good you could perform as a headliner.

Now, AI can generate any kind of music anyone wants, eliminating almost all the anonymous studio, commercial, and soundtrack work. If you're really good you can still perform as a headliner, but (this is a guess) 80% of the work for musicians is just gone.

> AI can generate any kind of music anyone wants

It only sounds like music.

At least for this article it's more about the job, or to be precise, the past where job and passion coincided:

> Ultimately if you have a mortgage and a car payment and a family you love, you’re going to make your decision.

Nothing is preventing the author from continuing to write code by hand and enjoy it. The difference is that people won't necessarily pay for it.

The old way was really incredible (and worth mourning), considering in other industries, how many people can only enjoy what they do outside of work.

The people outside of us didn’t care about your beautiful code before. Now we can quickly build their boring applications and spend more time building beautiful things for our community’s sake. Yes, there are economic concerns, but as far as “craft” goes, nothing is stopping us from continuing to enjoy it.

I'd add part of the craft is enjoying those minutiae, sharing lessons, and stories with others. The number of people you can do that with is going to dwindle (and has been for a long time from the tech sphere's coopting of all of it). That's part that I mourn.

Except that's not really true, because the work expands to fill the time allotted. Now we can build more boring applications with fewer people.

Yes, it is true that companies are always hungry for more. But once again, those same companies never cared about beautiful code. They wanted us to build something that works as quickly as possible. In my experience, the beauty of programming was often enjoyed outside of work for this very reason, and we can still enjoy it outside of work for it's own sake.

I disagree a bit. Coding can remain an artistic passion for you indefinitely, it's just your ability to demand that everyone crafts each line of code artisinally won't be subsidized by your employer for much longer. There will probably always be a heavily diminished demand for handcrafted code.

> Coding is a passion for some of us.

It's a passion for me too, but LLMs don't change this for me. Do they change it for you?

Huge tangent but curiosity is killing me: By any chance is your username based on the Egyptian football club Zamalek?

Is coding a passion only because other people appreciate it?

Is painting a passion because others appreciate it? No, it is a passion in itself.

There will always be people appreciating coding by hand as a passion.

My passions - drawing, writing, coding - are worthwhile in themselves, not because other people care about them. Almost noone does.

How do you read this article and hear indigence? It’s clearly someone grieving something personal about their own relationship with the technology.

It may not be a reaction to the article itself but to the many comments in this thread and others that fall under that category.

I never thought or felt myself as or my work as someone or something that "will automate your job away".

Agreed. I've always thought the purpose of all automation was to remove needless toil. I want computers to free people. I guess I subscribe to the theory of creative destruction.

Maybe it comes down to the definition of "toil". Some people find typing to be toiling, so they latch on to not having to type as much when using LLMs. Other people see "chores" as toiling, and so dream of household robots to take on the burden of that toil. Some people hate driving and consider that to be needless toil, so self-driving cars answer that—and the ads for Waymo latch onto this.

Personally, I am not stymied by typing nor chores nor driving. For me, typing is like playing a musical instrument: at some point you stop needing to think about how to play and you just play. The interaction and control of the instrument just comes out of your body. At some point in my life, all the "need to do things around the house" just became the things I do, and I'm not bothered by doing them, such that I barely notice doing them. But it's complex: the concept of "chores" is front and center when you're trying to get a teenager to be responsible for taking care of themselves (like having clean clothes, or how the bathroom is safer if it's not a complete mess) and participating in family/household responsibilities (like learning that if you don't make a mess, there's nothing to clean up). Can you really be effective at directing someone/something else without knowing how to do it yourself? Probably for some things, but not all.

> Maybe it comes down to the definition of "toil".

For sure.

I idealize a future where people can spend more time doing things they want to do, whatever those avocations might be. Freedom from servitude. I guess some kind of Star Trek / The Culture hybrid dream.

The world we have is so far from that imaginary ideal. Implicit in that ideal would be elimination of inequality, and I'm certain there are massive forces that would oppose that elimination.

And not just the definition, but the assumption that a specific toil is necessarily universal. I've had more than one conversation that started with someone else saying "using the LLM saves me soooo much time typing, think of how much time typing you'd save by using an LLM". But when I examine my processes and where I'm spending my time, typing isn't even on my list, so this claim is talking right past me and I can't see it all. Even when I was a hunt-and-peck typer on the c64 I didn't consider the typing to be a/the major factor in how long something took to program so much so that I continued with two-finger typing until I was forced to take a touch-typing class in highschool (back when that was still a thing, and we split the exercises between typewriters and computers).

"I'm able to put my shirt on so much faster with this shirt-buttoning machine, and I don't spend time tediously buttoning shirts and maybe having to rebutton when I misalign the buttons and buttonholes. You should get one to button your shirts, you're wasting time by not using a buttoning machine".

"I wear t-shirts."

(Obviously a contrived and simplistic example for fun)

Computers are definitely on the path to freeing programmers from programming

I'm very confident in saying the majority of developers didn't get into it saying "we'll automate your job away"

POSIWID

"We" might be such an industry, but I'm not. My focus has always been on creating new capabilities, particularly for specialists in whatever field. I want to make individuals more powerful, not turn them into surplus.

For me it's because the same tech is doing it to everyone else in a more effective way (i.e. artists especially). I'm an "art enjoyer" since I was a child and to see it decimated by people who I once looked up to is heartbreaking. Also, if it only affected software, I would've been happy to switch to a more artistic career, but welp there goes that plan.

I feel very similarly, I always thought of software engineering as being my future career. I'm young, I just really got my foot into the industry in my early twenties. It feels like the thing I wanted to do died right when I was allowed to start. I also always felt that if I didn't get to do development, I would try to get into arts which has always been a dream of mine, and now it feels that that died, too. I wish I was born just a little bit earlier, so that I had a bit more time. :(

Yeah, the thing that’s different about this technical revolution compared to the previous ones is that it’s not only trying to take out multiple industries, but the creative process as a whole.

Per the "About Me" picture, this particular technologist does not have any hair to tear out.

I do not mourn.

For my whole life I’ve been trying to make things—beautiful elegant things.

When I was a child, I found a cracked version of Photoshop and made images which seemed like magic.

When I was in college, I learned to make websites through careful, painstaking effort.

When I was a young professional, I used those skills and others to make websites for hospitals and summer camps and conferences.

Then I learned software development and practiced the slow, methodical process of writing and debugging software.

Now, I get to make beautiful things by speaking, guiding, and directing a system which is capable of handling the drudgery while I think about how to make the system wonderful and functional and beautiful.

It was, for me, never about the code. It was always about making something useful for myself and others. And that has never been easier.

I like coding, I really do. But like you, I like building things more than I like the way I build them. I do not find myself miss writing code by hand as much.

I do find it that the developers that focused on "build the right things" mourn less than those who focused on "build things right".

But I do worry. The main question is this - will there be a day that AI will know what are "the right things to build" and have the "agency" (or illusion of) to do it better than an AI+human (assuming AI will get faster to the "build things right" phase, which is not there yet)

My main hope is this - AI can beat a human in chess for a while now, we still play chess, people earn money from playing chess, teaching chess, chess players are still celebrated, youtube influencers still get monetized for analyzing games of celebrity chess players, even though the top human chess player will likely lose to a stockfish engine running on my iPhone. So maybe there is hope.

> will there be a day that AI will know what are "the right things to build" and have the "agency" (or illusion of) to do it better than an AI+human (assuming AI will get faster to the "build things right" phase, which is not there yet)

Of course, and if LLMs keep improving at current rates it will happen much faster than people think.

Arguably you don't need junior software engineers anymore. When you also don't need senior software engineers anymore it isn't that much of a jump to not needing project managers, managers in general or even software companies at all anymore.

Most people, in order to protect their own ego, will assume *their* job is safe until the job one rung down from them disappears and then the justified worrying will begin.

People on the "right things to build" track love to point out how bad people are at describing requirements, so assume their job as a subject matter expert and/or customer-facing liaison will be safe, but does it matter how bad people are at describing requirements if iteration is lightning fast with the human element removed?

Yes, maybe someone who needs software and who isn't historically some sort of software designer is going to have to prompt the LLM 250 times to reach what they really want, but that'll eventually still be faster than involving any humans in a single meeting or phone call. And a lot of people just won't really need software as we currently think about it at all, they'll just be passing one-off tasks to the AI.

The real question is what happens when the labor market for non-physical work completely implodes as AI eats it all. Based on current trends I'm going to predict in terms of economics and politics we handle it as poorly as possible leading to violent revolution and possible societal collapse, but I'd love to be wrong.

> The real question is what happens when the labor market for non-physical work completely implodes as AI eats it all. Based on current trends I'm going to predict in terms of economics and politics we handle it as poorly as possible leading to violent revolution and possible societal collapse, but I'd love to be wrong.

Exactly and the world has to start talking about it. Eventually everybody will, including all sorts of politicians who advocate to 'finally tackle the problem', which will be too late.

> I do find it that the developers that focused on "build the right things" mourn less than those who focused on "build things right".

I've always been strongly in the first category, but... the issue is that 10x more people will be able to build the right things. And if I build the right thing, it will be easy to copy. The market will get crowded, so distribution will become even harder than it is today. Success will be determined by personal brand, social media presence, social connections.

> Success will be determined by personal brand, social media presence, social connections.

Always has been. (Meme)

For me, photography is the metaphor - https://raskie.com/post/we-have-ai-at-home - We've had the technology to produce a perfect 2D likeness of a subject for close to two centuries now, and people are still painting.

Video didn't kill the radio star either. In fact the radio star has become more popular than ever in this, the era of the podcast.

Art, photography, acting, music - none of them are good career choices. You'll either be one of the fortunate few, or you'll struggle to make a living. Sucks but that's how it is.

While what you're saying is true, I think it is important to recognize that painting in a way that generates a livable income is mostly a marketing gig.

Likewise, being a podcaster, or "influencer" in general, is all about charisma and marketing.

So with value destruction for knowledge workers (and perhaps physical workers too once you factor in robotics) we may in fact be moving into a real "attention economy" where all value is related to being a charismatic marketer, which will be good for some people for a while, terrible for the majority, but even for the winners it seems like a limited reprieve. Historically speaking charismatic marketers can only really exist through the patronage of people who mostly aren't themselves charismatic marketers. Without patrons (who have disposable income to share) the charismatic marketers are eventually just as fucked as everyone else.

> will there be a day that AI will know what are "the right things to build" and have the "agency" (or illusion of) to do it better than an AI+human

I share this sentiment. It's really cool that these systems can do 80% of the work. But given what this 80% entails, I don't see a moat around that remaining 20%.

I can't explain it in a way that will make sense or base it on any data, but I do see that moat all the time. For example, Microsoft / GitHub somehow taking a 3 year lead (with Co-Pilot) and losing it to Cursor in months, and still catching up.

Microsoft / GitHub have no real limitation to doing better/faster, maybe it's the big company mentality, moving slower, fear of taking risks where you have a lot to lose, or when the personal incentive for a product manager at github is much much lower than the one of a co-founder of a seed stage startup. Co-Pilot was a microscopic line item for Microsoft as a whole, and probably marginal for GitHub too. But for Cursor, this was everything.

This is why we have innovation, if mega-corps didn't promote people to their level of incompetence, if bureaucracy and politics didn't ruin every good thing, if private equity didn't bleed every beloved product to the last penny, we would have no chance for any innovation or entrepreneurship because these company have practically close to unlimited resources.

So my only conclusion from this is - the moat is sometimes just the will to do better, to dare to say, I don't care if someone has a billion dollars to compete with me, I'll still do better.

In other words, don't underestimate the power of big companies to make colossal mistakes and build crappy products. My only worry is, that AI would not make the same mistakes an we'll basically have a handful of companies in the world (the makers of models, owner of tokens e.g. OpenAI, Anthropic, Google, Amazon, Meta, xAi), if AI led product teams will be able to not make the mistakes of modern corporations of ruining everything good that they got in their hands, then maybe software related entrepreneurship will be dead.

> The main question is this - will there be a day that AI will know what are "the right things to build"

What makes you think AI already isn't at the same level of quality or higher for "build the right things" as it is for "building things right"?

Computers are better at chess. Humans invented chess and enjoy it.

I think humans have the advantage.

  >  "build the right things" [vs] "build things right"

If I build my own table no one really gives a shit about the quality besides me and maybe my friends judging me.

But if I sell it, well then people certainly care[0] and they have every right to.

If I build my own deck at my house people do also care and there's a reason I need to get permits for this, because the danger it can cause to others. It's not a crazy thing to get your deck inspected and that's really all there is to it.

So I don't get these conversations because people are just talking past one another. Look, no one gives a fuck if you poorly vibe code your personal website, or at least it is gonna be the same level as building your own table. But if Ikea starts shipping tables with missing legs (even if it is just 1%) then I sure give a fuck and all the customers have a right to be upset.

I really think a major part of this concern with vibe coding is about something bigger. It is about slop in general. In the software industry we've been getting sloppier and sloppier and LLMs significantly amplify that. It really doesn't matter if you can vibe code something with no mistakes, what matters is what the businesses do. Let's be honest, they're rushing and don't care about quality because they have markets cornered and consumers are unable to accurately evaluate products prior to purchase. That's the textbook conditions for a lemon market. I mean the companies outsource tech support so you call and someone picks up who's accent makes you suspicious of their real name being "Steve". After all, it is the fourth "Steve" you've talked to as you get passed around from support person to support person. The same companies who contract out coders from poor countries and where you find random comments in another language. That's the way things have been going. More vaporware. More half baked products.

So yeah, when you have no cake the half baked cake is probably better than nothing. At home it also doesn't matter if you're eating a half baked cake or one that competes with the best bakers in the world. But for everyday people who can't bake their own cakes, what do they do? All they see is a box with a cake in it, one is $1, another for $10, and another other is $100. They look the same but they can't know until they take a bite. You try enough of the $1 cakes and by the time you give up the $10 cakes are all gone. By the time you get so frustrated you'll buy the $100 cake they're gone too.

I don't dislike vibe coding because it is "building things the wrong way" or any of that pretentious notion. I, and I believe most people with a similar opinion, care because "the right things" aren't being built. Most people don't care how things were built, but they sure do care about the result. Really people only start caring about how the sausage is made when they find out that something distasteful is being served and concealed from them. It's why everyone is saying "slop".

So when people make this false dichotomy it just feels like people aren't listing to what's actually being said.

[0] Mind you, it is much easier for an inexperienced person to judge the quality of a table than software. You don't need to be a carpenter to know a table's leg is missing or that it is wobbly but that doesn't always hold true for more sophisticated things like software or even cars. If you haven't guessed already, I'm referencing lemon markets: https://en.wikipedia.org/wiki/The_Market_for_Lemons

Of course. I mean, my view is that it needs to be "build the right things right", vs "build things right and then discover if they are the right things". It's a stab at premature optimisation, focusing on code elegance more than delivering working software. Code simplicity, good design, scalability, are super important for maintainability, even in the age of AI (maybe even more so).

But considering that AI will more and more "build things right" by default, it's up to us humans to decide what are the "right things to build".

Once AI knows what are the "right things to build" better than humans, this is AGI in my book, and also the end of classical capitalism as we know it. Yes, there will still be room for "human generated" market, like we have today (photography didn't kill painting, but it made it a much less of a main employment option)

In a way, AI is the great equality maker, in the past the strongest men prevailed, then when muscles were not the main means to assert force, it was the intellect, now it's just sheer want. You want to do something, now you can, you have no excuses, you just need to believe it's possible, and do it.

As someone else said, agency is eating the world. For now.

  >  it needs to be "build the right things right", vs "build things right and then discover if they are the right things"

  > But considering that AI will more and more "build things right" by default

I'm with Dijkstra because, like him, I believe we invented symbolic formalism for a reason. Like him, I believe that abstraction is incredibly useful and powerful, but it is about the right abstraction for the job.

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

[1] https://news.ycombinator.com/item?id=46928421

[2] At the end of the day, that's what they are. Even if they produce code you're still treating it as a transpiler: turning natural language into code.

[3] Okay, technically it does but that's because probability has to do with this[4] and I'm trying to communicate better and most people aren't going to connect the dots (pun intended) between function mapping and probabilities. The lack of precision is inherently representable through the language of probability but most people aren't familiar with terms like "image" and "pre-image" nor "push-forward" and "pull-back". The pedantic nature of this note is precisely illustrative of my point.

[4] https://www.mathsisfun.com/sets/injective-surjective-bijecti...

> The reason I'm not in favor of natural language programming has nothing to do with its probabilistic nature and everything to do with its lack of precision

Yeah, even if they're made to be 100% deterministic, you've now got a programming language whose rules are deterministic, but hard to understand. You've effectively pinned the meaning of the natural language in some way, but not a way that anyone can effectively learn, and one that doesn't necessarily match their understanding of the actual natural language.

And it's weird that this even needs to be argued given that our long explanations are needed to even convey fairly simple concepts. Not to mention that it still relies upon correct interpretation.

The result of natural language programming is either an extremely limited programming language or an extremely verbose one (again, look at law). Presumably it'll result in both.

It's a nice idea but ignores the reason we invented symbolic languages in the first place. They were invented after natural language. It's not like code is some vestigial language raiment. We're trying to replace it because it's hard and annoying. But I'm certain that's mainly due to the level of abstraction we're trying to work with more than due to the language we're using

I've seen a hundred ai-generated things, and they are rarely interesting.

Not because the tools are insufficient, it's just that the kind of person that can't even stomach the charmed life of being a programmer will rarely be able to stomach the dull and hard work of actually being creative.

Why should someone be interested in you creations? In what part of your new frictionless life would you've picked up something that sets you apart from a million other vibe-coders?

> stomach the dull and hard work of actually being creative

This strikes me as the opposite of what I experience when I say I'm "feeling creative", then everything comes easy. At least in the context of programming, making music, doing 3D animation and some other topics. If it's "dull and hard work" it's because I'm not feeling "creative" at all, when "creative mode" is on in my brain, there is nothing that feels neither dull nor hard. Maybe it works differently for others.

What sets you apart from millions of manual programmers?

I've been a professional programmer for 8+ years now. I've stomached that life. I've made things people used and paid for.

If I can do that typing one line at a time, I can do it _way_ faster with AI.

You may be mistaking some ai dev with non, because it doesn't have tell tails

Many AI generated web sites have a “look” and it’s not just all the emojis.

>It was, for me, never about the code.

Then it wasn't your craft.

Isn't this like saying that if better woodworking tools come out, and you like woodworking, that woodworking somehow 'isn't your craft'. They said that their craft is about making things.

There are woodworkers on YouTube who use CNC, some who use the best Festool stuff but nothing that moves on its own, and some who only use handtools. Where is the line at which woodworking is not their craft?

The better analogy is you're now a shop manager or even just QA. You don't need to touch, look at, or think about the production process past asking for something and seeing if the final result fits the bill.

You get something that looks like a cabinet because you asked for a cabinet. I don't consider that "woodworking craft", power tools or otherwise.

I'm pretty sure at least the better woodworking shop managers and QA people all have experience with woodworking and probably would also consider this their craft if asked.

If it looks like a cabinet, works as a cabinet and doesn’t fall apart, by all intents and purposes it’s a cabinet. 99% of people out there won’t care if it was a “craftsman” or a robot built it. Just like most people buy furniture at Ikea.

The difference is that the person who was a woodworker is no longer needed. Why can’t the customer just walk up to a kiosk and ask the machine to start building? The machine or another one specialized for QA can then assess if it fits all the technical requirements which the customer doesn’t necessarily understand. This is what most people here are worried about, eventually the professional human being will no longer be needed by businesses which can produce everything with neither customer nor business owner being in need of specialized knowledge which they previously needed to acquire by hiring professionals.

The only confusion is in the use of the term "woodworking".

For the power tool user, "woodworking with hand tools" isn't their craft.

For the CNC user, "woodworking with manual machines" isn't their craft.

The analogy you're making is that wiring a taskrabbit to assemble Ikea furniture is woodworking.

There's a market for Ikea. It's put woodworkers out of business, effectively. The only woodworkers that make reasonable wages from their craft are influencers. Their money comes from YouTube ads.

There's no shame in just wanting things without going to the effort of making them.

Love this extension of the analogy, particularly. Especially because, like a woodworker inspecting IKEA assembled by a taskrabbit, the craftsmanship of a finished product becomes less and less impressive the longer you inspect it

It's feeling much closer to hiring a woodworker to make you something, not woodworking tools

I think a better comparison is painting and photography. Prior to the invention of photography, painting portraits of individuals and families was a real profession. Today it’s practically unheard of outside of heads of state and the like. Sure, there are plenty of people who could afford to commission a painted portrait but few do when a quick session in a photographer’s studio is so much cheaper and more convenient.

Woodworking is, like, the quintessential craft. I think it is very useful to bring it in when discussion "craft"!

I am not myself a woodworker, however I have understood that part of what makes it "crafty" is that the woodworker reads grain, adjusts cuts, and accepts that each board is different.

We can try to contrast that to whatever Ikea does with wood and mass production of furniture. I would bet that variation in materials is "noise" that the mass production process is made to "reject" (be insensitive to / be robust to).

But could we imagine an automated woodworking system that takes into account material variation, like wood grain, not in an aggregate sense (like I'm painting Ikea to do), but in an individual sense? That system would be making judgements that are woodworker-like.

The craft lives on. The system is informed by the judgement of the woodworker, and the craftperson enters an apprenticeship role for the automation... perhaps...

Until you can do RL on the outcome of the furniture. But you still need craft in designing the reward function.

Perhaps.

[dead]

Yeah, seems like too many went into this field for money or status not because they like the process. Which is not an issue by itself, but now these people talk about how their AI assistant of choice made them some custom tool in two hours that would have taken them three weeks. And it's getting exhausting.

That is an insane assumption to make based on the grandparents' post. What part of them talking about how much they care about the systems thinking and software architecture and usefulness and meaningfulness to other people of software over the day-to-day drudgery of APIs and bugs and typing in syntax indicates to you that they only care about money and status? They just care about a different part of the process.

I went into this field because I love programming. I didn't even know how well these jobs paid until my junior year of college when I got an internship at AWS. I constantly programmed and read programming texts in my spare time growing up, in college, and after work.

I love AI tools. I can have AI do the boring parts. I can even have to write polished, usable apps in languages that I don't know.

I miss being able to think so much about architecture, best practices, frameworks/languages, how to improve, etc.

> many went into this field for money

I went into this field for both! what do i do now, i'm screwed

It is a different kind of code. Just a lot of programmers can’t grock it as such.

I guess I started out as a programmer, then went to grad school and learned how to write and communicate my ideas, it has a lot in common with programming, but at a deeper level. Now I’m doing both with AI and it’s a lot of fun. It is just programming at a higher level.

I’m going to be thinking about this comment for a while—-and I think you’re basically right.

Almost none of the code I wrote in 2015 is still in use today. Probably some percentage of people can point to code that lasted 20 years or longer, but it can’t be a big percentage. When I think of the work of a craft, I think of doing work which is capable of standing up for a long time. A great builder can make a house that can last for a thousand years and a potter can make a bowl that lasts just as long.

I’ve thought of myself as a craftsman of code for a long time but maybe that was just wrong.

That's just gatekeeping.

It was and is my craft. I've been doing it since grade 5. Like 30 years now.

Writing tight assembly for robot controllers all the way to AI on MRI machines to security for the DoD and now the biggest AI on the planet.

But my craft was not typing. It's coding.

If you're typist you're going to mourn the printer. But if you're a writer you're going to see how the improves your life.

A big component to coding is typing. If you aren't doing the typing, then, unless you are dictating code to someone else to mechanically, verbatim type out for you, you are not coding.

I do believe directing an LLM to write code, and then reviewing and refining that code with the LLM, is a skill that has value -- a ton of value! -- but I do not think it is coding.

It's more like super-technical product management, or like a tech lead pair programming with a junior, but in a sort of mentorship way where they direct and nudge the junior and stay as hands-off as possible.

It's not coding, and once that's the sum total of what you do, you are no longer a coder.

You can get defensive and call this gatekeeping, but I think it's just the new reality. There's no shame in admitting that you've moved to a stage of your life where you build software but your role in it isn't as a coder anymore. Just as there's no shame in moving into management, if that's what you enjoy and are effective at it.

(If presenting credentials is important to you, as you've done, I've been doing this since 1989, when I was 8 years old. I've gone down to embedded devices, up through desktop software, up to large distributed systems. Coding is my passion, and has been for most of my life.)

Assembling code doesn't require typing. Linking doesn't require typing.

Even though once upon a time both did.

Claiming that this isn't coding is as absurd as saying that coding is only what you do when you hook up the wires between some vacuum tubes.

The LLM is a very smart compiler. That's all.

Some people want to sit and write assembly. Good for them. But asserting that unless I assemble my own code I'm not a coder is just silly.

Right, there is a non-zero overlap between the VIM Andy's and AI nay-sayers.

No true programmer is excited for the future.

And no true scotsman puts sugar in his porridge

Yes, that was the reference!

Possibly too obscure. I can't tell whether I'm being downvoted by optimists who missed the joke, or by pessimists who got it.

Most sarcasm worsens discussion. And the comment guidelines say Don't be snarky.[1]

[1] https://news.ycombinator.com/newsguidelines.html

Haha, I downvoted you from the first category (until I read this comment).

[dead]

What is the definition of a true programmer.

Maybe the age of programmers is over and this is the age of builders.

this is so true.

never once in my life i saw anything get better. except for metal gear solid psx and gears of wars

As someone who started with Borland DOS-era IDEs I can tell you that IDEs did get a lot better over the years. I'm still fascinated every day by JetBrains IDEs.

> I'm still fascinated every day by JetBrains IDEs.

have you used them recently?

terrible, is the word I would use

(as a customer since the 2010s)

so much garbage ego in statements like this. if you really knew about software, you'd recognize there are about a million ways to be successful in this field

I love building things too, but for me, the journey is a big part of what brings me joy. Herding an LLM doesn't give me joy like writing code does. And the finished project doesn't feel the same when my involvement is limited to prompting an LLM and reviewing its output.

If I had an LLM generate a piece of artwork for me, I wouldn't call myself an artist, no matter how many hours I spent conversing with the LLM in order to refine the image. So I wouldn't call myself a coder if my process was to get an LLM to write most/all the code for me. Not saying the output of either doesn't have value, but I am absolutely fine gatekeeping in this way: you are not an artist/coder if this is how you build your product. You're an artistic director, a technical product manager, something of that nature.

That said, I never derived joy from every single second of coding; there were and are plenty of parts to it that I find tedious or frustrating. I do appreciate being able to let an LLM loose on some of those parts.

But sparing use is starting to really only work for hobby projects. I'm not sure I could get away with taking the time to write most of it manually when LLMs might make coworkers more "productive". Even if I can convince myself my code is still "better" than theirs, that's not what companies value.

Well said. This sums up my own feeling. I joined this craft and love this craft for the simple ability to build beautiful and useful things.

This new world makes me more effective at it.

And this new world doesn’t prevent me from crafting elegant architectures either.

Wait 5 years and your skills are down

I don't think 5 years is necessary. I think after two years of this agentic orchestration if you rarely touch code yourself skill will degrade to the point they won't be able to write anything non-trivial without assistance.

Depends how long you've done it, and how much the landscape has changed since then. I can still hop back into SQL and it all comes back to me though I haven't done it regularly at all for nearly 10 years.

In the web front-end world I'd be pretty much a newbie. I don't know any of the modern frameworks, everything I've used is legacy and obsolete today. I'd ramp up quicker than a new junior because I understand all the concepts of HTTP and how the web works, but I don't know any of the modern tooling.

How much do you think Linus Torvalds has coded over the last decade? Why is he still able to do his job?

His job is reviewing.

https://github.com/torvalds

It won't be 5 years, it'll be less than a year. When you don't exercise, your muscles atrophy. It's the same for any other skill. I use to speak conversational french in college, fast forward 10 years later and my understanding is no different than a casual "Emily in Paris" fan.

It'll be the same here, the only question is if those that do exercise will be able to command better salaries. I think this is possible but not with the current political climate.

In 5 years coding skills will matter as much as being able to operate an elevator. (sadly)

What infrastructure has gone through the last 15 years would like a word.

Half the people I work with can't do imperative jQuery interfaces. So what I guess. I can't code assembly.

A programming language is still an additional language with all the benefits of being multilingual.

AI will kill that.

> Now, I get to make beautiful things by speaking, guiding, and directing a system which is capable of handling the drudgery while I think about how to make the system wonderful and functional and beautiful.

For how long do you think this is sustainable? In the sense of you, or me, or all these other people here being able to earn a living. Six months? A couple of years? The time until the next-but-one Claude release drops?

Does everyone have to just keep re-making themselves for whatever the next new paradigm turns out to be? How many times can a person do that? How many times can you do that?

For your custom definition of sustainable, perhaps not.

but this is definitely generally sustainable. by 2030 we're fully agentic coding for everything, and it's going to sustain.

I want to be in your camp, and am trying hard. But the OP's blog entry should at least give us a moment to "respect the dead". That's all he's asking, I think.

Adam Neely has a video on GenAI and it's impact on the music industry. There is a section in the video about beauty and taste and it's pretty different from your conclusions. One example I remember is would an AI find beauty in a record scratch sound?

https://youtu.be/U8dcFhF0Dlk

This is the best description of value from AI that I've seen so far. It allows people who don't like writing code to build things without doing so.

I don't think it's nearly as valuable to people who do enjoy writing code, because I don't think prompting an agent (at least in their current state) is actually more productive than just writing the code. So I don't see any reason to mourn on either side.

> For my whole life I’ve been trying to make things—beautiful elegant things.

Why did you stop? Because, you realize, LLMs are giving up the process of creating for the immediacy of having. It's paying someone to make for you.

Things are more convenient if you live the dream of the LLM, and hire a taskrabbit to run your wood shop. But it's not you that's making.

> For my whole life I’ve been trying to make things—beautiful elegant things.

Me too, but... The ability to code was a filter. With AI, the pool of people who can build beautiful elegant software products expands significantly. Good for the society, bad for me.

AI agents seem to be a powerful shortcut to the drudgery. But let's not forget, that powerful software rests on substance. My hope is the substance will increase, after all.

So when you "learned software development and practiced the slow, methodical process of writing and debugging software", it wasn't about code? I don't get it. Yes, building useful things is the ultimate goal, but code is the medium through which you do it, and I don't understand how that cannot be an important part of the process.

It's like a woodworker saying, "Even though I built all those tables using precise craft and practice, it was NEVER ABOUT THE CRAFT OR PRACTICE! It was about building useful things." Or a surgeon talking about saving lives and doing brain surgery, but "it was never about learning surgery, it was about making people get better!"

I mean sure yeah but also not really.

Not the GP I feel some of that energy. The parts I most enjoy are the interfaces, the abstractions, the state machines, the definitions. The code I enjoy too, and I would be sad to lose all contact with it, but I've really appreciated AI especially for helping me get over the initial hump on things like:

- infrastructure bs, like scaffold me a JS GitHub action that does x and y.

- porting, like take these kernel patches and adjust them from 6.14 to 6.17.

- tools stuff, like here's a workplace shell script that fetches a bunch of tokens for different services, rewrite this from bash to Python.

- fiddly things like dealing with systemd or kubernetes or ansible

- fault analysis, like here's a massive syslog dump or build failure, what's the "real" issue here?

In all these cases I'm very capable of assessing, tweaking, and owning the end result, but having the bot help me with a first draft saves a bunch of drudgery on the front end, which can be especially valuable for the ADHD types where that kind of thing can be a real barrier to getting off the ground.

But this just makes me feel like it's literally more ABOUT the code than less. The comment I replied to makes it seem like "code" and "solving humanity's problems" are two different things, when in reality, one leads to the other (if we assume you're working on good products, etc.).

It's one thing to have your approach where you're using AI to help w/ the code, but it's totally another to pretend like "code" is not something you were ever interested in, so it's okay for the AI to write it while you're busy "solving problems," which doesn't make a lot of sense to me.

In my opinion the relationship between level of detailed care and resulting beauty is proportional. Can you get the same level without getting your hands dirty? Sure, maybe, but I doubt a painter or novelist could really produce beautiful work without being intimately familiar with that work. The distance that heavy use of AI tools creates between you and the output does not really lend itself to beauty. Could you do it, sure, but at that point it's probably more efficient to just do things yourself and have complete intimate control.

To me, you sound more utilitarian. The philosophy you are presenting is a kind of Ikea philosophy. Utility, mass production, and unique beauty are generally properties that do not cohere together, and there's a reason for this. I think the use of LLMs in the production of digital goods is very close to the use of automation lines in the production of physical goods. No matter how you try some of the human charm, and thus beauty will inevitably be lost, the number of goods will increase, but they'll all be barely differentiable souless replications of more or less the same shallow ideas repeated as infinitum.

I agree, LLMs definitely sand off a lot of personality, and you can see it in writing the most, at this point I'm sure tons of people are subconsciously trained to lower the trust for something where they recognize typical patterns.

With the code, especially interfaces, the results will be similar -- more standardized palettes, predictable things.

To be fair, the converging factor is going on pretty much forever, e.g. radio/TV led to the lots of local accents disappearing, our world is heavily globalized.

only the true artist will survive the advent of LLMs

But why would someone pay you for that?

So many people responding to you with snarky comments or questioning your programming ability. It makes me sad. You shared a personal take (in response to TFA which was also a personal take). There is so much hostility and pessimism directed at engineers who simply say that AI makes them more productive and allows them to accomplish their goals faster.

To the skeptics: by all means, don't use AI if you don't want to; it's your choice, your career, your life. But I am not sure that hitching your identity to hating AI is altogether a good idea. It will make you increasingly bitter as these tools improve further and our industry and the wider world slowly shifts to incorporate them.

Frankly, I consider the mourning of The Craft of Software to be just a little myopic. If there are things to worry about with AI they are bigger things, like widespread shifts in the labor force and economic disruption 10 or 20 years from now, or even the consequences of the current investment bubble popping. And there are bigger potential gains in view as well. I want AI to help us advance the frontiers of science and help us get to cures for more diseases and ameliorate human suffering. If a particular way of working in a particular late-20th and early-21st century profession that I happen to be in goes away but we get to those things, so be it. I enjoy coding. I still do it without AI sometimes. It's a pleasant activity to be good at. But I don't kid myself that my feelings about it are all that important in the grand scheme of things.

I couldn't agree more.

If AI can do the coding, those of us who aren't programmers don't need you anymore. We can just tell the AI what we want.

Luckily for real programmers, AI's not actually very good at generating quality code. It generates the equivalent of Ali Baba code: it lasts for one week and then breaks.

This is going to be the future of programming: low-paid AI clerks to generate the initial software, and then the highly paid programmers who fix all the broken parts.

Yes. The problem is there is a huge invisible gap between "looks like it works" and "actually works", and everything that entails, like security and scaling beyond a couple users. Non-programmers and inexperienced ones will have trouble with those gaps. Welcome to our slop filled future.

It's been here since it's inception. The more the market grew and the more computing became widespread, the greater the number of ravenous sociopaths with other people's money got involved. This is just another version of Rome burning. This is the terminal acceleration phase. The lunatics are running everything to the ground and the few sane people left are labeled the same way they always had been. The useful idiots are just thinking they're so much smarter. Noone asked if it is wise or not, they are thinking they can outrun the treadmill. Just add water and LLM, it's so much fun for the whole family.

But you don’t make.

You order it.

Because such people are not sincere either to themselves about who they are or to others. It's really hard for me to take seriously phrases like "I joined this industry to make things, not to write code".

Do painters paint because they just like to see the final picture? Or do they like the process? Yes, painting is an artistic process, not exactly crafting one. But the point stand.

Woodworkers making nice custom furniture generally enjoy the process.

Right.

It's like learning to cook and regularly making your own meals, then shifting to a "new paradigm" of hiring a personal chef to cook for you. Food's getting made either way, but it's not really the same deal.

No, it's more like moving from line cook, to head chef in charge of 30 cooks.

Food's getting made, but you focus on the truly creative part -- the menu, the concept, the customer experience. You're not boiling pasta or cutting chives for the thousandth time. The same way now you're focusing on architecture and design now instead of writing your 10,000th list comprehension.

Except the cooks don't exist anymore as they all have become head chefs (or changed careers) and the food is being cooked by magical cooking black boxes

Sure, but the point is you're now doing the most creative and satisfying part. Not the drudgery.

It's not that you've stopped doing anything at all, like the other commenter claimed in their personal chef analogy.

Would you consider drudgery the in-depth thinking that's required to actually go and write that algorithm, think out all the data ownership relationships, name the variables, think the edge cases for the tests?

For me, the act of sitting down and writing the code is what actually leads to true understanding of the logic, in a similar way to how the only way to understand a mathematical proof is to go trough it. Sure, I'm not doing anything useful by showing that the root of 2 is irrational, but by doing that I gain insights that are otherwise impossible to transfer between two minds.

I believe that coding was one of the few things (among, for example, writing math proofs, or that weird process of crafting something with your hands where the object you are building becomes intimately evident) that get our brains to a higher level of abstraction than normal mammal "survival" thinking. And it makes me very sad to see it thrown out of the window in the name of a productivity that may not even be real.

> Would you consider drudgery the in-depth thinking that's required to actually go and write that algorithm, think out all the data ownership relationships, name the variables, think the edge cases for the tests?

For 99% of the functions I've written in my life? Absolutely drudgery. They're barely algorithms. Just bog-standard data transformation. This is what I love having AI replace.

For the other 1% that actually requires original thought, truly clever optimization, and smart naming to make it literate? Yes, I'll still be doing that by hand, although I'll probably be getting the LLM to help scaffold all the unit tests and check for any subtle bugs or edge cases I may have missed.

The point is, LLMs let me spend more time at the higher level of abstraction that is more productive. It's not taking it away!

I do agree with this, and in fact I do often use LLMs for for these tasks! I guess my message is more intended towards vibe-only coders (and, I guess, the non-technical higher ups drooling at the idea of never having to hire another developer).

I see junior PM types glowing about being able to lead teams of agents, doing their bidding without putting up a fuss or argument. Short term, developers are in for a world of hurt. Long term, we're going to need a lot more to clean this crap up.

Noone will clean it up, it's a societal problem. The koolaid is produce more, like we need another app for X . We are celebrating owning nothing, as a liberating act. People hate mental load yes, this is the perfect drug. You don't need to think or challenge anything. If the model says it's okay, it's okay. Local models will never be able to democratise this. People will do as they are told, and another generation of consumers will follow. The matrix won't be a prison, it will be a prompt from birth to death. And y'all clapping cause you can have X number of agents running around burning tokens like kids looking at the fire cracker on their hand about to blow up, giggling. The world was always mad, and this is proof it will always be mad while people are still around.

I think there is room for a hybrid approach. You can delegate most of the "drudgery" to AI, but keep the parts that require creative solutions for yourself. There is undoubtedly a lot of crappy work we have to do as engineers. This is stuff that needs to be done but has also been done many times before.

I think unless you're vibe coding, it's pretty clear that they're still making it. Just because you aren't literally typing 100% of the characters that make up the syntax of the programming language you're using doesn't mean you're not making the final product in most meaningful sentences if you're designing the architecture, the algorithms, the data structures, the state machines, the interfaces, etc, and thinking about how they interact and whether they'll do something that's useful for the people you're making it for.

The transition is from author to editor/publisher. Both play an important role in bringing something new into the world.

It's true, but ask an author and 99% of them will say they don't want to be an editor.

[dead]

These comments are comical. How hard is it to understand that human beings are experiential creatures. Our experiences matter, to survival, to culture, and identity.

I mourn the horse masters and stable boys of a century past because of their craft. Years of intuition and experience.

Why do you watch a chess master play, or a live concert, or any form of human creation?

Should we automate parts of our profession? Yes.

Should he mourn the loss of our craft. Also yes.

Very well put.

Two things are true at the same time, this makes people uneasy.

In fact, contrary things are so very often both true at the same time, in different ways.

Figuring out how to live in the uncomfortableness of non-absolutes, how to live in a world filled with dualisms, is IMO one of the primary and necessary maturities for surviving and thriving in this reality.

Yes. Unwillingness to accept contradicting data points is holding many people back. They have an unconscious need to always pick one or the other, and that puts them at a disadvantage. "I know what I think." But no, you do not.

> They can write code better than you or I can, and if you don’t believe me, wait six months.

How many 6-month periods do we have to go through before we can all admit that this isn't actually the case?

Not that many, as the new crop of junior devs grows up not writing and barely reading code.

My fear is management saying: "here are two juniors and a Claud, now produce output of 10 seniors". It is not working out? You must be using it wrong. You don't want the juniors? Too bad.

"Wait 6 months" has been the call for 3-4 years now. You can't eulogize a profession that hasn't been killed, that's just mean.

This is what I don't really understand. It's a bit difficult to take "wait x months" at face value because I've been hearing it for so long. Wait x months for what? Why hasn't it happened yet?

Things seem to be getting better from December 2022 (chatgpt launch), sure, but is there a ceiling we don't see?

"Self-driving cars" and Fusion power also come to mind. With the advent of photography, it was widely believed that drawing and painting would vanish as art forms. Radio would obsolete newspapers, becoming obsolete themselves with television, and so on. Don't believe the hype.

My car has driven me back and forth with no issues for 6 months now. But yes it's been a long time coming.

And yet.. my car was surrounded by 5 self-driving cars with no people in them on the way to work on Thursday.

And your ability to go your own way is only temporary and due to inertia. Today, for a while, you can still buy a vehicle that requires a driver and doesn't look and perform exactly like every other waymo.

But that's only because self driving cars are still new and incomplete. It's still the transition period.

I already can't buy the car I want with a manual transmission. There are still a few cars that I could get with one, but the number is both already small and getting smaller every year. And none of those few are the one I want, even though it was available previously.

I already can't buy any (new) car that doesn't have a permanent internet connection with data collection and remote control by people that don't own the car even though I pay full cash without even financing, let alone the particular one I want. (I can, for now, at least break the on board internet connection after I buy the car without disabling the whole car, but that is just a trivial software change away, in software I don't get to see or edit.)

It's hardly unreasonable to suggest that in some time you won't be able to avoid having a car that drives itself, and even be legally compelled to let the car drive itself because you can't afford the insurance or legal risk or straight up fines.

And forget customizing or personalizing. That's right out.

I think the decline of manual transmission is different from self-driving. Manuals, you could argue are a technological progression that doesn’t change the fundamental economics or sociology of driving. But self-driving has issues far beyond the technology. Like liability, like ownership of vehicles, availability, traffic rules,…

I’m not even sure if, outside of highly mapped environments it even makes sense.

> And forget customizing or personalizing. That's right out.

Don’t panic, it’s only one additional subscription away. /s

Waymos require a highly mapped environment to function safely in. Not to take away from what Waymo has accomplished, but it's a far more bounded problem that what the "self driving" promise has been.

And they still rely on human operators for some maneuvers, as we learned this week.

Just like in "I, Robot?"

Um.. Claude Code has been out less than a YEAR.. and the lift in capability in the last year has been dramatic.

It does seem probable based on progress that in 1-2 more model generations there will be little need to hand code in almost any domain. Personally I already don't hand code AT ALL, but there are certainly domains/languages that are under performing right now.

Right now with the changes this week (Opus 4.6 and "teams mode") it already is another step function up in capability.

Teams mode is probably only good for greenfield or "green module" development but I'm watching a team of 5 AI's collaborating and building out an application module by module. This is net new capability for the tool THIS WEEK (Yes I am aware of earlier examples).

I don't understand how people can look at this and then be dismissive of future progress, but human psychology is a rich and non-logical landscape.

Because then you won't be important, the model will be important. And then everyone will have to use their model, that's their dream. Why isn't that your nightmare too? Why will you be special if it can just code whatever it needs to code? Then anthropic can just employ all the programmers that will ever be needed, to just review new skills and modules of code. It was predicted early on there would be a need for about six big computers worldwide. Well now we'll just need six AI shepherds. And then literally everyone else will forget how anything works because it will be a solved problem. People already treat computers like magic, it will literally become a dark art. And I guess it's fine, what can we do, right? Go with the flow I guess. "If I don't , someone else will. Maybe I can be one of those six real people at Anthropic".

[dead]

Just a couple more trillion dollars, we are so close!

Things have progressed much faster than even the most optimistic predictions, so every "wait 6 months" has come true. Just look at how the discourse has changed on HN. No-one is using the arguments from 6 months ago and any argument today will probably be equally moot in 6 months.

Maybe we should look at output like quality of software being produced instead of discourse on forums where AI companies are spending billions to market?

Where is all this new software and increased software quality from all this progression?

It doesn't necessarily enhance or detract from software quality. You could use it for quality assurance or code health initiatives, but you'd have to prioritize that. Obviously it is hard to find a lot of humans who will (be allowed to) choose that over adding some new feature to satisfy the sales guys. And since you measure quality basically on vibes (how many times has this app crashed lately?) it probably takes a while to diffuse from commit to your consciousness. But I have seen it used for the purpose of quality, so I am cautiously optimistic.

Quality shmuality. Get good bro, my app already uses best patterns and you can do all the things and has enterprise SSO and runs on vercel and needs 39 services and costs a few million to run to show you AI generated excel sheets because you cant be bothered to think for a hot minute. We can't have you thinking you might get wrong ideas about ownership. I'm afraid open source was a mistake in the end because it enabled enterprises to iterate faster than they ever could on their own.

Humans are notoriously bad at predicting the future. We can't even reliably predict the weather a week from now.

If we were as smart as the smartest guys throwing trillions at LLMs we wouldn't be predicting anything, we would be creating it like the gods we were always meant to be ever since someone hurt our feelings irrevocably. Hitler could have been a painter, these guys could be slinging dope for a living but here we are.

But the sentiment has changed significantly over the last 6 months. I think this is the biggest step change in sentiment since ChatGPT 3.5. Someone who said "wait 6 months" 6 months ago would have been "right".

> Now is the time to mourn the passing of our craft.

Your craft is not my craft.

It's entirely possible that, as of now, writing JavaScript and Java frontends (what the author does) can largely be automated with LLMs. I don't know who the author is writing to, but I do not mistake the audience to be "programmers" in general...

If you are making something that exists, or something that is very similar to something that exists, odds are that an LLM can be made to generate code which approximates that thing. The LLM encoding is lossy. How will you adjust the output to recover the loss? What process will you go through mentally to bridge the gap? When does the gap appear? How do you recognize it? In the absolute best case you are given a highly visible error. Perhaps you've even shipped it, and need to provide context about the platform and circumstances to further elucidate. Better hope that platform and circumstance is old-hat.

It's funnily enough quite the opposite front ends that have a focus on UX are pretty well protected from generative AI

I haven't heard this perspective. I'm kind of surprised the LLMs can't generate coherent frontend framework-ized code, if that's the implication.

Both of you are right. They can generate the code quite well, but well-considered UX is another thing entirely.

Strangly, yeah. LLMs are absolute trash at generating good UX and UI.

I was very impressed by AI-generated CSS when I didn't know CSS.

Then I learned CSS.

Now I am not as impressed by AI-generated CSS.

This seems to be a general rule for AI-generated anything. It's impressive in domains you're not an expert in. Much less so on domains you are an expert in.

That's how I felt about human-generated CSS 10 years ago.

This perspective was mine 6 months ago. And god damn, I do miss the feeling of crafting something truly beautiful in code sometimes. But then, as I've been pushed into this new world we're living in, I've come to realize a couple things:

Nothing I've ever built has lasted more than a few years. Either the company went under, or I left and someone else showed up and rewrote it to suit their ideals. Most of us are doing sand art. The tide comes in and its gone.

Code in and of itself should never have been the goal. I realized that I was thinking of the things I build and the problems I selected to work on from the angle of code quality nearly always. Code quality is important! But so is solving actual problems with it. I personally realized that I was motivated more by the shape of the code I was writing than the actual problems it was written to solve.

Basically the entire way I think about things has changed now. I'm building systems to build systems. Thats really fun. Do I sometimes miss the feeling of looking at a piece of code and feeling a sense of satisfaction of how well made it is? Sure. That era of software is done now sadly. We've exited the craftsman era and entered into the Ikea era of software development.

> Nothing I've ever built has lasted more than a few years.

maybe this say something more about your career decisions than anything else?

Maybe? I wasn't just speaking of myself however.

Interesting, I still have code I wrote 20 years ago being used in production.

Theres always exceptions. Congrats!

“Most of us are doing sand art. The tide comes in and it’s gone.”

I’m putting that on my wall.

I agree with the nolanlawson's sentiment. What's interesting is many of the opposing statements here seem to be less interested in the actual code, and more interested in the final state. Both are valid, but one is going away due to technological advancements. That is the mourning.

There are some of us who enjoyed the code as a thing to explore. Others here don't seem to like that as much.

I've never bought into it because like 80% of the work the world does is CRUD-level stuff which should be boring and simple so it can be readable and maintainable.

The craftspeople doing the other 20% of the code are at the top end of the skill spectrum, but AI is starting from the bottom and working its way up. They should be the least worried about AI taking over their output.

This is like throwing together dozens of stick frame homes that look alike vs. building custom log, brick, or stone houses. No one is going to be tearing down my drywall and marveling at how well the studs are spaced.

If AI is good enough that juniors wielding it outproduce seniors, then the juniors are just... overhead. The company would cut them out and let AI report to a handful of senior architects who actually understand what's being built. You don't pay humans to be a slow proxy for a better tool.

If the tools get good enough to not need senior oversight, they're good enough to not need junior intermediaries either. The "juniors with jetpacks outpacing seniors" future is unrealistic and unstable—it either collapses into "AI + a few senior architects" or "AI isn't actually that reliable yet."

Or it collapses when the seniors have to retire anyway. Who instructs the LLM when there’s nobody who understands the business?

I’m sure the plan is to create a paperclip maximizing company which is fully AI. And the sea turned salty because nobody remembered how to turn it off.

> We’ll miss the feeling of holding code in our hands

I agree, I started feeling this a few months ago, where I was only writing the architecture and abstractions and letting AI fill in the gaps. It seems in the next few months it could probably do more than that. But is it so bad, I agree that I can't really mold an entire pot by my hand any more. But, if you ask AI to do it, it will create a pot with cracks in it and it would be your job to either plaster it of fill gold in those cracks.

I feel coding is going to be similar to kintsugi after this is all over

Sort of ironic. My dad coded on hole punch cards and hated it, hated th physicality of that. Now he super loves AI, having left the field 20 years ago due to language fatigue.

Programming brings me joy in two different ways.

1. Crafting something beautiful. Figuring out correct abstractions and mapping them naturally to language constructs. Nailing just the right amount of flexibility, scalability and robustness. Writing self-explanatory, idiomatic code that is a pleasure to read. It’s an art.

2. Building useful things. Creating programs that are useful to myself and to others, and watching them bring value to the world. It’s engineering.

These things have utility but they are also enjoyable onto themselves. As best I can tell, your emotional response to coding agents depends on how much you care about these two things.

AI has taken away the joy of crafting beautiful things, and has amplified the joy of building things by more than 10x. Safe bet: It will get to 100x this year.

I am very happy with this tradeoff. Over the years I grew to value building things much more highly. 20yo me would’ve been devastated.

"They can write code better than you or I can, and if you don’t believe me, wait six months." They've been saying that for years. Stop believing it.

I tried out Claude code for the first time today, and I was a little bit disappointed after all the comments I’ve been reading about it. I didn’t so much notice a speed difference as I did just not having to think very hard while I was working compared to writing everything myself.

Perhaps I’m too opinionated / a micromanager.

Also, it’s always six months from now, because otherwise you could just point at the hundred ways they’re wrong right now. It’s nothing but the ol’ dotcom “trust me, bro” kind of marketing.

> I didn’t ask for the role of a programmer to be reduced to that of a glorified TSA agent, reviewing code to make sure the AI didn’t smuggle something dangerous into production.

This may be the perspective of some programmers. It doesn't seem to be shared by the majority of software engineers I know and read and listen to.

Do you mean the perspective that he is a "glorified TSA agent" or that he doesn't like it? Because in this thread it seems that some people agree but they just like it :)

I disagree the opportunities created for software engineers are reduced to those of a "glorified TSA agent".

We now have more opportunity than ever to create more of the things we have wanted to. We are able to spend more time leaning into our abilities of judgement, creativity, specific knowledge, and taste.

Countless programming frustrations are gone. I, and all those I talk to are having more fun than they have ever had.

I'm still not sure what analogy fits for me. It's closer to product manager/maestro/artist/architect/designer that helps a number of amazing systems create great code.

From a blog post last month by the same author:

> Today, I would say that about 90% of my code is authored by Claude Code. The rest of the time, I’m mostly touching up its work or doing routine tasks that it’s slow at, like refactoring or renaming.

> I see a lot of my fellow developers burying their heads in the sand, refusing to acknowledge the truth in front of their eyes, and it breaks my heart because a lot of us are scared, confused, or uncertain, and not enough of us are talking honestly about it. Maybe it’s because the initial tribal battle lines have clouded everybody’s judgment, or maybe it’s because we inhabit different worlds where the technology is either better or worse (I still don’t think LLMs are great at UI for example), but there’s just a lot of patently unhelpful discourse out there, and I’m tired of it.

https://nolanlawson.com/2026/01/24/ai-tribalism/

If you're responding to this with angry anti-AI rants (or wild AI hype), might want to go read that post.

I often venerate antiques and ancient things by thinking about how they were made. You can look at a 1000-year-old castle and think: This incredible thing was built with mules and craftsmen. Or look at a gorgeous, still-ticking 100-year-old watch and think: This was hand-assembled by an artist. Soon I'll look at something like the pre-2023 Linux kernel or Firefox and think: This was written entirely by people.

This is romanticising the past.

The modal person just trying to get their job done wasn't a software artisan; they were cutting and pasting from Stack Overflow, using textbook code verbatim, and using free and open-source code in ways that would likely violate the letter and spirit of the license.

If you were using technology or concepts that weren't either foundational or ossified, you found yourself doing development through blog posts. Now, you can at least have a stochastic parrot that has read the entire code and documentation and can talk to it.

At least with physical works (for now, anyway), the methods the artisans employ leave tell-tale signs attesting to the manner of construction, so that someone at least has the choice of going the "hand made" route, and others, even lay people without special tooling, can tell that it indeed was hand made.

Fully AI generated code has similar artifacts. You can spot them pretty easily after a bit. Of course it doesn't really matter for the business goals, as long as it works correctly. Just like 99% of people don't care if their clothing was machine made vs. handmade. It's going to be a tiny minority that care about handmade software.

> Fully AI generated code has similar artifacts. You can spot them pretty easily after a bit.

For now. Though I suspect the commit history would probably still be pretty telling.

lol.. the AI actually writes detailed commit message. Unlike me... "Fixed issue with timeout"

> and parrot it back

I don't like this particular phrase, as it suggests that LLMs are just replicating code. As far as I understand, LLMs can also create new code and algorithms (some better than others). When we think of them as copy-paste-maschines, we judge their capabilities unfairly and also underestimate their capabilities.

> They can write code better than you or I can, and if you don’t believe me, wait six months.

You can use AI to write all your code, but if you want to be a programmer and can't see that the code is pretty mid then you should work on improving your own programming skills.

People have been saying the 6 month thing for years now, and while I do see it improving in breadth, quality/depth still appears to be plateauing.

It's okay if you don't want to be a programmer though, you can be a manager and let AI do an okay job at being your programmer. You better be driven to be a good at manager though. If you're not... then AI can do an okay job of replacing you there too.

“We’ll miss creating something we feel proud of”

I still feel proud when skillfully guiding a set of AI agents to build from my imagination. Especially when it was out of my reach just 6-months ago.

I’m a 49 year old veteran who started at just 10 years old and have continued to find pure passion in it.

I wonder if this is just a matter of degree. In a few years (or less) you may not have to "skillfully guide" anything. The agents will just coordinate themselves and accomplish your goals after you give some vague instruction. Will you still feel proud? Or maybe a bit later then agents will come up with their own improvements and just ship them without any input at all. How about then?

Then we can finally turn off the computers and go outside to play with friends.

That requires thinking. Let's just ship now, think later. Does it matter? Show me the money and all that. We will all just ride in the sunset with Butch Cassidy and the Sunset Kid I'm sure.

> Someday years from now we will look back on the era when we were the last generation to code by hand. We’ll laugh and explain to our grandkids how silly it was that we typed out JavaScript syntax with our fingers. But secretly we’ll miss it.

Why will I miss it? I will be coding my small scripts and tools and hobby projects by hand because there is no deadline attached to them. Hell, I will also tag them as "bespoke hand-crafted free range artisanal" code. There will be a whole hipster category of code that is written as such. And people will enjoy it as they enjoy vinyl records now. Many things would have changed by then but my heart will still be a programmer's heart.

Either that or the “bespoke hand-crafted artisanal free-range code” will be the only thing still maintainable because vibe coders made such a mess

Some code is worth transcribing by hand — an ancient practice in writing, art and music.[0] Some isn't even worth looking at.

I find myself, ironically, spending more time typing out great code by hand now. Maybe some energy previously consumed by tedium has been freed up, or maybe the wacky machines brought a bit of the whimsy back into the process for me.

[0] And in programming, for the readers of Zed Shaw's books :)

I do not mourn typing in code.

But I am still quite annoyed at the slopful nature of the code that is produced when you're not constantly nagging it to do better

We've RLed it to produce code that works by hook or by crook, putting infinity fallback paths and type casts everywhere rather than checking what the semantics should be.

Sadly I don't know how we RL taste.

I hope that "our craft" which now produces, largely, vulnerable buggy bloatware actually dies.

Perhaps people or machines will finally figure out how to make software which actually works without a need to weekly patching

Something tells me a non-deterministic code generator won't be the solution to this problem.

Humans are also non-deterministic code generators though. It can be possible that an LLM is more deterministic or consistent at building reliable code than a human.

You're missing the point. Consider this:

Mathematicians use LLMs. Obviously, they don't trust LLM to do math. But LLM can help with formalizing a theorem, then finding a formal proof. It's usually a very tedious thing - but LLMs are _already_ quite good at that. In the end you get a proof which gets checked by normal proof-checking software (not LLM!), you can also inspect, break into parts, etc.

You really need to look into detail rather than dismiss wholesale ("It made a math error so it's bad at math" is wrong.)

Like other tech disrupted crafts before this, think furniture making or farming, that's how it goes. From hand-made craft, to mass production factories (last couple of decades) to fully automated production.

The craft was dying long before LLMs. Started in dotcom, ZIRP added some beatings, then LLMs are finishing the job.

This is fine, because like in furniture making, the true craftsmen will be even more valuable (overseeing farm automation, high end handmade furniture, small organic farms), and the factory worker masses (ZIRP enabled tech workers) will move on to more fulfulling work.

That’s not how it goes for the worker. If you are a capitalist then it doesn’t matter, you own the means of production. The laborer, however, has to learn new skills, which take time and money. If your profession no longer exists, unless you have enough capital to retool/be a capitalist, then you will personally get poorer.

I'm not sure comparing artisanal software to woodworking or organic farming is possible.

With woodworking and farming you get as a result some physical goods. Some John Smith that buys furniture can touch nice cherry paneling, appreciate the joinery and grain. With farming you he can taste delicious organic tomatoes and cucumbers, make food with it.

Would this John Smith care at all about how some software is written as long as it does what he wants and it works reliably? I'm not sure.

Where do people find this optimism? I reckon when the software jobs fall everything else will follow shortly too. That's just the first target because it's what we know and the manual stuff is a little harder for now. The "good news" is everyone might be in the same boat so the system will have to adapt,

Software, and most STEM based jobs, have a lot of determinism and verifiability + some way to reduce the cost of failure so brute force iteration can cover up the remaining. There is often "a correct answer". They've also yet to be truly disrupted until now which makes them particularly vulnerable than any other job.

Most jobs don't have the same level of verification and/or repeatability. Some factors include:

* Physical constraints: Even the jobs that have productive output if they are physical it will take a long time for AI and more importantly energy density to catch up. Robots have a while to go as well - in the end human hands and your metabolism/energy density will be worth more than your brain/intelligence.

* Cost of failure/can't repeat: For things like building the cost of failure is high (e.g. disposal, cleanup, more resources, etc) -> even 70% of a "building bench" benchmark would be completely inadequate without low cost to repeat. Many jobs are also already largely automated but scaled (e.g. mining, manufacturing, etc) - they've already gone through the wave.

* Human need for its own sake: Other jobs cater not just for productive output, but for some human need where it hasn't been made more efficient ever (e.g. care jobs). There are jobs that a human is more effective in the medium term because the receiver needs it from a human.

No -> this just affects white collar STEM based roles. Thinking we are in it together is just another form of "cope" sadly. There's a rational reason why others have optimism while we SWE's are now full of anxiety and dread.

For the people who it doesn't affect given their current place in many societies (nurses, builders, etc etc) there will be little sympathy.

I can relate coz once upon a time I enjoyed reading poetic code - which I later found to be impossible to modify or extend.

> Eventually your boss will start asking why you’re getting paid twice your zoomer colleagues’ salary to produce a tenth of the code.

And then I couldn’t relate because no one ever paid me for lines of code. And the hardest programming I ever did was when it took me 2 days to write 2 lines of C code, which did solve a big problem.

I abhorred the LOC success metric because we had to clean up after those who dumped their code diarrhea to fool those who thought every line of code is added value. Not to mention valuing LOC strictly makes you a junior programmer.

E.g. you have to know more to do the following in 2 lines (yes, you can):

‘’’ t = a; a = b; b = a; ‘’’

According to LOC missionaries these 3 lines are more expensive to write and shows that you’re a better programmer than the XOR swap. But it’s actually more expensive to run it than the XOR swap, and it’s more expensive to hire the person who can write the XOR swap. (Not endorsing clever/cryptic code, just making a point about LOC)

So, if the LOC missionaries are out of a job because of LLMs, I will probably celebrate.

It's the end goal that matters in this context.

Boss that counts LOC will be fired or will bankrupt the company/team.

One of my friend who never lost a touch with coding in hist 30+ years career recently left FAANG and told me it's the best time to realize his dream of building a start up. And it's not because AI can write code for him - it would take him about 12 month to build the system from the ground up manually, but it's the best time because nobody can replicate what he's doing by using AI only. His analogy was "it's like everyone is becoming really good cyclist with electric bikes, even enthusiast cyclists, but you secretly train for Tour de France".

I get the grief about AI, but I don't share it.

After ten years of professional coding, LLMs have made my work more fun. Not easier in the sense of being less demanding, but more engaging. I am involved in more decisions, deeper reviews, broader systems, and tighter feedback loops than before. The cognitive load did not disappear. It shifted.

My habits have changed. I stopped grinding algorithm puzzles because they started to feel like practicing celestial navigation in the age of GPS. It is a beautiful skill, but the world has moved on. The fastest path to a solution has always been to absorb existing knowledge. The difference now is that the knowledge base is interactive. It answers back and adapts to my confusion.

Syntax was never the job. Modeling reality was. When generation is free, judgment becomes priceless.

We have lost something, of course. There is less friction now, which means we lose the suffering we often mistook for depth. But I would rather trade that suffering for time spent on design, tradeoffs, and problems that used to be out of reach.

This doesn't feel like a funeral. It feels like the moment we traded a sextant for a GPS. The ocean is just as dangerous and just as vast, but now we can look up at the stars for wonder, rather than just for coordinates.

So funny because "you’re still riding around on a fixie bike." that's literally what I do. I also take a plane to fly.

In that analogy that would be picking the right library/framework/service vs. vibe coding it. I do NOT need to write all the code to provide value.

Knowing which tool to use for the task is precisely what requires honing a skill and requires judgement. It's not about how many kilometers you manage to cover.

> So as a senior, you could abstain. But then your junior colleagues will eventually code circles around you, because they’re wearing bazooka-powered jetpacks and you’re still riding around on a fixie bike. Eventually your boss will start asking why you’re getting paid twice your zoomer colleagues’ salary to produce a tenth of the code.

I might be mistaken, but I bet they said the same when Visual Basic came out.

I fall in the demographic discussed in the article but I’ve approached this with as much pragmatism as I can muster. I view this as a tool to help improve me as a developer. Sure there will be those of us who do not stay ahead (is that even possible?) of the curve and get swallowed up but technology has had this affect on many careers in the past. They just change into something different and sometimes better. It’s about being willing to change with it.

The blacksmith analogy is poetic but misleading. Blacksmithing was replaced by a process that needed no blacksmith at all. What's happening with code is closer to what synthesizers did to music — the instrument changed, the craft didn't die.

Musicians mourned synthesizers. Illustrators mourned Photoshop. Typesetters mourned desktop publishing. In every case the people who thrived weren't the ones who refused the new tool or the ones who blindly adopted it. They were the ones who understood that the tool absorbed the mechanical layer while the taste layer became more valuable, not less.

The real shift isn't from hand-coding to AI-coding. It's from "I express intent through syntax" to "I express intent through constraints and review." That's still judgment. Still craft. Just a different substrate.

What we're actually mourning is the loss of effort as a signal of quality. When anyone can generate working code, the differentiator moves upstream to architecture, to knowing what to build, to understanding why one approach fails at scale and another doesn't. Those are harder skills, not easier ones.

I’m in my 40 something and it’s game over for my career. The grey in my hair makes it so that I never get past the first round. The history on my resume makes it so I’m lucky to get a round. The GPT’s and Claude have fundamentally changed how I view work and frankly, I’m over it.

I’m in consulting now and it’s all the same crap. Enterprises want to “unleash AI” so they can fire people. Maximize profits. My nephews who are just starting their careers are blindly using these tools and accepting the PR if it builds. Not if it’s correct.

I’m in awe of what it can do but I also am not impressed with the quality of how it does it.

I’m fortunate to not have any debt so I can float until the world either wises up or the winds of change push me in a new direction.

I liked the satisfaction of building something “right” that was also “useful”. The current state of Opus and Codex can only pretend to do the latter.

People have to stop talking like LLMs solved programming.

If you're someone with a background in Computer Science, you should know that we have formal languages for a reason, and that natural language is not as precise as a programming language.

But anyway we're peek AI hype, hitting the top on HN is worth more than a reasonable take, reasonableness doesn't sell after all.

So here we're seeing yet another text about how the world of software was solved by AI and being a developer is an artifact of the past.

> we have formal languages for a reason

Right? At least on HN, there's a critical mass of people loudly ignoring this these days, but no one has explained to me how replacing formal language with an english-language-specialized chatbot - or even multiple independent chatbots (aka "an agent") - is good tradeoff to make.

It's "good" from the standpoint of business achieving their objectives more quickly. That may not be what we think of as objectively good in some higher sense, but it's what matters most in terms of what actually happens in the world.

Should it be what matters most? Idiots leading idiots in a circle.

Does it really matter that English is not as precise if the agent can make a consistent and plausible guess what my intention is? And when it occasionally guesses incorrectly, I can always clarify.

You're right, of course, but you should consider that all formal language starts as an informal language idea in the mind of someone. Why shouldn't that "mind" be an LLM vs. a human?

I think mostly because an LLM is not a "mind". I'm sure there'll be an algorithm that could be considered a "mind" in the future, but present day an LLM is not it. Not yet.

Yes, but the people who talk to me as Software Engineer about what to build also talk to me only in natural language, not a formal language.

This is in my opinion the greatest weakness of everything LLM related. If I care about the application I'm writing, and I believe I should if I bother doing it at all, it seems to me that I should want to be precise and concise at describing it. In a way, the code itself serves as a verification mechanism for my thoughts and whether I understand the domain sufficiently.

English or any other natural language can of course be concise enough, but when being brief they leave much to imagination. Adding verbosity allows for greater precision, but I think as well that that is what formal languages are for, just as you said.

Although, I think it's worth contemplating whether the modern programming languages/environments have been insufficient in other ways. Whether by being too verbose at times, whether the IDEs should be more like databases first and language parsers second, whether we could add recommendations using far simpler, but more strict patterns given a strongly typed language.

My current gripes are having auto imports STILL not working properly in most popular IDEs or an IDE not finding referenced entity from a file, if it's not currently open... LLMs sometimes help with that, but they are extremely slow in comparison to local cache resolution.

Long term I think more value will be in directly improving the above, but we shall see. AI will stay around too of course, but how much relevance it'll have in 10 years time is anybody's guess. I think it'll become a commodity, the bubble will burst and we'll only use it when sensible after a while. At least until the next generation of AI architecture will arrive.

I dont get the hype.. And I dont think we will reach peak AI coding performance any time soon.

Yes, watching an LLM spit out lots of code is for sure mesmerizing. Small tasks usually work ok, code kinda compiles, so for some scenarios it can work out.. BUT anyone serious about software development can see how piece of CRAP the code is.

LLMs are great tools overall, great to bounce ideas, great to get shit done. If you have a side project and no time, awesome.. If your boss/company has a shitty culture and you just want to get the task done, great. Got a mundane coding task, hate coding, or your code wont run in a critical environment? please, LLM that shit over 9000..

Remember though, an LLM is just a predictor, a noisy, glorified text predictor. Only when AI reaches a point of not optimizing for short term gains and has built-in long term memory architecture (similar to humans) AND can produce some linux kernel level code and size, then we can talk..

Super weird comments on this thread, to the point I would think it's brigaded or some (most) comments are straight up AI generated. Hackernews definitely changed. The tone on AI changed since a few months ago, I guess also because many people here are working on AI. Almost any new startup is AI-adjacent now. It's no surprise, cca. 120 out of 150 YC startups are AI. So there is a big push on this forum to keep the hype and sentiment going.

The hard part is always the last 20%.

I was thinking the same thing as I scrolled through. Half the comments are some AI generated homage to AI. I’ve seen Anthropic pushing so much marketing BS on X/Twitter that wouldn’t surprise me if it extended to HN.

I have junior people on my team using Cursor and Claude, it’s not all great. Several times they’ve checked in code that also makes small yet breaking changes to queries. I have to watch out for random (unused) annotations in Java projects and then explain why the tools are wrong. The Copilot bot we use on GitHub slows down PR reviews by recommending changes that look reasonable yet either don’t really work or negatively impact performance.

Overall, I’d say AI tooling has maybe close to doubled the time I spend on PR reviews. More knowledgeable developers do better with these tools but they also fall for the toolings false confidence from time to time.

I worry people are spending less time reading documentation or stepping through code to see how it works out of fear that “other people” are more productive.

There's a commercial building under construction next to my office. I look down on the construction site, and those strapping young men are digging with their big excavators they've been using for years and taking away the dirt with truck and trailer.

Why use a spade? Even those construction workers use the right sized tools. They ain't stupid.

Them using excavator and trucks etc to move dirt. Is the same as us using a compiler to compile code into an executable.

LLM would be if the digging and hauling of the dirt happened without any people involved except the planning of logistics.

LLM would be equal to a monstrous moving castle with million robotic hands that can somehow collaterally extract piles of dirt from earth, doing a lot of damage to our planet

> LLM would be if

you'd sometimes discover a city communication line destroyed in the process; or the dirt hauled on top of a hospitals, killing hundreds of orphaned kids with cancer; or kittens mixed into concrete instead of cement.

And since you clicked "agree" on that Anthropic EULA, you can't sue then for it, so you now hire 5 construction workers to constantly overlook the work.

It's still net positive... for now at least... But far from being "without any people". And it'll likely remain this way for a long time.

This is the right take IMO, so thanks for a balanced comment.

I would add a nuance from OPs perspective sorta: a close friend of mine works in construction, and often comments on how projects can be different. On some, everyone in the entire building supply chain can be really inspired to work on a really interesting project because of either its usefulness or its craftsmanship (the 2 of which are related), and on some, everyone’s, just trying to finish the project is cheaply quickly as possible.

It’s not that the latter hasn’t existed in tech, but it does appear that there is a way to use LLMs to do more of the latter. It’s not “the end of a craft”, but without a breakthrough (and something to check the profit incentive) it’s also not a path to utopia (like other comments seem to be implying)

Craftsmanship doesn’t die, it evolves, but the space in between can be a bit exhausting as markets fail to understand the difference at first.

I think OP is coming at this more from an artisan angle. Perhaps there were shoveler artisans who took pride in the angle of their dirt-shoveling. Those people perhaps do lament the advent of excavators. But presumably the population who find code beautiful vs the art of shoveling are of different sizes

I've been hearing "the LLM can write better code than a human, and if you don't believe me, wait six months" for years now. Such predictions haven't been true before and I don't believe they are true now.

> wait six months

from other sources: 6-12 months, by end of 2025, ChatGPT 7.

It's a concern trolling and astroturfing at it best.

One camp of fellow coders who are saying how their productivity grew 100x but we are all doomed, another camp of AI enthusiasts who got ability to deliver products and truly believe in their newly acquired superiority.

It's all either true or false, but if in six months it becomes true, we'll know it, each one of us.

However, if it's all BS and in six months there will be Windows 95 written by LLM but real code still requires organic intelligence, there won't be any accountability, and that's sad.

This makes me think about the craftsmen whose careers vanished or transformed through the ages due to industries, machines etc. They did not have online voices to write 1000's of blogs everyday. Nor did they have people who can read their woes online.

Maybe not 1000s and not online, but we do have journals, articles, essays, and so on written by such people throughout history. And they had similar sentiments.

I don't mourn coding for itself, since I've always kinda disliked that side of my work (numerical software, largely).

What I do mourn is the reliability. We're in this weird limbo where it's like rolling a die for every piece of work. If it comes up 1-5, I would have been better off implementing it myself. If it comes up 6, it'll get it done orders of magnitude faster than doing it by hand. Since the overall speedup is worthwhile, I have to try it every time, even if most of the time it fails. And of course it's a moving target, so I have to keep trying the things that failed yesterday because today's models are more capable.

I get where this is coming from. But at the same, AI/LLMs are such an exciting development. As in "maybe I was wrong and the singularity wasn't bullshit". If nothing else, it's an interesting transition to live through.

I agree, in the sense that any major change is "interesting". Doesn't mean they are all good though, many major changes have been bad historically. The overall net effect has been generally good, but you never know with any individual change.

Write a blog post promoting inevitability of AI in software development while acknowledging feelings of experienced software engineers.

I on the other hand await the coming of the Butlerian Jihad.

> We’ll miss the sleepless wrangling of some odd bug that eventually relents to the debugger at 2 AM.

I'll miss it not because the activity becomes obsolete, but because it's much more interesting than sitting till 2am trying to convince LLM to find and fix the bug for me.

We'll still be sitting till 2am.

> They can write code better than you or I can, and if you don’t believe me, wait six months.

I've been hearing this for the last two years. And yet, LLMs, given abstract description of the problem, still write worse code than I do.

Or did you mean type code? Because in that case, yes, I'd agree. They type better.

I am not confident that AI tooling can diagnose or fix this kind of bug. I’ve pointed Claude Opus at bugs that puzzle me (with only one code base involved) and, so far, it has only introduced more bugs in other places.

I'm not saying it can btw. I'm arguing for the opposite.

And for the record, I'm impressed at issues it can diagnose. Being able to query multiple data sources in parallel and detect anomalies, it sometimes can find the root cause for an incident in a distributed system in a matter of minutes. I have many examples when LLMs found bugs in existing code when tasked to write unit tests (usually around edge cases).

But complex issues that stem from ambiguous domain are often out of reach. By the time I'm able to convey to an LLM all the intricacies of the domain using plain English, I'm usually able to find the issue myself.

And that's my point: I'd be more eager to run the code under debugger till 2am, than to push an LLM to debug for me (can easily take till 2am, but I'd be less confident I can succeed at all)

The acceleration of AI has thrown into sharp relief that we have long lumped all sorts of highly distinct practices under this giant umbrella called "coding". I use CC extensively, and yet I still find myself constantly editing by hand. Turns out CC is really bad at writing kubernetes operators. I'd bet it's equally bad at things like database engines or most cutting edge systems design problems. Maybe it will get better at these specific things with time, but it seems like there will always be a cutting edge that requires plenty of human thought to get right. But if you're doing something that's basically already been done thousands of times in slightly different ways, CC will totally do it with 95% reliability. I'm ok with that.

It's also important to step back and realize that it goes way beyond coding. Coding is just the deepest tooth of the jagged frontier. In 3 years there will be blog posts lamenting the "death of law firms" and the "death of telemedicine". Maybe in 10 years it will be the death of everything. We're all in the same boat, and this boat is taking us to a world where everyone is more empowered, not less. But still, there will be that cutting edge in any field that will require real ingenuity to push forward.

I think there's clearly a difference in opinion based on what you work on. Some people were working on things that pre-CC models also couldn't handle and then CC could, and it changed their opinions quickly. I expect (but cannot prove of course) that the same will happen with the area you are describing. And then your opinion may change.

I expect it to, eventually. But then the cutting edge will have simply moved to something else.

I agree that it's very destabilizing. It's sort of like inflation for expertise. You spend all this time and effort saving up expertise, and then those savings rapidly lose value. At the same time, your ability to acquire new expertise has accelerated (because LLMs are often excellent private tutors), which is analogous to an inflation-adjusted wage increase.

There are a ton of variables. Will hallucinations ever become negligible? My money is on "no" as long as the architecture is basically just transformers. How will compiling training data evolve with time? My money is on "it will get more expensive". How will legislators react? I sure hope not by suppressing competition. As long as markets and VC are functioning properly, it should only become easier to become a founder, so outsized corporate profits will be harder to lock down.

To the people who are against AI programming, honest question: why do you not program in assembly? Can you really say "you" "programmed" anything at all if a compiler wrote your binaries?

This is a 100% honest question. Because whatever your justification to this is, it can probably be used for AI programmers using temperature 0.0 as well, just one abstraction level higher.

I'm 100% honestly looking forward to finding a single justification that would not fit both scenarios.

I'm all for AI programming.

But I've seen this conversation on HN already 100 times.

The answer they always give is that compilers are deterministic and therefore trustworthy in ways that LLMs are not.

I personally don't agree at all, in the sense I don't think that matters. I've run into compiler bugs, and more library bugs than I can count. The real world is just as messy as LLMs are, and you still need the same testing strategies to guard against errors. Development is always a slightly stochastic process of writing stuff that you eventually get to work on your machine, and then fixing all the bugs that get revealed once it starts running on other people's machines in the wild. LLMs don't write perfect code, and neither do you. Both require iteration and testing.

  > The answer they always give is that compilers are deterministic and therefore trustworthy in ways that LLMs are not.

I wrote much more here[0] and honestly I'm on the side of Dijkstra, and it doesn't matter if the LLM is deterministic or probabilistic

  It may be illuminating to try to imagine what would have happened if, right from the start our native tongue would have been the only vehicle for the input into and the output from our information processing equipment. My considered guess is that history would, in a sense, have repeated itself, and that computer science would consist mainly of the indeed black art how to bootstrap from there to a sufficiently well-defined formal system. We would need all the intellect in the world to get the interface narrow enough to be usable, and, in view of the history of mankind, it may not be overly pessimistic to guess that to do the job well enough would require again a few thousand years.
  - Dijkstra: On the foolishness of "natural language programming"

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

[1] If we want to be more pedantic we can actually codify his argument more simply by using some mathematical language, but even this will take some interpretation: natural language naturally imposes a one to many relationship when processing information.

Nah bro I'll just ask the LLM to do better next time /s

It amazes me people say that serially, given in the next breath they'll complain about how their manager doesn't know shit and is leading blind. Or complain about how you don't understand. Maybe we need to install more mirrors

I just answered exactly that. I think that AI agents code better than humans and are the future.

But the parent argument is pretty bad, in my opinion.

Depends on who these humans you're comparing AI code to. I've seen and reviewed enough AI code in the last few months to have formed a solid impression that it's "ok" at best and relies heavily on who guides it - how well spec defined, what kind of rules are set, coding styles, architecture patterns.

The prompt user is basically selecting patterns from latent space. So you kind of need to know what you're looking for. When you don't know what you're looking for that's when the fun begins, but that's a problem for the next quarter.

It's true for more guided development approach. But the further you go into vibecode territory, the less you need to know.

There's a big difference between deterministic abstraction over machine code, and probabilistic translation of ambiguous language into machine code.

Compiler is your interface.

If you treat LLM as your interface... Well, I wouldn't want sharing codebase with you.

I'm not particularly against AI programming but I don't think these two things are equivilent. A compiler translates code to specifications in a deterministic way, the same compiler produces the same output from the same code, it is all completely controlled. AI is not at all deterministic, temperature is built into LLMs and furthermore the lack of specificity in prompts and our spoken languages. The difference in control is significant enough to me not to put compilers and AI coding agents into the same catagory even though they are both taking some text and producing some other text/machine code.

A chef can cook a steak better than a robo-jet-toaster, even though neither of them has raised the cow.

It's not about having abstraction levels above or below (BTW, in 21st century CPUs, the machine code itself is an abstraction over much more complex CPU internals).

It's about writing a more correct, efficient, elegant, and maintainable code at whichever abstraction layer you choose.

AI still writes messier, sloppier, buggier, more redundant code than a good programmer can when they care about the craft of writing code.

The end result is worse to those who care about the quality of code.

We mourn, because the quality we paid so much attention to is becoming unimportant compared to the sheer quantity of throwaway code that can be AI-generated.

We're fine dining chefs losing to factory-produced junk food.

Even if you are not coding in assembly you still need to think. Replace llm with a smart programmer. I don't like the other guy to do all the thinking for me. Much better if it's a collaborative process even if the other guy could have coded the perfect solution without my help. Like otherwise why am I even in the picture?

I know how to review code without looking at the corresponding assembly and have high confidence in the behavior of the final binary. I can't quite say the same for a prompt without looking at the generated code, even with temperature 0. The difference is explainability, not determinism.

Compilers are deterministic.

There is no requirement for compilers to be deterministic. The requirement is that a compiler produces something that is valid interpretation of the program according to the language specification, but unspecified details (like specific ordering of instructions in the resulting code) could in principle be chosen nondeterministically and be different in separate executions of the compiler.

We are not talking about deterministic instructions, we are talking about deterministic behavior.

UB is actually a big deal, and is avoided for a reason.

I couldn't in my life guess what CC would do in response to "implement login form". For all I know CC's response could depend on time of day or Anthropic's electricity bill last month more, than on the existing code in my app, and the specific wording I use.

I do not talk about UBs, compiler can be non-deterministic even for completely valid and well-specified source code.

Seems to me that people just confuse determinism with soundness.

Determinism is just whether the output of the tool (machine code) is determined by the input (source code), i.e., for one input always returns the same output.

Soundness means that output is always consistent with the semantics of the input. i.e. returned machine code always does what is specified by the source code.

Compilers can be non-deterministic (although usually are deterministic), but they are always sound (ignoring compiler bugs).

LLMs can be deterministic (although usually aren't), but they are not sound in general.

For me, the whole goal is to achieve Understanding: understanding a complex system, which is the computer and how it works. The beauty of this Understanding is what drives me.

When I write a program, I understand the architecture of the computer, I understand the assembly, I understand the compiler, and I understand the code. There are things that I don't understand, and as I push to understand them, I am rewarded by being able to do more things. In other words, Understanding is both beautiful and incentivized.

When making something with an LLM, I am disincentivized from actually understanding what is going on, because understanding is very slow, and the whole point of using AI is speed. The only time when I need to really understand something is when something goes wrong, and as the tool improves, this need will shrink. In the normal and intended usage, I only need to express a desire to achieve a result. Now, I can push against the incentives of the system. But for one, most people will not do that at all; and for two, the tools we use inevitably shape us. I don't like the shape into which these tools are forming me - the shape of an incurious, dull, impotent person who can only ask for someone else to make something happen for me. Remember, The Medium Is The Message, and the Medium here is, Ask, and ye shall receive.

The fact that AI use leads to a reduction in Understanding is not only obvious, but also studies have shown the same. People who can't see this are refusing to acknowledge the obvious, in my opinion. They wouldn't disagree that having someone else do your homework for you would mean that you didn't learn anything. But somehow when an LLM tool enters the picture, it's different. They're a manager now instead of a lowly worker. The problem with this thinking is that, in your example, moving from say Assembly to C automates tedium to allow us to reason on a higher level. But LLMs are automating reasoning itself. There is no higher level to move to. The reasoning you do now while using AI is merely a temporary deficiency in the tool. It's not likely that you or I are the .01% of people who can create something truly novel that is not already sufficiently compressed into the model. So enjoy that bit of reasoning while you can, o thou Man of the Gaps.

They say that writing is God's way of showing you how sloppy your thinking is. AI tools discourage one from writing. They encourage us to prompt, read, and critique. But this does not result in the same Understanding as writing does. And so our thinking will be, become, and remain vapid, sloppy, inarticulate, invalid, impotent. Welcome to the future.

  > why do you not program in assembly?

The point of code is to write specification. That is what code is. The whole reason we use a pedantic and somewhat cryptic schema is that natural language is too abstract. This is the exact reason we created math. It really is even the same reason we created things like "legalese".

Seriously, just try a simple exercise and be adversarial to yourself. Describe how to do something and try to find loopholes. Malicious compliance. It's hard, to defend and writing that spec becomes extremely verbose, right? Doesn't this actually start to become easier by using coding techniques? Strong definitions? Have we not all forgotten the old saying "a computer does exactly what you tell it to, not what you intend to tell it to do"? Vibe coding only adds a level of abstraction to that. It becomes "a computer does what it 'thinks' you are telling it to do, not what you intend to tell it to do". Be honest with yourself, which paradigm is easier to debug?

Natural language is awesome because the abstraction really compresses concepts, but it requires inference of the listener. It requires you to determine what the speaker intends to say rather than what the speaker actually says.

Without that you'd have to be pedantic to even describe something as mundane as making a sandwich[1]. But inference also leads to misunderstandings and frankly, that is a major factor of why we talk past one another when talking on large global communication systems. Have you never experienced culture shock? Never experienced where someone misinterprets you and you realize that their interpretation was entirely reasonable?[2] Doesn't this knowledge also help resolve misunderstandings as you take a step back and recheck assumptions about these inferences?

  > using temperature 0.0

I really think Dijkstra explains things well[0]. (I really do encourage reading the entire thing. It is short and worth the 2 minutes. His remark at the end is especially relevant in our modern world where it is so easy to misunderstand one another...)

  The virtue of formal texts is that their manipulations, in order to be legitimate, need to satisfy only a few simple rules; they are, when you come to think of it, an amazingly effective tool for ruling out all sorts of nonsense that, when we use our native tongues, are almost impossible to avoid.

  Instead of regarding the obligation to use formal symbols as a burden, we should regard the convenience of using them as a privilege: thanks to them, school children can learn to do what in earlier days only genius could achieve. 

[1] https://www.youtube.com/watch?v=FN2RM-CHkuI

[2] Has this happened to you and you've been too stubborn to realize the interpretation was reasonable?

[dead]

I suspect my comment will not be well received, however I notice in myself that I've passed the event horizon of being a believer and am past the honeymoon period and I'm beginning to think about engineering

My headspace is now firmly in "great, I'm beginning to understand the properties and affordances of this new medium, how do I maximise my value from it", hopefully there's more than a few people who share this perspective, I'd love to talk with you about the challenges you experience, I know I have mine, maybe we have answers to each others problems :)

I assume that the current set of properties can change, however it seems like some things are going to be easier than others, for example multi modal reasoning still seems to be a challenge and I'm trying to work out if that's just hard to solve and will take a while or if we're not far from a good solution

That's why I'll only read source code written until 2024.

I thought I'd miss all the typing and syntax, but I really don't. Everyone has their own relationship with coding, but for me, I get satisfaction out of the end product and putting it in front of someone. To the extend that I cared about the code, it mainly had to do with how much it allowed the end product to shine.

Yes, there's clearly a big split in the community where perhaps ~50% are like OP and the other ~50% are like you. But I think we should still respect the views of the other side and try to empathize.

At the end I felt more like a plumber, connecting pipes and building adapters where pipes didn't match.

Repost this in a couple of years and it'll be relevant. Too soon though, as it stands.

To me this sentiment is silly. Programming was never about the act of writing, but about making the computer do something. Now we can ask computers to helps us write instructions for them. Great if you ask me. And no, your job is not going away because human maintainers will always be required to review changes, communicate with stakeholders and provide a vision for the projects. I have yet to see a chatbot that can REDUCE entropy inside a codebases rather than continuously increase it with more and more slop.

The inspired me to write down some scattered thoughts I have on this [0]. tl;dr I firmly believe we kicked the can down the road and now it's too late.

Things programmers forgot to do before AI started writing a bunch of software:

1. Learn how to review code

Some tools exist, some of them are even quite good! Large organizations have tried to build best practices to balance urgency with correctness, but programmers are still quite bad at this.

2. Compare program A vs program B

In a similar vein, we simply do not know how to measure one program vs another. Or a function against another. Or even one variableName vs another_variable_name.

"It depends" Depends on what? We never sorted this out.

3. Talk to other professions

We are not the first profession forced to coordinate with Automation as a coworker, and we certainly won't be the last. We're not even the first knowledge workers to do so.

How did other laborers deal with this? We don't know because we were busy making websites.

[0]: https://bsky.app/profile/did:plc:wh7bie3ld7bmg3cz76sbjkwj/po...

Software was never governed by a single standard. It has always been closer to architecture or design, with competing schools judging quality differently. AI tools do not remove judgment; they make it unavoidable. I sit in a minimalist, almost brutalist school: fewer layers, obvious structure, and software that delivers results even if it is not fashionable.

The majority of the code currently running in production for my company was written 5+ years ago. This was all "hand-written" and much lower quality than the AI generated code that I am generating and deploying these days.

Yet I feel much more connected with my old code. I really enjoyed actually writing all that code even though it wasn't the best.

If AI tools had existing 5 years ago when I first started working on this codebase, obviously the code quality would've been much higher. However, I feel like I really loved writing my old code and if given the same opportunity to start over, I would want to rewrite this code myself all over again.

I didn't come in IT for money - back in the days it wasn't as well paid as today - nevertheless if this craft was very poorly paid I probably wouldn't choose this profession either. And I assume many people here wouldn't as well unless you are already semi-retired or debt free.

I mourn a little bit that in 20 years possibly 50% of software jobs will get axed or unless you are elite/celebrity dev salary will stagnate. I mourn that in the future upward mobility and moving up into upper middle class will be harder without trying to be entrepreneur.

I'm probably a minority, but I've never loved dealing with syntax. The code itself always felt like a hindrance to me that reminded me that my brain was slowed down by my fingers. I get it though, it was tactical and it completed the loop. It was essential for learning I felt like despite eventually getting to a point where it slows you down the more senior you get.

AI has a ways to go before it's senior level if it ever reaches that level, but I do feel bad for juniors that survive this who never will have the opportunity to sculpt code by hand.

I feel like we are long into the twilight of mini blogs and personal sites. Its like people trying to protect automotive jobs, the vas majority were already lost

Perhaps Im a cynic but I don't know

> If you would like to grieve, I invite you to grieve with me.

I think we should move past this quickly. Coding itself is fun but is also labour , building something is the what is rewarding.

By that logic prompting an AI is also labour.

It's not even always a more efficient form of labour. I've experienced many scenarios with AI where prompting it to do the right thing takes longer and requires writing/reading more text compared to writing the code myself.

> because they’re wearing bazooka-powered jetpacks and you’re still riding around on a fixie bike

Sure, maybe it takes me a little while to ride across town on my bike, but I can reliably get there and I understand every aspect of the road to my destination. The bazooka-powered jetpack might get me there in seconds, but it also might fly me across state lines, or to Antarctica, or the moon first, belching out clouds of toxic gas along the way.

Like the cab drivers in London who have to know the city inside and out? https://wheelchairtravel.org/london-black-cab-driver-knowled...

Some years ago I was at the Burger King near the cable car turntable at Powell and Market St in San Francisco. Some of the homeless people were talking about the days when they'd been printers. Press operators or Linotype operators. Jobs that had been secure for a century were just - gone.

That's the future for maybe half of programmers.

Remember, it's only been three years since ChatGPT. This is just getting started.

From valued professional to surplus inventory just like that. Where does this process end? Because right now it's only accelerating.

I understand the sentiment and I've been involved in software engineering in various roles for the last 25+ years. The thing that gives me hope is that never once in that time has the problem ever been that we didn't have more work to do.

It's not like all of a sudden I'm working 2-3 hours a day. I'm just getting a lot more done.

This post is rather like a recent similar post "I miss thinking hard about things". Top comment quoted a metaphor relating to clay. No offense this blog article feels as if an LLM ingested that post and thread and produced a gestalt of it

One other helpful frame: I consider LLMs simply to be very flexible high-level 'language' Compilers. We've moved up the Abstraction Chain ever since we invented FORTRAN and COBOL (and LISP) instead of using assembly language.

We're 'simply' moving up the abstraction hierarchy again. Good!

A non-deterministic, slow, pay to use, compiler for a language that is not precise enough for software. What an amazing abstraction!

You are just salty and old. If you're young and hip you don't need to know what you're doing just do the thing.

You know who else mourned the loss of craft? People that don't like PHP and Wordpress because they lower the barrier to entry to creating useful stuff while also leaving around a fair amount of cruft and problems that the people that use them don't understand how to manage.

Like iambateman said: for me it was never about code. Code was a means to an ends and it didn't stop at code. I'm the kind of software engineer that learned frontends, systems, databases, ETLs, etc -- whatever it was that was that was demanded of me to produce something useful I learned and did it. We're now calling that a "product engineer". The "craft" for me was in creating useful things that were reliable and efficient, not particularly how I styled lines, braces, and brackets. I still do that in the age of AI.

All of this emotional spillage feels for not. The industry is changing as it always has. The only constant I've ever experienced in this industry is change. I realized long ago that when the day comes that I am no longer comfortable with change then that is my best signal that this industry is no longer for me.

I think it's a bit different when you can opt out. If you didn't want to use PHP you didn't have to. But it's getting increasingly hard to opt out of AI.

The death of a means to an end is the birth of an end itself.

When cameras became mainstream, realism in painting went out of fashion, but this was liberating in a way as it made room for many other visual art styles like Impressionism. The future of programming/computing is going to be interesting.

We have CNC machines, and we still have sculptors.

Mechanising the production of code is good thing. And crafting code as art is a good thing. It is sign of a wider trend that we need to look at these things like adversaries.

I look forward to the code-as-art countermovement. It's gonna be quite something.

Great post. Super sad state of affairs but we move on and learn new things. Programming was always a tool and now the tool has changed from something that required skill and understanding to complaining to a neural net. Just have to focus on the problem being solved more.

> Programming was always a tool

This is the narrow understanding of programming that is the whole point of contention.

Coding is an abstraction. Your CPU knows nothing of type safety, bloom filters, dependencies, or code reuse.

Mourning the passing of one form of abstraction for another is understandable, but somewhat akin to bemoaning the passing of punch card programming. Sure, why not.

Your entire brain's model of the world is an abstraction over its sensory inputs. By this logic we might as well say you shouldn't mourn anything since all it means is a minor difference in the sensory inputs your brain receives.

Stop acting like software engineering is dead or something. Even if it its, we will still code by hand when we are poor later in this bubble. Only thing I would refuse is to pay any money to Anthropic & openAI. Literally would invest in Chinese labs at this point

I'll believe it when I start seeing examples of good and useful software being created with LLMs or some increase in software quality. So far it's just AI doom posting, hype bloggers that haven't shipped anything, anecdotes without evidence, increase in CVEs, increase in outages, and degraded software quality.

It would be helpful if you could define “useful” in this context.

I’ve built a number of team-specific tools with LLM agents over the past year that save each of us tens of hours a month.

They don’t scale beyond me and my six coworkers, and were never designed to, but they solve challenges we’d previously worked through manually and allow us to focus on more important tasks.

The code may be non-optimal and won’t become the base of a new startup. I’m fine with that.

It’s also worth noting that your evidence list (increased CVEs, outages, degraded quality) is exclusively about what happens when LLMs are dropped into existing development workflows. That’s a real concern, but it’s a different conversation from whether LLMs create useful software.

My tools weren’t degraded versions of something an engineer would have built better. They’re net-new capability that was never going to get engineering resources in the first place. The counterfactual in my case isn’t “worse software”—it’s “no software.“

It really shouldn't be this hard to just provide one piece of evidence. Is anecdotes of toy internal greenfield projects that could probably be built with a drag and drop no-code editor really the best from this LLM revolution?

What is your bar for “useful”? Let’s start there and we’ll see what evidence can be offered.

User count? Domain? Scope of development?

You have something in mind, obviously.

If you're asking me to define a very clear bar, it's obvious nothing cleared it.

Anything that proves that LLMs increase software quality. Any software built with an LLM that is actually in production, survives maintenance, doesn't have 100 CVEs, that people actually use.

At my work ~90% of code is now LLM generated. It's not "new" software in the sense that you're describing but it's new features, bug fixes, and so on to the software that we all work on. (Although we are working on something that we can hopefully open source later this year that is close to 100% LLM generated, and I can say, as someone that has been reviewing most of the code, is quite high quality)

Well, on the surface it may seem like there’s nothing being created of value, but I can assure you every company from seed stage to unicorns are heavily using claude code, cursor, and the like to produce software. At this point, most software you touch has been modified and enhanced with the use of LLMs. The difference in pace of shipping with and without AI assistance is staggering.

> every company from seed stage to unicorns are heavily using claude code, cursor, and the like to produce software

> The difference in pace of shipping with and without AI assistance is staggering.

Lets back up these statements with some evidence, something quantitative, not just what pre-IPO AI marketing blog posts are telling you.

Why quantitative? I have friends at most major tech companies and I work at a startup now. You shouldn’t write by hand what can be prompted. Doesn’t mean the hard parts shouldn’t be done with the same care as when everything was handwritten, but a lot of minutiae are irrelevant now.

Because anything not quantitative is either “trust me bro” or AI marketing. Some of us are engineers, so we want to see actual numbers and not vibes.

And there are studies on this subject, like the MITRE study that shows that development speed decreases with LLMs while developers think it increases speed.

It's not clear what evidence you expect to see? Every major tech company is using AI for a significant % of their code. Ask anyone that works there and you will have all the evidence you need.

> Every major tech company is using AI for a significant % of their code

It shows, increased outages, increased vulnerabilities, windows failing to boot, windows task bar is still react native and barely works. And I have spoken to engineers at FANG companies, they are forced to use LLMs, managers are literally tracking metrics. So where is all this amazing new software and software quality or increased productivity from them?

You are measuring differently..they measure in how much stuff they ship. They don't measure if it's going to break , if it is not very maintainable, or how much it will cost to keep using the LLM I. The future. Remember its an extraction grift: buy now, pay later. Preferably after you have made the model an intrinsic part of the process. Oh snap, now we definitely need to bailout LLMs cause noone knows how this stuff works. Please help. Useful idiots all around. Classic case of not using their brains the way they evolved for.

Like the new features in Windows 11? They’ve just anointed a “software quality czar” and I suspect this is not coincidence.

1. it isn't that bad

2. the tools still need a lot of direction, i still fight claude with opus to do basic things and the best experiences are when i provide very specific prompts

3. being idealistic on a capitalist system where you have to pay your bills every month is something i could do when my parents paid my bills

These apocalyptic posts about how everything is shit really don't match my reality at all. I use these tools every day to be more productive and improve my code but they are nowhere close to doing my actual job, that is figuring out WHAT to do. How to do it is mostly irrelevant, as once i get to that point i already know what needs to be done and it doesn't matter if it is me or Opus producing the code.

About 20 years ago I realised the extreme immaturity of IT field. The market was fragmented and you could literally become billionaire from your basement (80's), from an office (90's) etc. It was at the stage of car industry of the beginning of the past century. Since then the IT market has matured a lot so that a handful of companies formed an oligopoly and are thriving with no possibility of threat from isolated developers. In the following years the startup landscape will be dead, everyone will be bought up and even the computer devices will become sealed boxes with controlled buttons. Having a browser open might be a hack.

I feel like a lot of comments here are missing the point. I think the article does a fairly good job neither venerating nor demonizing AI, but instead just presenting it as the reality of the situation, and that reality means that the craft of programming and engineering is fundamentally different than it was just a few years ago.

As an (ex-)programmer in his late 40s, I couldn't agree more. I'm someone who can be detail-oriented (but, I think also with a mind toward practicality) to the point of obsession, and I think this trait served me extremely well for nearly 25 years in my profession. I no longer think that is the case. And I think this is true for a lot of developers - they liked to stress and obsess over the details of "authorship", but now that programming is veering much more towards "editor", they just don't find the day-to-day work nearly as satisfying. And, at least for me, I believe this while not thinking the change to using generative AI is "bad", but just that it's changed the fundamentals of the profession, and that when something dies it's fine to mourn it.

If anything, I'm extremely lucky that my timing was such that I was able to do good work in a relatively lucrative career where my natural talents were an asset for nearly a quarter of a century. I don't feel that is currently the case regarding programming, so I'm fortunate enough to be able to leave the profession and go into violin making, where my obsession with detail and craft is again a huge asset.

The thing he has spent his whole career doing unto others he finally did into himself

I am feeling this loss. I spent most of mu career scrupulously avoiding leadership positions because what I really like is the simple joy of making things with my own two hands.

Many are calling people like me Luddites for mourning this, and I think that I am prepared to wear that label with pride. I own multiple looms and a spinning wheel, so I think I may be in a better position speculates on how the Luddites felt than most people are nowadays.

And what I see is that the economic realities are what they are - like what happened to cottage industry textile work, making software by hand is no longer the economical option. Or at least, soon enough it won’t be. I can fret about deskilling all I like, but it seems that soon enough these skills won’t be particularly valuable except as a form of entertainment.

Perhaps the coding agents won’t be able to make certain things or use certain techniques. That was the case for textile manufacturing equipment, too. If so then the world at large will simply learn to live without. The techniques will live on, of course, but their practical value will be as an entertainment for enthusiasts and a way for them to recognize one another when we see it in each others’ work.

It’s not a terrible future, I suppose, in à long enough view. The world will move on, just like it did after the Industrial Revolution. But, perhaps also like the Industrial Revolution and other similar points in history, not until after we get through another period where a small cadre of wealthy elites who own and control this new equipment use that power to usher in a new era of neofeudalism. Hopefully this time they won’t start quite so many wars while they enjoy their power trips.

> They can write code better than you or I can

Speak for yourself. They produce shit code and have terrible judgment. Otherwise we wouldn't need to babysit them so much.

To me, it’s super exciting to play ping pong with ideas up until I arrive at an architecture and interfaces, that I am fine with.

My whole life I have been reading other people’s code to accumulate best practices and improve myself. While a lot of developers start with reading documentation, I have always started with reading code.

And where I was previously using the GitHub Code Search to eat up as much example code as I could, I am now using LLMs to speed the whole process up. Enormously. I for one enjoy using it.

That said, I have been in the industry for more than 15 years. And all companies I have been at are full of data silos, tribal knowledge about processes and organically grown infrastructure, that requires careful changes to not break systems you didn’t even know about.

Actually most of my time isn’t put into software development at all. It’s about trying to know the users and colleagues I work with, understand their background and understand how my software supports them in their day to day job.

I think LLMs are very, very impressive, but they have a long way to go to reach empathy.

Oh no, my engineering profession requires me to use new engineering techniques due to advancements produced by engineering. Quality cringe.

Dang right we do.

And the problem isn't even the Junior Zoomer devs running circles around seniors. It's the CTO or Engineering VP himself disappearing for a few months and single-handedly consolidating a handful of products into a full rewrite for the company, excluding most of their engineering team from the process, and then laying them off after.

The problem is the CEO pretending to be an engineer and thinking they know better because they can write English prompts and spit out a hideous prototype.

The problem is Product Owners using LLMs to "write code" while their engineering team does zero human review before merging it, because their AI tooling was made solely responsible for code quality. If something's broken, just prompt a sloppy fix full of hidden performance and security bugs that the automated code review step missed.

If you think this is hyperbole, I was recently laid off from a company that did exactly the above.

Then in 2027, it will be product owners replacing the entire engineering team, including the CTO, because they made their system too reliable to justify their employment, while the "thinkers" get to build the product, engineers be damned.

People with real skills they acquired over a lifetime are no longer shaping business. Reckless efficiency towards being average will rule the day.

The more popular it becomes for coding, the more likely a model collapse will occur.

"Glorified TSA agent" is a rather gloomy, low-agency take on it. You both ask for what you want and verify the results.