Ask HN: Where is our profession (programmer) going?
RU version is available. Content is displayed in original English for accuracy.
In particular: - the code is not the source of truth anymore; it's ask claude to write, and ask claude to explain - LoC, abstractions, and all those "software development principles" does not seem to matter to people - Code review is not done by humans - Actually understanding the problem deeply seems to be offloaded to claude - Some developers are running like 5+ simultaneous claude sessions, and no code is being looked at - Explosion of llm-generated tests
First off, is this similar to what's going on at your company?
If this company is representative, it feels like software development is going from a precise occupation that requires high degree of understanding to something probabilistic and offloaded understanding (to eventually not an occupation at all honestly).
I'm interested to hear other folks' perspectives.
Discussion (49 Comments)Read Original on HackerNews
Understanding the problem and the existing system well enough to design the right solution, even with AI assistance, is a higher cognitive load. I’m doing a lot more of that lately.
I’m more productive, but also more tired. This may be due in part to the breadth of what my team owns, which makes my day a bit more context-switchy than other teams.
As others in this thread have noted, the situation is still evolving. However, I worry less each day about being replaced by AI. There has always been more work than available bandwidth in my experience.
What seems clear to me is that expectations around velocity and throughput will increase (are increasing). AI use will be required to meet those expectations. Learning to use this new tool effectively will be essential for career progression (and preservation).
This works, until it doesn’t. I’m continuously shocked by these stories, where so many people put the future of their job/company in the hands of these agents after only a few months of existing.
I still constantly run into bad output from LLMs, from code to basic questions. I don’t understand how anyone can hand things over to something that is laughably wrong on a pretty regular basis, often in subtle ways that won’t be noticed by someone who isn’t reading closely and thinking critically.
They’ve gotten better, but I still regularly give them the old Nick Burns treatment, push it out of the way, and do it myself.
To the extent that it gets fixed or works at all, it's not because of competent developers doing rigorous analysis of the software, it's because either someone testing it or using it gets annoyed, reports an issue, and then that specific issue gets patched out.
If using LLMs to perform a similar function shocks you, then you should have been shocked already by the proliferation of pretty bad software for the better part of the last couple of decades.
So many criticisms of LLMs assume that people have been writing software very diligently, applying a high standard of engineering, subjecting the code to a battery of rigorous tests, passing it through a strict review process... and that does happen for some software, especially software that is commonly used, but it's not true for the vast majority of software developed.
I'm still amazed people don't achieve extremely high test quality, since you get tests "for free" now.
One of the limitations of testing were always that people "design" things so they're hard to test.
And then they argue "This can't be tested", or "Refactoring this for testing is not worth it."
It is now. Yet, I work on codebases with no tests and lots of yolo co-authoring.
I think for small tools that people want to make for themselves, that’s great. Where I see a problems are when other people and money get involved. If something goes wrong, who is accountable? Claude wrote it, Claude reviewed it, Claude submitted the PR… yet Claude can’t have any real accountability.
There is just such a tremendous amount of waste at every company, in that the headcount and software expands to fill the budget. I’m not defending Elon, but look at how much he slashed from X (80% or so?) and the company still has its core product functioning and an active user base.
There is a ton of software (especially internal) at essentially every company that also is low accountability before Claude. “Oh Ted built that but he’s working on a new important project. I understand it’s broken and that’s impacting you but we won’t be able to prioritize this until next quarter at least. Can you set up a meeting next month to discuss?”
Honestly the outcome for all of these LLMs is indeed is likely a higher amount of software with no accountability, but it’s also an improved ability to juggle more of that software to the same (realistically low) standard.
Therefore a computer must never make a management decision"
-- Internal IBM training manual, 1979
I’ve also seen a lot of issues with co-workers using an LLM to write their readme files. I look at the readme for what return values I should get, go to use them, and get an error. I check the code, and sure enough, none of the variables in the readme exist. The LLM just through they sounded good. Things like this I would say are pretty objectively wrong.
Especially with prototyping-style work, LLMs are clearly good enough for a ton of business-oriented proof-of-concepts, and that line of work is essentially dead. Unfortunately a lot of mid-tier art falls into this category as well, particularly because execs very clearly can't tell good art from bad (on a "customers like this" scale, with functionality being the judge, which is fairly objective. not a subjective "this is good art").
High-skill work is still necessary, but it's hard to tell if it's actually going to be more important (because skill is obviously still needed for actually-good results, and I honestly see no evidence that this will change with current tech) or less (primarily due to less demand, and it being significantly harder for non-skilled to judge skill when everyone can prototype something seemingly-impressive in a weekend). Some will very obviously continue to exist though.
Whether this means "high-skill people are going to be fine, stay the course" or "<10% of high-skill people will be fine, you had better be scrambling right now or looking for a new line of work" is... much less clear.
Unfortunately despite being impressive for solo stuff, such results don’t scale to software you’d give to others.
This, to me, is the biggest differentiator. In terms of results, there's a huge yawning chasm between the person who says "Claude make me a $thing" versus the person who puts in the effort to lay down the overall architecture, gives some thoughts to libraries and dependencies, performance trade-offs etc, and only then begins prompting.
Knowing how to implement Djikstra or a linked list by heart is no longer important. Actual software engineering skills are more important than ever.
This was never important. The important part was always knowing when to use them.
Two things can be true simultaneously. I think there was a time when deep familiarity with implementing algorithms was important.
I'm in a slow-moving, much bigger company. Lot's of talk about "AI" here and we can use copilot if we want to, but there is 0 pressure. I'm in a small team and one colleague uses copilot often. In the beginning there was a minor conflict between him and me, because I found the quality of the LLM code unacceptable and had to ask him to review it more carefully. I think that's settled now, but it makes me sad how a once motivated colleague now seems to try to cheat his way out of work.
I personally find it incredibly boring to write copilot prompts or read its answers full of boiler plate and sycophancy. I don't understand how anyone would want to replace the cognitive work of programming, that I find enjoyable for the most part, with the cognitive work of "talking" to an LLM.
Anyway, I think it will be like this at least for a little while longer: only vibe coding allowed in small companies and less vibe coding the bigger the company is.
But before vibe coding can take over the slow-moving big companies, all the accumulated technical debt will come back to haunt us and vibe-free software will be the new fad. That's what I hope at least.
Before LLMs came, there used to be the technical debt to deal with in a project, now there is also the added cognitive debt which is way more subtle and impactful long-term. If your source of truth isn't source code but a prompt (or even a series of prompts with branches) and the executor of prompts is a non-deterministic agent, I think you've already lost the battle there.
This is cope. There are multiple open models that are already good enough and cheap enough at API rates to sustain this.
It’s really not. Opus 4.8 can’t produce good software design and it still makes straightforward implementation mistakes. Two errors it made in one day for me recently: it built the Cookie class I asked for without a name field—cookies have a name and a value—and it neglected to handle a case where a database could have multiple rows with the same id, just returning whatever came back first.
The “best human programmers” absolutely would not have made those mistakes. At worst, they would have asked if I really meant what they thought I meant.
Basically, in a decade or so, we'll be completely out of the loop in software development; even this title won't exist anymore (like the 2000's webmaster). We'll still be around, but with different roles.
I don’t even disagree with the premise, but it shifts the burden of assessing likelihood back onto the reader, so it doesn’t really add much value to me.
in the olden days (pre-LLMs) we would write high-level code.
the entire layer was high-level code and rarely would we ever need to peak into the assembly:
writing, debugging, architecting, reviewing, testing - all were done in the high-level language layer.
---
welcome to present day:
since we don't write code - we write intents, we also shouldn't review code either - we should review intents.
I don't review my code anymore. I ask the agent to generate markdown docs, graphviz diagrams, changelogs, audit reports, etc. I only review that.
I also ask it to write test and evaluate by whether the tests passed or not. I don't need to peak into the tests code - I can also ask plain english, pseudocode, control flow graph, whatever it is I want.
I can ask it to find errors or missing tests and improve that too!
code is like assembly now.
rare are the cases you would need to peak into that level.
- Humans still own the code
- All code reviewed by humans
- LLM adoption varies across the org. Some are heavy users and some less. Some suspicious some less.
Where are we heading? Depends on model/harness capabilities. Likely some sort of mix where some projects will still require expert humans and others will just be vibe coded. How much we lean in that direction - we'll see.
It may seem hopeless as a programmer, but imo you'd be much better off reframing your situation re: the above sentence.
Among peers, I feel like I am top 20%? 30%? maybe, by being a good programmer who is adept at agents. A year ago was the 0.1% point, this stuff is spreading like wildfire. A year from now I think it's going to just be de rigeur that these are our tools now.
Worse, any edge I have from working with this stuff for years is quickly dulled. The tools are evolving fast. My tricks from 3 months ago have been eclipsed.
Now we have machines that, when asked to produce a paperclip, may instead produce a butter knife, or a banana, or maybe just a "try again later".
These modern "tools" are quite a different animal. They're more akin to roulette wheels that generate massive amounts of heat and CO2.
But it sounds like you're really asking about the state of the world today. If so, I don't think that ideal state is like your friend's company (or at least, as it appeared to be to you). It might be possible that you can make that "dark factory" pattern work (StrongDM seems to be doing it), but it would require infrastructure and discipline that I doubt they're mustering. Think about how CD didn't involve taking a sloppy build process with no testing or observability and just going straight to prod -- it required building up a lot of infra and discipline first.
But on the other hand, I don't think the ideal present involves artisan hand-crafting code either. I haven't written a line of code by hand in enough months that it would genuinely feel weird if I were to try to program that way despite decades of having done just that. That era's done with, and moderate normie practices right now today are more about supervising and guiding agents than about chiseling code into clay tablets.
Claude always likes to "go big," for example, by choosing tools that can support millions of concurrent users or by adding unnecessary layers of abstraction that create more maintenance pain. I guess that's good for LLM companies, since more tokens are spent fixing the mess it caused.
Every time I enter plan mode for a huge feature, I end up cutting about 30-60% of the task scope before the LLM can actually start the work. I review the final code, and I still find things to cut. As said before "The best code is no code, or code you don’t have to maintain" [0]
0: https://www.simplethread.com/20-things-ive-learned-in-my-20-...
I don't think the future is massive data centers running at a staggering loss to generate questionable code.
The future is rethinking IDEs to have local models work in partnership with the developer to ease tedium and catch mistakes.
A model that maintains a visual, zoomable mind-map of the entire project, with two way binding. Code can be created visually or textually, same with data flows.
Project structure and architecture are presented in high-level ways, that can be easily altered and refactored with almost zero tedium.
I think we start using AI for what it's good for: pattern matching and transformation, and stop trying to make it reason and pretend like it's a human.
Once we, as an industry, figure this out we'll unlock a massive boost in quality and productivity, but it looks like there will be some painful times ahead before everyone realizes that the token extrusion machines are only increasing the total cost of ownership, and they are being used incorrectly when we try to outsource our thinking to them.
I think there's an enormous opportunity to build these tools right now, and that whoever nails it will win.
https://www.reddit.com/r/technology/comments/1ueidyv/softwar...
> I had an interview where I was asked the obligatory “what’s your Al workflow” and I said I use it for searching documentation and writing small functions or boilerplate that are tedious. Then I was asked whether I use Cursor. I said no, and immediately was told that “I’d be a better programmer if I used Cursor”. I have 13 years of software engineering experience, and was talked down by an Al startup with no minimal viable prototype. Then I was told I did not have the experience for the role. I love this timeline so much
i think that is a more important question that you shouldn't ignore.
do they have growing revenue?
I haven't worked at a startup in over a decade, but the stories I hear now sound the same as back then. There's lots of wasted effort for mediocre to poor code destined to be rewritten or thrown away until there's enough investment to justify more work. At which point, "more work" just means more sprawling slop instead of fixing the technical debt rotting at the foundation.
AI just put a spotlight on the futility of trying to run before you can walk. Whether so many founders are going to stay in denial about it is yet to be seen. Statistics about any line of business says yes. This is how most businesses fail and most of them have to fail.