I can totally identify with that feeling. It must be how professional mathematicians are feeling as well.
I can totally identify with that feeling. It must be how professional mathematicians are feeling as well.
And also that on the other side of that grief is something new and potentially exciting, but very different than what we're all used to.
I don't know if it helps, but they should know that for every one of them that experiences this grief, it brings joy to ten other people that are now able to do things (make vibe-coded programs) that used to be out of reach for them.
imagine spending years to develop mastery of something that anyone can do now? For example, sitting your ass down in college, debugging lines of code on a Saturday night while people are out partying? It's fun to do, sure, but there's still a huge opportunity cost.
It's easy to say that such people are prideful, arrogant, only cares about being better than others, but I think such a feeling sucks for 99% of the population that are not siddharthas.
The most vocal denouncers of egoism are utterly pathologic egoists themselves.
Edit: I'm at a loss for words.
There are some interesting things being built by AI, but 10x the number of joyful software engineers ain't it.
Every new technology is going to also enable bad people, just like the Internet enabled scammers, it enabled a lot more people to be more productive.
What I'm not seeing is news promoting how we're suddenly doing 10x better in any aspect of our daily lives, nor 6x or 4x or even 2x better. You'd think if we were suddenly getting 10x more productive, even if it was never published in the news, we'd see something, anything that affected our lives in a positive manner.
We're not.
Or at least, I'm not. And a lot of other people seem to be in the same boat.
Comparative advantage ("Is this the best use of my time?") is a real thing, and the human time to make and maintain non-trivial software will always itself be real.
Obviously this is not true for every SWE. A lot of people feel liberated now that the burden of actually writing the code is being replaced by molding it through the interaction with AI. I see people that struggle because they've identified with the writing code part a lot and that's gone now that the machine is doing it, I bet that's hard.
In other words, people who just wanted to become managers.
If someone loves building technology products that doesn't mean they were "only in it for the money". Beyond just being disparaging for no reason, you're missing the path out of the depression-pit here.
You're certainly welcome to miss what coding was, but being rude to engineers who are trying to build businesses is just as ridiculous and entitled as this article is.
This is a false comparison. Agents cannot solve all the technical problems, so the entire statement falls apart.
I obviously implied code related problems. I know agent can't change a diaper or born a child, lol
Out of curiosity, when you take a bite of a burger do you call it a product?
When you watch a movie do you call it content?
And given that fast food is the pinnacle of sustenance as a product and Hollywood has been content-brained since 1977, sure!
It's funny how people produce tons of code they can't even read and somehow feel like they "solved the problem". Do you feel like you built the shed when you hire carpenter and ask him to do it..?
And why school district need you when any highschooler can produce similar code..?
If it wasn't hardest part, why pay so much to swe?
You can feel free to cope by inventing imaginary bad guys. But the reality is that there are a wide variety of reasons people coded by hand. And people that are different than you aren’t somehow inferior or bad.
Why do they have to hate coding, technology and problem solving, that makes no sense. They just use coding agents to write the code for them to use technology and solve problem.
I happen to love the process of building software by coordinating agents. It’s an addictive form of flow state that I enjoy a great deal - similar to the flow state I get playing real time strategy games like Age of Empires. It’s a different kind of flow state than writing code, for sure.
But to say that the only people who enjoy building software in this new way are those who hated coding, technology, or problem solving is simply untrue.
I realized I most enjoy higher level problem solving but don’t really enjoy implementation. Like I enjoy algorithms, data structures, memory allocation strategies, SIMD optimization, etc. But writing the code, and debugging it is tedious and takes me out of flow.
And if I’m really interested in the project itself then the algorithms take a back seat and I enjoy the even higher level problem solving of building a cool project.
I don’t think it makes you lesser to enjoy these things more than literally banging out code, and hunting down bugs. Perhaps I’ve written enough code that I don’t find the same joy in that. Who knows.
Let's not forget that there is this silver lining of the tech. We can be free[1].
__
[1] Requiring a one-time payment of about $200000 + a small gas turbine
I love writing code, but I don't love every single part of writing code. In particular, I really disliked getting stuck on some irrelevant detail, some mysterious error that had nothing to do with my code (dep issues, OS quirks, silent changes, auth failures, researching alternatives), and spinning my tires, unable to work on what I wanted to accomplish. Often I never made it through the far side; I've got a project directory littered with half-finished projects.
Having an AI to figure all that junk out for me so I can focus on the thing I want to build is fantastic. I worry about losing the grip I still have, but for now I've lost some things I loved (a lot of actual code-writing, solving nice straightforward problems), but gained what might as well be superpowers to help with some real shortcomings I had. It's been a net-positive trade for me so far.
And none of my personal projects have made me rich yet...
I enjoy what I do but I confess to being “in technology” because I need to earn a living not because it’s some sort of passion project. I think it’s pretty horrible to wish us all out of job so you can feel superior again.
The stuff I’m building is things I could only dream of before. With LLMs, I can build things in a year that would have taken me a lifetime before.
In the corporate setting I think though it won't take a lot of time to reduce the layers and number of people that are required to run a software company. Either one becomes a more general work manager or obsolete I guess.
All of your potential customers are just going to vibecode their own software. In many cases they won't even realize that the software they vibecoded even exists as it will just be an invisible tool the LLM built for itself to reproduce a similar solution to a similar prompt over and over.
Once AI flattens out any company enough, the company itself no longer needs to exist, it can trivially be replaced by the model providers. Companies exist to be collections of skilled people with a common goal. When you don't need that, you don't need companies. The agents can work for your customer instead of you and nothing changes except who gets paid (not you).
There's a ton of magical thinking out there where people seem to assume AI will progress right up to the point where it is maximally beneficial to their job without replacing them. Keep huffing that copium, folks.
I've commented previously that there will be much more political interest in AI causing unemployment when the first CEOs are replaced.
That's going to happen. It's part of the "creative destruction" of capitalism. If AIs maximize shareholder value better than some CEOs, those CEOs are toast. They either get replaced in the same organization, or a new company arises and crushes them.
Just imagine what would happen if JP Morgan did this and the model decided it needs to dump their position in AI data centers. Or maybe it's a health insurance company that fires all of the claim deniers for being unaligned with Dario's ethics.
Because you are singularly right about the issue? Have some intellectual modesty, brother.
AI is great enabler for stuff that you don't want to be good at, it cut a ton of chore type jobs out of my workflow, but for stuff you do want to get better and care for, it's both joy killer, and if you're not careful you will only learn how to prompt, not how the stuff works.
I love code as a craft. I love spending time designing the perfect abstraction. I love seeing it come together in the implementation stage. I love the troubleshooting process and the understanding that comes when you finally engage with the root cause of the issue. I love all of this so much that I ship little, all my time is spent in process.
I also love code as a tool. I love working tirelessly towards describing a goal and then watching it come to completion. I love knowing my projects consume terabytes of data and spit out useful results. I love seeing my assumptions on the outcome proved right or wrong.
Now I can do the latter without the former, and it leaves me deeply conflicted. A large part of me is more excited than I've ever been. Another part of me is quite sad, and this is unfortunately the part where my ego lives. For now, I keep it in check by asking the LLM to describe the pros/cons of alternative architectures. That way I stay learning about the products I create.
So it all wishes and prayers? no wonder software quality is down.
I ultimately think learning how other people structure programs is an enriching task and not one that should cause you to dig in and discredit differently-shaped approaches.
Learning from others is great. But there should be actually something to learn. When someone says
so long as you're not writing the code or specifying exactly how it should work.
It means they’re not creating software. They’re just playing with randomly generating something.A software is the recipe for some process. The code is the formal version where everything is exhaustively specified. Not thinking about the code means you’ve stopped thinking about the software somewhere and no longer can say if it’s ok or not.
Axiom: A software is the recipe for some process. The code is the formal version where everything is exhaustively specified.
P: Not thinking about the code
Q: means you’ve stopped thinking about the software somewhere and no longer can say if it’s ok or not.
To further go with my point, it's like explaining how to make a cake and you said that instead of a recipe, it's fine to provide just the name of the ingredients and a general instruction like: mix everything together and put it in the oven.Modern computing is an exercise in trusting abstractions and then zooming into the abstractions and figuring out what went wrong when something breaks. Just because I wrote a web route doesn't mean I've audited the code behind the web framework, the event loop, the HTTP implementation, the TCP implementation and so forth. By your argument then I've already stopped thinking about my software and can't tell you if it's okay or not.
I'm sympathetic to both the perspective of sadness from the loss of hand coding and the perspective of joy from working at a higher level of abstraction, despite its costs in understanding. It actually seems very simple to me to hold both perspectives within me.
Once that’s done, there’s a matter of accountability where you can report the issue to the people responsible for that. Then because they know their own code they can repeat what you did and try to find where things went wrong.
That chain of accountability is the main issue there. We still have tower of abstraction, but no one knows about their layers. Accountability is lost and with it the trust is gone.
I never care about code, whether you wrote the majority of it or it’s just a glue that hold several library. What I care about is that the semantics of that module that I interact or build upon can be trusted, and when something wrong is an accident and not a daily event.
Even when you’re writing an application and not a library or a platform, you’re not free to write whatever. Your users depends on you, and themselves may have clients that depends on them. Being cavalier about what you write is just recklessness and in any other (real in some countries) type of engineering, it would be labelled as malpractice.
Right this is the main difference between our viewpoints. I don't work on completely open systems. A lot of my life I've worked on closed platforms, cloud runtimes, a mix of work that's been in my control and out of my control. I've filed my share of AWS tickets but ultimately most of them ended up not fixed by AWS. I've made peace with not having accountability for layers of the stack and am comfortable assuming that there are bugs on the foundation that I have to work around.
> Being cavalier about what you write is just recklessness and in any other (real in some countries) type of engineering, it would be labelled as malpractice.
An old critique of software engineers that I've always found flimsy and find that Hillel Wayne addresses well: https://hillelwayne.com/post/are-we-really-engineers/
Software is built on wishes and prayers. Programmers don't ship pixels to be installed in monitors, nor do we (mostly) work with compiler internals. We write a detailed set of instructions and hope that a bunch of systems we don't necessarily comprehend follow them well enough to get the intended results. It works because some folks got together and wrote down their wishes and prayers so good that others were able to understand and follow them later.
I've done a lot of functional coding in the past (in academia, in Haskell as a hobby, and Scala for a unicorn where I was an early hire.) This probably affects how I think. But I find it quite natural to organize my code this way. After all the fundamental data structures and the hierarchies relating them are what often determine core properties of your programs such as being CPU, Memory, or IO bound.
I also work as a pretty senior engineer and my tasks before agents were usually about leading a team to implement something. I would often do the v0 implementation to make sure we met customer requirements and then take a step back and help the team scale the service up. These days the team is a lot smaller and maybe just another engineer; the agents make up the rest.
so ... this conversation isn't really about you then, is it.
For example recently I did tiny little hobby project, taking metrics of ESPHome/homeassistant MQTT and pushing it into prometheus. Coded the main parts, told LLM to do the boring part of setting up test suite, guided it thru making tests, it worked fine, tested it, then told LLM to do another boring task, taking all the datatypes it support and unit conversions (which is hundreds).
I got to do all the fun design stuff, but had code review assistant that also did all the boring tasks.
It's like making animation but you only have to make keyframes and initial coloring, with AI filling the blanks, just cutting out the tedium
so it's just like making really crappy animation?
You're saying that I must not be good in writing tests, irregardless on how I feel about test writing.
I’ve been coding over four decades and it is clear to me that most programmers don’t know how the stuff works, and not just script kiddies but some PhDs I worked with.
For those who want to know how it works, LLMs are massive enablers. I’ve written so many debugging and inspection tools with an LLM; had a model explain the assembly language produced; had rubber duck conversations with it. I’m having such fun tbh.
You are aware that the LLM (or anything/anyone) explaining stuff to you is just going to atrophy if you don't use it, so maybe you weren't actually learning but just scratching a curiosity itch.
On the road to wire heading.
I think the benefit is that now I get to choose what I want to focus my limited attention on; from a much broader range of subjects; with expert knowledge on tap. For sure, some of it was just scratching an itch. I didn’t waste much time getting to that point before I could go down another interesting rabbit hole. It’s just much more fun!
I venture to say that this number is small. Most SWEs get into it because they don't view writing code as a "burden".
The people who are "liberated" aren't the SWEs, it's the people higher up the ladder than the SWEs, who can't or don't want to be bothered with coding anymore. For them, managing a fleet of agents is easier than managing a group of SWEs.
I don't think it's fair to say that all SWEs swing one way or the other. I absolutely love the fact that I will never have to waste time debugging cargo culted, trendy libraries ever again while I am also sad I'll also never to get hand write elegant implementations of interesting problems ever again either (unless for fun).
I would be happy to keep writing code but I'm also happy to be liberated from the type of code I was often paid to write.
Agents help you bang out good code faster if you know how to use them. My relationship to Claude and DeepSeek is somewhere between an IDE, a coworker and a friend (I still have real friends don't worry).
I don't treat it as a world changing magic wand that fundamentally changes the way everything works. It's more like a fast forward button that lets me skip the boring part in exchange for some hand holding. No more dealing with syntax errors or finding trivial bugs.
This always read like
Writing sentences was the annoying part. The fun come from sharing ideas, optimizing for brevity, making the rhythm flow better and words more impactful, all things that are on the level of communication, and not grammar.
Then you start wondering about the actual level of education of the person and their claims about writing a nice novel.Code is formal writing. Expressing an idea in such formal forms means you have thought exhaustively about the evolution of the algorithm/process. If you’ve not done that, you can’t guarantee the correctness of that algorithm/process. Is it just toying around with an idea of software?
but most SWEs are being pushed to delegate the _thinking_ to agents.
so instead of "here's a solution to load this page faster that I came up with: X. Implement this in JS", which is along the lines of what you describe, most people are doing "this page needs to load faster, what's the best way to do that?" claude: "X". "OK, implement X." What fun is that? What's the point of developing skills and acquiring knowledge if you can't use them anymore. that's the loss.
If all you care about is having pages that load fast, then yeah, agents are great. If you care about being the architect who figured out how to load pages faster, then agents take the wind out of your sails.
"you need to improve performance of the graph especially rollover and highlighting it's VERY Slow there are too many updates"
In the past I would have cracked open a profiler, and spent a couple days probably tuning this thing. I probably would have gotten a big dopamine hit and felt really accomplished when I finally got buttery smooth performance.But I'm happy to delegate this task to the agent, because this is one step in 1000 steps I have to accomplish, and no I can't just tell the agent to accomplish them all from the start because I don't know where it's going. I'm very very happy I don't have to waste a day making the graph load faster, because I can get back to my real work, which is not making graphs load faster.
At the end of the day, solving that problem will make someone's use of my project a little better, but it's not adding value to anyone's life -- that's what the project is (supposed to be) for. In the past, it was those little problems and 1000s more like them that would derail a large project. Today, they are mere bumps in the road, so the large project has a better chance to come to fruition.
in this context, those are really 2 different things. what people are lamenting is the fact that "I built a career on building these skills because it's something I care about doing with my life, and now I'm being relegated to QA at best, or replaced at worst". That's completely different than, "I can now get my personal project out faster, or maybe create 10 personal projects, and can have the agent take care of the parts of the project I don't really care about doing (like improving graph performance) and focus instead on the overall design of the project, more features, etc.".
It's like going through med school and residency to become a doctor, and instead of practicing medicine, you're feeding prompts into an AI and passing on the responses. Sure, on you might appreciate not having to field medical questions from all your friends and relatives ("personal project"), but that's not your career.
I can appreciate that perspective, but at the same time: it's a job, the whole arrangement is you sign away your autonomy, you do what you're told, and people were paid more in one year than I've made in 5 for this. Now the balance has been disrupted, and that's a shame, but the gravy train can't go forever. Moreover, this particular job, software developer, has changed fundamentally again and again over the years, and those changes definitely disrupted people's careers, so although the blast radius is significant, this too shall pass.
And we're not exactly talking about doctor-level of training here, it was only about a dozen years ago that it was very fashionable to land a 6-figure salary at a top Silicon Valley tech firm after having only attended a bootcamp, for a job that was characterized as being a "code monkey". The whole thesis of the "Theil Fellowship" was that the job was doable without any formal education at all. At my institution, the CS major was the most popular because it was the shortest path to the largest salary. Now that equation has changed, no one wants to be a CS major, enrollment is through the floor.
> you're feeding prompts into an AI and passing on the responses.
Okay but is the job writing code or building software? A lot of people seem to think the job was writing code, and that's what they liked about it, but it was always the case that if you like your job it's not going to pay well. That software engineers were paid so well to do something they love is an aberration, not something to expect forever.
As a teacher, I definitely understand this. I love my job, doesn't pay well, and it's also changed fundamentally as well in the last year. So I empathize -- I used to grade student papers which was rewarding; then all of a sudden I was grading LLM output, which is not. A lot of my colleagues have complained endlessly about this, have made it their job to become the LLM "police", or have quit the profession entirely because like you said it's not how they started in this field. It's bleak.
But you can also adapt to the times. We just completed a module where students use AI to create games in Lua, and they made the best games I've seen in years, each one different and unique and fun. Before the class was "we'll spend 4 weeks and hopefully we'll get to animations if we're lucky". Now the final projects are all animated with interesting gameplay mechanics, graphics, animations, and they're all different despite them each using AI. I like this situation better.
> A lot of people feel replaced now that the writing of code is being shoddily replaced by the burden of interaction with AI.
It's stupid.
I never cared about the social aspects of it other than releasing the odd plugin I developed.
My social life is entirely offline.
Speak for yourself.
However, most code is corporate CRUD stuff. The world sort of runs on CRUD. But it's rarely particularly fun, or beautiful, or fulfilling. It tends to be pretty ugly because there's rarely time to make it beautiful. So I'm not losing much joy there.
Additionally, even with an agentic workflow, my team still thinks deeply about architecture issues. We believe that well structured code is better for bots and humans alike. So I am still exercising my engineering brain; I'm writing blueprints and supervising the bricklayers now instead of laying bricks.
Does that match your teams' experience at all? Sometimes I feel like folks on these threads are working in a parallel universe where the majority of coding tasks and somehow fulfilling and fun and not 99% tweaking reports, trying to implement arcane and contradictory business logic, or fighting with shitty and frustrating externalities. Maybe people found joy in those aspects. I guess there are all types of people in the world. I mean, I'm a sicko who loves writing SQL, something that most coders seem to hate.
I've been direct with my team about it being a legitimate
feeling of grief and the grieving process that comes along
with it. It's been helpful for folks to hear that they aren't
alone in that feeling.
This is super great. God, I wish all leaders had half this much empathy! Good on you.Those are the parts the LLM is bad at. The 1% of stuff that was interesting was worth looking forward to.
I’m unconvinced about architecture mattering much. I used to think that, but these days I’m leaning towards it being the product of a problem we don’t have anymore. Architecture used to be dangerous and time-consuming to redo. If an AI can do that safely for $100 or $1000 in tokens (one day), that ROI is maybe negative
I guess you’re right, though - what is the ROI of keeping the architecture clean? It certainly saves time and money later, but it’s unclear if it’s a net win.
(It’s of course also significant to note that the upfront work of figuring out the right architecture and keeping the code clean has also been correspondingly reduced as well. Both sides of the equation are affected…)
The industry never really figured out a way to reliably answer this question in the pre-LLM days either, so… I suspect it will continue to be hard to determine.
I find that I struggle more with personal projects, as I tend to take things where I'm not even in the skirts of the learning curve, and consequently redo my work a few times.
Where do you work! :)
I think the technical freedom plays a big part, not because you're chasing the shiniest, but because you're choosing the tools that will hopefully outlast you. One of my former employers was 'modernizing' their IBM i (former AS/400) systems by porting them to Java and Windows Servers, and they were having all kinds of problems. Couldn't even get the EBCDIC to Unicode conversion quite right. I was lucky not to be there anymore.
But I'm sorta old and some of my school's texts were outdated so they had programming examples and explanatory text that treated EBCDIC on equal footing with ASCII.
So unlike anybody who dealt with EBCDIC conversions in the wild, seeing that acronym actually takes me back to happier days!
Generally the only way to get it done in a corpo environment (and receive any kind of thanks or glory, as opposed to just torpedoing your own career) is to let things get so bad that production stability suffers and/or the team's ability to ship features is severely impacted.
...I realize I'm basically just echoing what you said, except more verbose. I'm venting!
With massive amounts of effort and strong communication it was usually possible to get some tech debt time, but management acted like they were doing YOU a huge favor. It was kind of a career killer, generally.
Alternatively it was possible to get this kind of work done on my own time… but that’s a marriage killer instead of a career killer.
I burned out on trying after decades.
Shitty devs without AI are slowly building BS that wants to be cleaned up.
Shitty devs with AI are much more fasterly building BS that wants to be cleaned up.
I have a similar experience as yours, just add another 10-ish years to the timeline. Literally my first job out of uni, I got to work on a legacy code base that was another 15 years older than that which had a ton of reports all built differently over time with slight variations in both code and end user output that really all wanted to be "the same" both on the code and end user side. So I slowly but surely, one user/PM requested change at a time would build out a common layer of abstractions and shared code that both made the code shared and easier to maintain (great for me!) and consistent for users (great for the PM/users).
Heck, I built a rudimentary TransactSQL parser that'd output stored procedure call graphs to graphviz and then I printed it and hung it on the wall to get through all this and having an LLM to just make a mermaid out of this in 5-ish minutes would definitively have been faster than I was ;)
With an LLM all of that would just have been faster to do but still worthwhile and useful on both levels. I.e. both code abstraction/reuse and PM/user level. Similarly there was a report that one of the devs had to actually run manually and it took him a full week, so users that wanted the report would only request it once a year-ish. When I was asked to learn how to run it from him I was appalled and just took that week to put it into a script that we ran and emailed the report out once a month automatically. They ran that report manually like that for like 10 years prior to that :mindblown:
None of this is an "AI thing". It's a good dev vs. not so good dev thing. And none of it really has to do with coding as in "writing source code" as much as "solving problems for humans" somehow and the "language" you do that in changes over time. If you're the guy that's tied up with the particular language: yeah LLMs are gonna eat your lunch. If you're the problem solver type that uses whatever tools they have available, you're still in demand.
Disclaimer: I had to take an opportunity at management in cybersecurity, and haven't coded in about five years. It helps a lot when talking to developers about risk mitigation, though.
The nicest thing was when you nailed down the architecture and then you are mostly twiddling your thumbs while waiting for the PM guys to have the next feature idea. Maintenance and bug fixing is a breeze.
I have no idea where you work but 90% of companies are not like that. In fact, it's the opposite: filled with awful management, terrible timelines and legacy code.
Engineering had always been a nuisance to them and getting basic approval for maintenance regarding technical debt has been an uphill battle.
One of the fun things to do would be to use the 8 hrs of work to spend about 4-5 hrs working on deliverables, which was usually sufficient to exceed expectations, using 2-3 of the remaining hours (I’d keep 1-2 hrs for myself), to make significant architectural improvements.
I’d bring in an improvement every 6 months or so and suddenly the app would get significantly better and I’d get credit for it.
Well, that is not entirely true. The British parliament made sabotaging work machinery punishable by death. So people did in fact get hurt, the people who were hurt were the Luddites, and the people hurting them was the British state executing them.
The Luddites only wanted to keep their jobs.
Brother, they're you. You just don't realize it yet.
I have very mixed feelings.
- AI lets me plough through issues which previously would require debugging, troubleshooting, googling, stackoverflow
- my coding abilities are starting to atrophy
- not having to deal with low-level language quirks is nice (parameter differences of subString in C# vs Java).
- but I'm seeing the same as OP: when working on a team, the sense of ownership and community is gone. You have AI un-AI-speak for you to properly read the Jira ticket another dev created using AI. Pull requests are echo chambers between the AI used to create it, review bots, other devs using AI for PR reviews manually.
- there's little denying that we devs are feeding the very machine that will replace us
That is a problem though with AI currently. E.g. I've found a severe issue with Claude Code and prose writing when trying to make an explainer site. Instead of "plain" english it likes to use "flowery" phrases and "punchy" statements. This forces the user to spend extra time thinking about it.
And code comments are terrible. It can use 3 paragraphs to describe something when only one sentence is enough. Then further agents (or humans) have to waste their context window to figure out what the "riddle-ly" worded sentences mean.
But the things you care the most about, the AI doesn't unless you tell it to care. And even then, you have to be very careful because it acts more like a contractor with the potential to stop in the middle of a project (lack of tokens) and leave it in a very bad state until it's complete.
Or worse, it forgets what you want and does it's own thing for a while until you remind it.
The big money valley bros figured it out just before they embraced regressive conservatism for their politics. There’s a reason we went from massages and pet daycare to rentier agriculture executive style management of the peons.
And that reason is "service businesses are too expensive in California because of high housing costs".
(Also because of firefighters. And American urban planners who basically believe their job is to stop any project that anyone ever objects to.)
The looming thing today is qualitatively different, because it's not formalizing something to reliably mass-produce.
In theory, but not in practice. Instead, somehow we ended up writing essentially the same app over and and over, usually without reusing libs. You know because this time we'll use vue, or svelte, or phoenix, or htmx, or go, because this time we actually know what we're doing. so gotta start from the ground up and figure out how to store a row in a db as if we haven't done the same thing a million times before.
And that all under one roof. Now multiple that by thousands of roofs.
At least the devs were having fun and making good money writing all that code.
Well, no, for a lot of us, there really is no other side. Slop farming is not software engineering and it never will be; scribbling some Markdown that begs agents to omit bugs is not equivalent to using high-level languages with thoughtful abstractions to directly define program behavior. I didn't want to be a manager when I worked in the industry and I certainly don't want to be one now. Moreover, it's downright offensive for a purported expert to defer their expertise to a SAAS black box.
On the bright side, we will probably (eventually) self-segregate into communities that code however they want and leave the other side the fuck alone.
Would you look at a piece of code elegantly using high-level abstractions to model some problem written by a human and go "see, look, code is beautiful"... and then look at the exact same code written by an LLM and say "this is slop"?
> Moreover, it's downright offensive for a purported expert to defer their expertise to a SAAS black box.
With programming, it's just the opposite, though.
Programmers work with abstractions. Understanding the full system down to how atoms work is too much to think of when e.g. writing an API handler. So instead you work with modules and their interfaces.
Pre-LLM, if you need some task done, you wouldn't write it all out yourself if there was some external package which did the work for you.
Of course, when using an LLM, you don't need to surrender your ability to think about the problem and solution.
> High-level programming languages use well-defined, limited syntax to encode program behavior in a deterministic way. Compilers translate these directions into programs that should have identical behavior between compiler runs and between different compilers. (If they don't, that's a compiler bug, or else an artifact of UB.) This means you can structurally and provably rely on the high-level programming layer without worrying about what's underneath: the assembly is abstracted away. You also get the massive benefit of being able to tweak and improve the assembly layer independently of the programming language layer, so long as the contract between language and compiler is not violated.
> If AI is a "layer of abstraction," so is working with a bunch of contractors to make your app. The definition is broadened to the point of absurdity. (Solely: "I don't have to think about code anymore," which only touches on the most superficial aspect of an abstraction.)
With a good high-level abstraction, I can mostly think on the level of the abstraction, but I can also dive down through the layers and figure out what's actually going on in each one.
> Would you look at a piece of code elegantly using high-level abstractions to model some problem written by a human and go "see, look, code is beautiful"... and then look at the exact same code written by an LLM and say "this is slop"?
Using is one thing; inventing is another. I have seen no evidence that LLMs have the capacity to discover and leverage new abstractions. To me, that's the most exciting part of programming: finding ways to reify powerful concepts and then turn complex tasks into simple ones, ad infinitum.
We had our work stolen and they're squeezing us with it, all for garbage, what in the world are you talking about.
I love writing code. But I also love solving problems. AI allows me to solve problems in different ways. And I am totally enjoying that as well. If someone got into this SWE only to code, yes, they may not love where things are today and appear to be going in the future.
I certainly did not come to computing to be a manager, in fact I already had that role and freely downgraded myself.
In my case I had prior experience with tech support and I saw lots of people struggling to use computers and it's interfaces.
So my joy comes equally from coding or seeing people relieved that their problems were solved.
With that mindset that I'm able to fly with Claude or codex.
And even doing my comp sci more than a decade ago many professors told that I should worry more about the outcomes and what problems I'm solving, instead of building this life game around coding only. So I'm grateful for them.
Maybe that can help other people getting out of this dread feeling whenever they are using A?
My frustrations changed, nonetheless, with AI. When it forgets cases that the LLM session and I forgot to cover, that for me is pretty obvious if I had or gave more time to evaluate and review things.
This week I realized that running a separate session and asking dumb questions about the plans and recent pull requests helps grounding again.
The lack of AI mental model between conversations or even within the conversation is a definite frustration. “No, I didn’t just decide to entirely change everything I’ve planned based on one ambiguous word…”
Your use of a separate session for q&a is actually something I find interesting in the new Granite Switch architecture’s KV Cache Normalization, where the kv cache is essentially frozen while the model performs certain other tasks in order to prevent the mental ‘conversation’ from getting polluted. However, I’m also assuming what you mean by “helps grounding” is that it helps keep the agent grounded in the context by not introducing a bunch of external information, which is certainly beneficial.
What's the point of contributing to OSS if anyone can just LLM wash your work knowingly or unknowingly? You won't even get credit. Heck, you won't even know if anyone is using it!
But then what if you have a larger project than a library. Do all the leg work figuring out what works and what doesn't. What users like. Then anyone can just point an LLM at it and clone it for $50? Fun.
Those of us who refuse to use that stolen labor are loosing our jobs, fast.
I'm sure word is getting around of MBAs and etc getting access to GitLab and using AI to make python apps. Look, you don't need devs anymore?
Okay, but wouldn't a software engineer be better at that? "No, because I'm an SME, I know finance!". Right, but the LLM knows finance?
A year ago these tools were assistants, copilots, but know.. It's clear if the pace doesn't plateau or slow greatly we are headed towards replacement of massive swaths of knowledge workers.
And it risks completely destroying our society due to the economic fallout from mass unemployment..
-- Paul Krugman, 1997
Note this does not say "it will decrease if we suddenly invent new productivity technologies".
I am fine with people using my work, copying my source code, and distributing derivative work. I am not fine with AI companies stealing everyone’s work and renting it back to us.
Did they steal Wikipedia? Wikipedia is still there.
This would be true even if I signed a contract stating that I give all my labor away for free to my exploiter. You cannot sign away your rights like that, and my exploiter is not allowed to abuse my goodwill this way.
You are basically arguing in feudalism. My labor belonged to my landlord and they had full right to take all the profit for them selves.
Previously when I licensed my code with a liberal license I got something back, credit, contributions, connections, job opportunities, etc. The AI companies stole my labor, then they demanded I pay them, and finally they took my job.
It's a bit like Bob Ross' Joy of Painting: if everyone can paint then anyone can make any painting they want to see.
- The freedom to run the program as you wish, for any purpose (freedom 0).
- The freedom to study how the program works, and change it to make it do what you wish (freedom 1). Access to the source code is a precondition for this.
- The freedom to redistribute copies so you can help others (freedom 2).
- The freedom to distribute copies of your modified versions to others (freedom 3). By doing this you can give the whole community a chance to benefit from your changes. Access to the source code is a precondition for this.
Note that "preserve licenses" and "preserve attribution" are very much not in that list. Well, the Four Freedoms are what these AI doohickeys enable by being able to in theory reverse engineer or replicate any code, making all code effectively "public", and to bypass any copyright issues around distribution. The fact that AI blowing away the existence of proprietary code also blows away the licenses of FOSS licensed code is a harmless side effect of getting to the Four Freedoms, which was the Free Software goal all along.
If any of this is surprising, then you didn't understand what you signed up for. The AI monkey's paw has curled and you've got what you asked for, sort of.
FWIW, many of us who do open source would also find that hypothetical world in which the idea of copyright is abolished rather enticing... but you pretending that is this current world whenever you want to steal our code whilst copyright still paints our interests in using and altering the code from companies that have always been in fear of our community and our licenses (Apple, Microsoft, etc.) as theft is not merely a bit shitty... it is kind of evil/cruel.
And on the first part about AI reading your code or training from it, it does seem like it's legal now, while you as a human reading and porting is not.
As far as I know, A is still illegal, and nothing at all has changed that situation; if it did, it would be shocking, as it essentially undermines the entire legal framework of copyright, and it would be making national news and destroying -- not harming: entirely wiping out -- major software companies.
The only thing I think people have really litigated in the courts is B (as the obvious defendant is the juicy maker of the model rather than the users of the model, whereas they might be able to dodge culpability in C and even A), with the result that it is very likely legal... but, while that might be a bit frustrating, it was never shocking: a model is a highly transformative use case vs. the original code fed into the training.
However... B being legal doesn't actually imply that C is legal -- even if a ton of people fail to appreciate this distinction -- and C is where the war is starting to be fought. Instead of software, I think the most interesting avenue for this to become scary for people assuming this is legal will come from lawsuits involving the music industry (which tended to lead the pro-copyright cause in many of the skirmishes I was involved in while working on device freedom issues).
That said, people really focus too much on C, hoping for that grey area in both the law and in their analogies, when what developers are actually doing now is often A: the model has become an agent that uses tools, has access to the Internet, pulls code off my got repository, and is essentially just running a non-deterministic transform on that data sitting in its context... I have heard nothing that makes it sound as if A is "legal now".
the functionally same product is still being made, but there is less human involvement in the craft, and more of a human management over the manufacturing process
Or during a sales meeting, an experienced engineer can have a quick prototype done to show the client.
But none of this is going to bring back actually writing code for the love of it. That will become a hobby kind of like knitting or sewing.
Another PR and technical debt.
Everything is weird now.
There is this belief amongst software engineers that humans are always part of the process and that AI prompting is just the new IDE. Yet, every new model release is even more optimized to replace programmers and is pushing us one more step closer to that reality.
Right now (Fall 2026), we focus on empowering agents and LLMs and that's the current challenge facing software. However, once we solve that, the LLM really can kind of take it from there.
I know I'm being dramatic when I say this, but it really is how I'm starting to become jaded from all of this AI tech. It looks more and more like we're becoming a world full of really brilliant humans who are bored because there aren't any intellectual problems left to solve. That is not a utopia. That seems like a dystopian nightmare.
But in the last year you just don't get these jobs anymore, due to AI. It's everywhere and I totally understand the feeling uncreative people get when they are finally given a tool that lets them create something.
What makes me depressed however, is seeing that the vast majority of people are perfectly fine with AI slop posters etc... Highlighting to me that they likely didn't actually value or appreciate the good design to begin with. A lot of people don't care about the human element to anything.
I think this is a crucial point. The AI era seems to bring out two distinct movements in people: Those that always saw the human as a necessary bottle-neck, and those that actively sought and enjoyed interacting with another human brain.
Yep. The problem I feel is that humanity and society evolved via human interaction over the span of tens of thousands of years. And then in the space of a decade some of the people who benefited from that development feel so comfortable in their lives that they seek to literally end that method of progression for our species.
Being able to program means in particular, you can read those programs and understand what they do.
What happens when you don't understand them anymore?
Living in a reality where everything is a black box, doing its thing as if by magic, leaves you in a position devoid of control. The objects upholding your life are incomprehensible to you, you cannot change them or even only reliably exchange them with alternatives.
The chilling bit is that the machines are doing just fine on the understanding programs front (up to and including decompiling them from machine code).
And even if you understand how it works, how does it affect your day-to-day function or the advancement of the field? As Apple liked to say, It Just Works (TM).
Instead of driving you're telling a piece of nondeterministic software where you'd like to go and then watching the result as a passenger.
Would you be willing to drive one if the engineers at ford were all fired and an almighty agent who kinda did the almost right thing most of the time was designing the black box?
So yes, maybe we will all just exist to get sued at the end of the day.
For me it's about losing much of the entire career, because companies will come to expect AI-level work that I can't/won't provide.
> Being able to program means in particular, you can read those programs and understand what they do.
IMO This assumes that one views programming as more than just a job/career, but not everyone does so.
> Living in a reality where everything is a black box, doing its thing as if by magic, leaves you in a position devoid of control.
For some, this is actually relieving. Sometimes we want to be more ignorant, sometimes it makes us happier.
The point isn't some people not understanding whatever stuff with limited effects, it's no people understanding anything important.
Mathematics is about describing fundamental reality, so you can change it. When corporations own it exclusively, they can do whatever they want with it.
Using an LLM doesn't mean "I must write this code in a way that I cannot understand it". I'd encourage using the LLM to write code in a way that you can understand.
> When corporations own it exclusively, they can do whatever they want with it.
This is an argument in favour of open-weight models.
- Eric Hoffer
Wait... What's that you say?
This is analogous to coding as a profession versus for fun. For work I'd use all the tools at my disposal to get the job done because that's what matters in a corporate environment. And for home, well, I'll code some things and vibe code others, depending on how I feel about a certain project. I think OSS maintainers lean too hard in setting themselves and others too high of expectations such that they burn out like this, many such cases, when in reality they shouldn't take it so seriously. Work on your code when you want to and leave it alone when you don't, the license literally says "as-is," so follow that philosophy.
Probably the LLMs saved me because deep down I knew that my own power by itself wouldn't be enough to let me do what I really want, but right now the future does seem bright.
If not all agents are equal and require calibration, then it seems like people can specialize, so you're only competing with other specialists in that area (and not necessarily trying to out-compete).
This idea that there is 0 skill to using them is the opposite: it requires far more skill because the human has to manage the whole building all at once rather than focusing on putting up one beam at a time, one rafter at a time. Your responsibility is totally different. It has to scale far higher!
Many devs have had strong leads that do the ticket work, that figure out what to do. It's unclear what role there is for those folks now.
Anyone can do work on their own car. It's not especially hard.
But a professional working on their own car knows tricks and has tools / ways of working that a regular person doesn't have access to.
You can tell the difference in the result if you know where to look.
Sometimes it matters: the way you change some components matters - and while you're there with half the engine bay cleared, you can fix a few other things that usually fail in this specific model.
Sometimes it doesn't: oil change is hard to fuck up, but not impossible.
The the things I've made with agents aren't hard to do for anyone, but I can claim that I can pick up any of my projects 6 months from now and confidently add features without worrying about stuff breaking or the agent doing crazy crap - because I build the limits into my projects by default.
It's surprisingly easy to do that shit properly when budgets and time aren't an issue.
For the vast majority of software that isn't the case at all.
"right now the future does seem bright"
This reads like "Fuck you, I've got mine." Who cares about those wage workers anyway, right?