我並未請求這樣做，你們也沒有。
我並未請求讓機器人來消化我寫過的每一篇部落格文章和程式碼，然後轉述給某個駭客，讓他能從中獲利。
我並未請求將程式設計師的角色貶低為一個光鮮亮麗的 TSA（美國運輸安全管理局）幹員，負責審查程式碼，確保 AI 沒有偷偷將危險的東西帶入生產環境。
然而，我們現在就處於這種境地。這些工具最糟糕的事實是，它們真的有效。它們能寫出比你我更好的程式碼，如果你不相信，再等六個月看看。
你可以出於道德原則而選擇退出。如果你職涯已近尾聲，這當然沒問題。如果你剛開始職涯，你不需要我來解釋這些，因為你已經在使用 Warp、Cursor 和 Claude，並將 ChatGPT 當作你的心理治療師、配對程式設計師，甚至可能是你的情人。這篇文章是寫給我的觀眾中那些還沒意識到這個事實的四十幾歲的人。
所以，作為一個資深開發者，你可以選擇退出。但隨後你的初級同事最終會在程式碼上超越你，因為他們穿著裝有火箭推進器的噴射背包，而你還騎著單速自行車。最終，你的老闆會開始質疑，為何你領著同事的兩倍薪水，卻只產出十分之一的程式碼。
最終，如果你有房貸、車貸，還有你深愛的家人，你將會做出你的決定。這或許不是你年輕、更理想主義的自己會希望你做的決定，但它能確保你的汽車、你的房子以及你家人的安全。
總有一天，多年以後，我們回顧我們是最後一代親手寫程式碼的時代。我們會笑著向我們的孫子孫女解釋，我們用手指打出 JavaScript 語法是多麼愚蠢。但我們內心深處會懷念它。
我們會懷念將程式碼握在手中，像雕塑家撫摸黏土一樣塑造它的感覺。我們會懷念為了某個奇怪的 bug 而徹夜奮戰，最終在凌晨兩點用調試器解決它的感覺。我們會懷念創造出讓我們感到自豪的東西，真實、正確且美好的東西。我們會懷念藝術家在油畫底部的簽名，GitHub 儲存庫上寫著「這是我做的」的那種滿足感。
我不慶祝這個新世界，但我也沒有抵抗它。太陽升起，太陽落下，我無助地圍繞著它運行，我的抗議無法阻止它。它不在乎；它會繼續在天空中劃過它的軌跡，移動但不動搖。
Well, there is still the problem that the code must be reviewed by a senior developer. So the question is how of people get to be senior developers if the AIs van doo all the entry level stuff just fine.
Really, it is far more than that. Our capitalism economy is dependent on labor. The Economic Loop: Labor->Wages->Income->Consumption->Revenue for company … back to labor All parts are needed for economy, a system that was built. Capital will always want to replace labor, to cut costs, but that will break the economy. Capitalism self destructs. Survival is not built into corporations, mostly short term profit and competitive advantage. Expect: Acceptance, then Panic, then re-branding (cognitive workers are essential), then protection (bail out and regulation). When automation becomes a threat to order by embarrassing the cognition workers (and company officers). When recommendations from AI out perform CEOs, lawyers, etc. Then who gets bailed out?
I’m pretty far along at solving this problem, but it will take a little longer. It is a far larger problem than it looks. The real problem, ultimately, will probably be over production.
Well, there is still the problem that the code must be reviewed by a senior developer.
I used to think this is true, but I’ve come to believe the next step is to have AI code reviewers. (And refactorers, and security auditors, and performance benchmarkers, etc.) I cover this a bit in AI tribalism . This is the future that projects like Ralph and Gas Town are pointing toward.
If you’re right and we’re staring down the barrel of a civilizational collapse, then I don’t necessarily disagree with you, but I don’t think it changes my conclusion much. If we’re due for a reshuffling of job titles then I have no idea what comes next, but it probably looks very different from the past.
Who said civilization collapse? The last time something like this happened was the invention of the printing press. It made a mess, but did not cause civilization collapse. You either need to fix capitalism or replace it. Both things can be done, but really you need to understand what capitalism is. Capitalism, meaning using capital as a tool of production, is needed in all systems from theocracies to monarchies to democracy to socialism. The thing is that “capitalism” has been given another meaning: ownership. It is the reason for the term “ownership class”. It is is easy to see the problem with that because then capital is used as a means of control as a bludgeon or to buy the law. The end result is wealth concentration like we see today. Automation will just make that more true. Wealth concentration will make that more true., Then when the enough of the wealth is controlled by the ownership class that families are unaffordable, the system changes, either by adjustment of law and social contract or the pitchforks come out. Many of the zillionaire class have been saying for years that taxes have to be higher. The thing is that the ownership class isn’t as much the problem, many of them create wealth or guide it to production by capital investment. Unfortunately, part of the ownership class is the “control class”. The ones that want to use wealth as a method of control are exhibiting dominance instinct, which has no off switch. That is the “control class”. They are the ones that have bought the law and fight for control of the working classes. They dominate wealth to do it and are the reason greed can be such a danger, not because of desire for wealth, but desire for control. Wealth is how they gain control. Somehow their control must be removed. It is best if it is done by law, that is taxation, because that preserves order. Nations, businesses and families thrive in order and investment. Historically though, what has happened is that people do not have the “wealth”, the resources, to survive due to Capital Accumulation, and the pitchforks come out – bad for everyone. That control class will call any attempt to limit their control “communism”.
“This is inevitable” is industry propaganda, though. This is far from inevitable.
First, it is entirely likely that the better models simply cannot be economically viable without a technological breakthrough reducing energy use and hardware costs, and when the giant pool of free investment money finally runs out and subsidies are ended, that harsh truth will crush the coding agent market.
Second, we are generating tech debt at a rate faster than any time in history. Back in 2007, Greg Jorgensen wrote “ Introduction to Abject-Oriented Programming. ” It was meant as satire at the time, but read that and tell me it doesn’t perfectly describe how Claude writes code. We’re fighting a losing battle trying to keep code quality high; there was already pressure to compromise (thus the celebration of “10x devs”) and most orgs are going to be willing to make that compromise if it lets them ship software on time for once. What happens when that tech debt finally catches up?
Third, regulation is still not impossible. Hard to imagine in the current political situation, but when the pendulum swings back and everybody’s electricity bill has doubled, the political will to put an end to the industry’s externalities might materialize.
And all of that is assuming this investment bubble, 17x that of the dotcom era, somehow doesn’t pop. Who’s going to pay to run the models if it does?
I say all this as someone who has used Anthropic’s models daily for the last six months, both personally and professionally, who works at a YC-backed startup that was funded specifically because of the AI pitch deck. I’ve hand-written maybe a hundredth of the code I’ve committed in that time. I see the potential in the tools, but the industry is nowhere near ready to handle the level of deployment we have now, and neither are the economy, the power grid, or the climate. My only hope is that in the aftermath of the upcoming crises, we take a long hard look at the dangers and start focusing on mitigation, not expansion.
I agree with a lot of what you said. Claude currently produces a lot of duplicate, verbose code, which is ironic because this is exactly what makes life hard for the next agent. But as I mentioned in another comment, I think this can be solved by additional steps of AI code reviewers, AI bug hunters, AI tech-debt-payer-downers, etc. I’ve already started using this technique in my work, and it shocks me how throwing more AI at the problem really does solve it. This is why Gas Town and Ralph scare me so much – if you’re trying to one-shot or one-conversation everything, you’re going to produce junk, but that doesn’t mean it’s impossible not to produce junk.
When the tech debt catches up, it’s definitely going to be interesting! See my essay The collapse of complex software . The smart companies won’t wait for this to happen, but I do think many will.
Regulation is maybe the only thing that can stop this future; you’re right. I do think though that the energy costs will go down over time, since there’s every incentive to build more efficient models and hardware (we’re still reusing chips meant for gamers , recall). I have a coworker who uses Kimi K2.5 which can run on your own hardware if you want, although he uses a service since it’s faster. I expect though that we’ll run into a Jevons Paradox where even if the energy costs go down, we’ll just use more of it, so who knows how high the energy bill will go.
I’m happy that I’m no longer in the game. I can enjoy my level of knowledge and nostalgia.
They can write code better than you or I can — no they can’t, they can code fast, and maybe they can code better than you, but they haven’t passed me quite yet. Good luck to you.
“I don’t celebrate the new world, but I also don’t resist it.”
This part really sadden me the most…
LLMs are not better at programming than me. If they were, I wouldn’t be inspecting their output with a fine-toothed comb, I’d be rubber stamping it. I wouldn’t be constantly amending Markdown files telling them not to do things no experienced programmer would do. If you are mourning this craft, why are you choosing to play into a false narrative crafted by billionaires trying to secure an exit before the bubble bursts?
I hear you, but please read my other replies in these comments.
if you’re suggesting the answer to crappy AI code is more AI reviewers then maybe you’re part of what’s making it inevitable. people who are willing to accept more bad food than less good food. people who judge code by the kilo.
These LLMs we see nowadays have lots of errors (e.g., lack of memory), and they couldn’t be fixed totally even in 10 years unless they figure out a new algorithm, a new primitive solution; Indeed it would take years for AI researchers and engineers to practically invent a brand new AI model that could really beat humans at any intellectual skill. That would be the AI that we should be scared of.
And yes, perhaps lots of us are going to have a bad ending.
Yeah, it’s easy to underestimate just how much the LLM jump was completely unexpected, unplanned for, and, critically, unrepeatable. That first jump was huge, even on consumer-grade hardware, compared to what was before. But every time we 10x the size of the model (or the number of co-working models), we don’t get anywhere near 10x improvement. So the tech sector is spending obscene amounts of money for each modest increment, and the diminishing returns are already underwater. And that’s just training, nevermind the cost of hardware and execution…
There are some interesting developments around the edges, but the big companies are aiming mostly at more data and larger models, and training for benchmarks to encourage investment, and that way is a dead end.
We’re none and all of these now, as collective, but I hear you. I am alive and experience very things you say. Hearbreaking
i want puke on your face after ive read “They can write code better than you or I can, and if you don’t believe me, wait six months.”
oh well it’s been 4 months since publication and the 6 months prediction is not aging well
Yeah, look, I sympathise with the existential panic – I feel it too – but… we’re just not there yet. In fact I don’t think we’re ever going to be. The ‘synthetic ceiling’ is real.
man, i am feeling this and mourn with you.
almost 47 and as a developer seen alot that came and went. this thing is different and too big to ignore or fight against. true, if you can’t beat ‘em, join ‘em. but the mourning is not only for my soon to be archaic craft. i also mourn for us as humans. Our crafts are the first victims of this new apex predator.
Yep, I remember when ChatGPT first came out, and I was talking with some coworkers in a bar about it, and I basically said that I had worked in natural language processing, and I had seen all the silly Markov models and next-word predictors, and I admitted this thing felt different, but it must just be the same thing. I felt uneasy about it, though. In retrospect I might have just been coping.
Hey Nolan, I want to put this out there for you:
I still use Pinafore as my main fediverse client. Not Semaphore, not Enaphore, and not any other fork that was made since. Admittedly, part of why I still use it is because I don’t want to go through the admittedly easy process of logging into my accounts again. But the other reason is sentimentality.
Pinafore, in my opinion, is the best fediverse client. I think that, becuase it the product of being very mindful about what should or shouldn’t be used in the code, what features should or shouldn’t be implemented, and even just the simple fact that the person who worked on it cared. You showed that you cared by maintaining it. By adding accessibility features and performance improvements. I think you showed care through your labor by making pinafore run well on KaiOS—I still remember that, I think that was cool as hell.
I still remember the first of just two small commits that I contributed to pinafore. This was to allow you to switch instances quicker by adding a “star” button to each item in the instance list. You took the time to review it, even fixing my code after merging, and made sure I was credited in the release notes. I’ve contributed to a number of FOSS projects, usually drive-by commits, and very few of them have been as welcoming as how you’d managed pinafore. That sticks with a person.
Sure, maybe in six months I could vibe-code my own pinafore. Maybe I could do that now. But I would never have met you, and you would never have met me. The craft gave us the opportunity to work together, however briefly, on something shared. I think that matters.
I got to see what kind of developer I want to be in you. I want to value performance and accessibility. I want my open source projects to be welcoming and enriching to whoever contributes. I want to learn from others what their wants and needs are for software, and to work with them to make that shared vision real.
I just don’t see how we’ll ever be able to achieve this if all we’re doing is toiling, quietly and alone, in front of an LLM’s text prompt. I don’t know how we can ever learn what is valuable, what we should even type into that text prompt, if we hadn’t already done some of that menial labour ourselves. I don’t know how we could ever learn what matters if we don’t talk to each other, work with each other, raise each other up, etc.. etc..
All I really want to say to you is this: don’t lose sight of what code actually is. It is a model of reality. It’s a representation of our wants and needs. You can't make a model of reality if you don’t know what reality is, and we only have two eyes and two ears, and there’s much more to reality than we can ever observe or experience ourselves. We have to learn from each other, learn how to listen, learn how to distill all those wants down into code, into those sets of instructions for the silicon to run.
That is the craft. And you can't do it alone.
Note: this is my second time trying to make this comment. Hopefully it doesn’t get eaten by wordpress again. Also, hopefully, both comments don’t appear side-by-side making me look like a double-posting dink.
Thank you for this comment; I really hope you turn it into your own blog post or something because it is really beautifully expressed. For what it’s worth, my first experience with (collaborative) open source was PouchDB and Dale Harvey, and I’ll never forget how he welcomed anyone in the IRC server who wanted to ask questions or get advice on how to write a good pull request. I’ve tried to model all my open source projects on that ever since (with varying degrees of success), so I’m really happy to hear that you had a good experience.
Pinafore was an experiment at building the perfect web application – no compromises on performance, accessibility, security, etc. This is part of the reason that I didn’t want to hand it off to someone else – I was afraid that they would compromise on any one of these things and ruin my vision. Of course this is the exact opposite of how most software is written today (especially in the AI age): everything is disposable, “good enough,” etc. I think we will see more of this, but I also see the potential of someone building a Pinafore by siccing enough AI agents on a small enough codebase, giving them a benchmark harness, etc.
That said, the human element is certainly lost. Maybe eventually we will have armies of AI agents summoned by Mickey Mouse sorcerer’s-apprentice types who learn to collaborate with each other as we have. I don’t know. I do know that I feel that something has been lost, and that’s why I wrote this post.
And BTW you did not double-comment! No worries.
Just remember you are not the first and you wont be the last to feel their craft disappear.
remember what it means to be an engineer:
“An engineer is someone who turns understanding of reality into reliable, repeatable outcomes that make the world work better”
i tried to write some of my thoughts because i see people starting to react.
This is the best time to be a builder , and the types of things you can build… we’re just starting to see the possibilities.
https://www.linkedin.com/feed/update/urn:li:activity:7426078758291435520/
„The machine will be able to do everything, it will be able to solve all the problems it is given,
but it will never be able to invent a problem.
I fully agree, but will embracing these tools even be enough to preserve our car payments, mortgages, and family security? Will copying & pasting feature requests from product be enough to warrant a 6-figure salary or even any salary at all? After a year or so of “no known incidents”, code TSA agents may no longer be seen as a necessary expense. I mourn for our craft, but I mourn even harder for my family’s future.
One solution is to use the exact same approach employed by the likes of Nvidia/AMD/Intel – create ecosystems that are so proprietary and locked down with no public reference that AIs can't help as they have no context and nothing to train on. Obviously this assumes you control said environment and ensure that none of your proprietary IP leaks and that you can create a viable business model around that technology to keep yourself employed or paid.
I’d also say that mileage you get from AI really depends on the type of development you do. If I’m building out APIs and Web stuff using common tooling like Go/Typescript/Python etc then yes – I can generate at least 80+% of the code exclusively in AI and just spend my effort ensuring overall architecture and consistency. At the end of the day though – writing that sort of code although what 90% of the industry does, is really the bottom of the cognitive barrel – you’re really just an API glue mechanical turk – and if AI kills that – so be it.
I bet Claude/ChatGPT and co wouldn’t be able to help you one bit with writing code for some defense-only highly NDA type systems – and for languages it is little exposed to it can downright useless.
I still don’t quite get how people manage to vibe code whole systems with it, unless they’re so trivially non-complex as I find it routinely makes simple logic mistakes – even with the latest 5.3 or Opus models. I had one today – it decided that a 32bit dword value needed to be ANDed with bit(3) and promptly informed me that should be: someValue &= 3 (or the ASM equivalent and eax, 3) .. clearly bit(3) = 8.
Thank you for writing this. I am also in mourning at the old world that seems to be slipping away in a timeframe of months.
At the same time, it also is the birth of something new. I’m even a bit excited about it, which is weird because I’m mourning. But I will always look fondly at what we’re now leaving behind. I guess it’s now our generation’s time to know how that feels.
Yes, I agree: a new craft is forming, which will probably share a lot of similarities with the old craft. I know a lot of people who are excited about that and have little sentimentalism for the old ways, but that’s just not me. I’m glad to know I’m not the only sentimental one. :)
I am 23, author of Lensor Compiler Collection
I hate AI in programming. I program for fun, as a hobby, and a robot will never replace the relationship I have with my projects.
vibe-coding → vibe-working → vibe-crafting
From writing code for work, to working in flow, to crafting for the pure joy of it on weekends — when coding stops being a task and becomes an art.
I’m still not convinced that LLMs actually boost productivity; in reality, I’m seeing more and more that they just provide an illusion of productivity. I’m not delivering any faster, and my colleagues are feeling the same pain. It’s impossible to keep up with the cognitive load an LLM dumps on you after every prompt. I’ve tried everything: sub-agents, skills, OpenSpec, code reviewers (copilot and cursor bugbot: those ones are actually helpful sometimes). But none of it solves the core issue: when you receive the output, you’re forced to work top-down. You lose the ability to truly grasp the essence of the code, because you only really understand something when you build it bottom-up.
Slop code ends up in prod, only to be rewritten manually later (even if nobody, including you, caught it during review), but we’re the ones held responsible for it. It feels like a rigged game: you’re forced to stop doing your job to manage some drunk alien who hands you work that you have to review and vouch for. Sure, juniors who have no idea what they’re doing will be ‘faster.’ But we’ve seen this before, like the hiring booms for cheap labor where devs cranking out tons of code for $500/month were considered ‘productive,’ even though the code was unmaintainable. Same thing here. At work, I’m constantly trying to rein it in, literally holding Opus 4.6 by the hand, because the moment you lose focus, disaster strikes.
Out of curiosity, I tried to >FULLY< ‘vibe-code’ a pet project, prioritizing speed over control. It works, but the code is a nightmare. Even with a predefined architecture, the LLM ignored every instruction: DB calls in controllers, insane code duplication, side effects, and blurred responsibilities. But hey, 10k lines of code a day! I haven’t lost hope that this hype will die down, the circus will leave town, and we can finally get back to actual work.
I lost hope that “the circus would leave town” (great metaphor BTW) when I saw Ralph and Gas Town and realized you could just plug more of these things into loops and solve such problems. I tried it with code correctness, DRYness, security, accessibility, performance, etc., and it worked every time. (“Look for bugs,” “run benchmarks and make it faster,” etc.) The people having a really bad time with LLMs are the ones just building features and not putting their PRs through multiple layers of agent review (yes multiple, just give it the same instructions over and over). They’re like a software company that only focuses on features and never tech debt, with predictable results. My AI tribalism post touches on this.
Of course you’re right that you still need true code understanding even with all of the above, and maybe there’s a case to be made that you have to get your hands dirty at first just to understand the codebase, but… I dunno, I feel very much like John Henry losing to the machine at this point.
I think one of the interesting questions is what do future senior developers look like now that the focus is shifting. What kind of things should we teach for future juniors?
My personal feeling is that you still have to understand what's happening underneath at least to some degree (classic wisdom from Spolsky states that you should understand one level below the abstraction you are working with) so there will still be value in being able to evaluate code.
That said, when work moves more from authoring to reviewing/curating, likely we’ll put more value on tools and technologies enabling more effective curation. It wouldn’t surprise me if programming languages that put authoring before understandability would fall out of favor for this reason. Languages with strong verifiability properties will likely grow in popularity, however.
I think the big shift has to do with the fact that we are moving from software development to software engineering and that can be a tough shift for many.
Having only worked in industry for 2 years before genai become the go to. I feel a bit hopeless that I will never have the opportunity to make the mistakes and do the reps to get truly good at software engineering. The pressure is high to just ship features asap.
Same with learning a new language. The language has been abstracted over by just prompting and making design specs.
I would love to hear from other devs how we can go forward mastering our craft without being left behind.
I would tell you not to lose hope. I work with a junior with less experience than you, and she is more adept with AI tools than I am – you might say “AI-native.” I watch her code, and it's utterly alien to me how AI pervades the terminal, the IDE, the browser. She skipped a lot of the struggles that I had, sure, but 90% of those struggles might not be relevant anymore. You can “get the reps” on the skills that actually matter now (systems thinking, architecture, design, taste), and you have a hyper-intelligent buddy to guide you along the way. Keep on keeping on!
[…]
under two rules: humans must not write code, and humans must not read code. Nolan Lawson published “We Mourn Our Craft,” an elegy for programming as a human […]
[…]
Nolan Lawson (Hacker News, Mastodon): […]
I grew up in the 90s and early 2000s and went to college when they still taught cobol and c++ was a horror show and python was still in version 2, and numpy and scipy and pytorch were just babies.
While you may be nolstalgic for real code and real coders, from my perspective( and I know i’m smarter than you because my head is physically bigger than yours), programming was, and is, alien to human nature. Humans basically understand a logical sequence of tasks and decisions, and translating that into the “how” is an art, not a science. Every programming language we ever made is full of quirks that our quirky little brain obfuscates but which cost productivity and legibility. The best languages we have are those that do what they do predictably and consistently for their application and are coincidentally and not consequentially widely adopted.
The nature of the programmer is as important as that of the programming language itself. Disciplined behaviors and rigid adherence to design principles cover a multitude of sins.
What the nerd/geek world does not want to admit is that it is a temple, an occultic tradition of consulting oracles and arranging bones, wizardry as it were, and thus it is not strictly limited by IQ. So, you have myriad midwits coding in C and thus you have a lot of the bugs or vulnerabilities of modern computer operating systems and the software that runs on them, and you have visionary frameworks like the earlier dotnet and asp.net and anything else from that era that has now been fully obseleted yet was concocted entirely without the intervention of AI.In light of that, AI does not seem too bad. When it can rewrite our entire world in a spark-ada themed strictly typed rust-like language that’s devoid of terenary operators and requires both indentation and encapsulation for syntax flow, where legibility communicates correctness, where all important calls are themselves well-documented and well-labeled apis in library systems sweetly organized for human consumption, then we will actually be far better coders than we are even today.
We will tell the machine in SenseTalk what we want it to do, and it will render us in Assembly the optimal instructions to do it.
Your brain needs to hold the whole of what you’re tuning and working with in your mind to design it. Can most people do this? no. so they abandon complex systems because they must allocate inside budget to trivial details and because they think in terms of the hardware platform, and then their code is replaced with something a million times less efficient written by an actual child due to a corporate takeover necessitating a new framework.
Will there still be virtue in fine-tuning, fiddling with the CPU machine language? perhaps. But the moment you’ve started using libraries that responsibility rightfully lies with the library designer, not the one who uses it. The cost-complexity of today’s programs lies in obfuscated cost, and not typically in the coding patterns in use by the developer, except in compiled languages where arrays must be manually iterated over and the structured iteration is itself hostile to vectorization, and even there, it's mainly because people don’t THINK logically and stick branching operators inside looping constructs and don’t do a final refactor. Because people are lazy.
So, in conclusion, there's nothing we're leaving behind that we truly will miss, the art will continue for those enthusiastic enough to do it, and for the rest of the world, what they need is AI that respects convention and intelligently applies optimizations. They do not need to code. They need to leave coding the hell alone. They always did, and it is because they didn’t that we’re not yet a planet-hopping galactic species.
I think what you’re saying is all true to a large extent.But dude – this is an elegy . You can't just tell people not to mourn.
I mourne that we ever even went through such a period
I applaud you for writing this, Nolan.
I, and many people I know, have wrestled with this over the past year and more. As someone who knows neural networks and understands the mathematics of the transformer model, I always had a nagging suspicion that the best model efficacy across languages would really come from programming languages – you have more tightly scoped lexical grammar, and “tone” is not really a thing so much as “best practices”. The objective functions are tighter, often binary (compile vs. no compile, test pass vs. doesn’t pass, etc.)
Yet, I secretly hoped they wouldn’t be as good as they have become, or it would take a while longer. Because deep down, I really enjoy coding. Sure, it's “never been most of the job” as people kind of keep saying these days like a broken record, but it's always been incredibly stimulating for me – figuring out flow control, learning nuances of syntax, tackling a hard problem, and feeling the satisfaction of going through the friction and coming out on the other end of it feeling like you learned something. There’s so much to be said about the act of writing vs merely reading. The former has been shown to really help with learning over the latter, and there’s much to be said about that.
These days I also probably write 70-80% of my code with Claude. I can manage the last 20% or so and still continue to meet the new speed deadlines that the industry has become acclimated to. It may be the case that I can keep up with it. For some personal OSS I have the time for outside of work, I still like hand crafted with LLM as a judge.
But all this to say – “mourn” is the correct word. Because even as I write this, I feel sad. I know this wasn’t the world that I asked for, especially not this fast. But here it is. I’m somewhat hopeful even if I’m not quite “excited”. I know I can continue my craft to an extent, but it won’t be what’s rewarded economically. And there’s some comfort in knowing that for what it’s worth.
All this to say, one strange thing about this whole time-compressed paradigm shift is that it actually led me to confront my own mortality, as hilariously over-the-top as it may sound. I’m also in my 40s and my youngest most energetic years are not that far behind me. I recall a lot of the things you mentioned – the struggle of finding bugs, the satisfaction of fixing them, and also the hope of building software as a future in the aftermath of the Great Financial Crisis. Those are all so recent in my memory, and yet, they're actually quite far away now. People will come and go. Technology will come and go even faster as they are supplanted.
Perhaps it's time for me to enjoy what I have, the people I’ve met along the way, and look optimistically into the future.
Thank you for your beautiful sentiment; I share a lot of this perspective. You’re right that my thoughts did turn to mortality (“all things must pass”-type stuff) and yeah, it is because of a feeling of mortality, or the gears of history turning to replace one world with another. A little sappy, and plenty of my colleagues do not feel this way and are just excited by the new possibilities, but I’m a sentimental person by nature.
One interesting thing about coding: I can't recall where I read it, but someone pointed out that code is different from art, poetry, music, etc., in that good code is usually idiomatic – if you’re not sure how to write a for-loop, write it the same way that ~75% of people do it, to avoid surprises or WTFs/minute . Whereas good art/poetry/music is usually surprising – of course you can borrow motifs or themes from other works, but really we’re looking for novelty (most of the time). So maybe our field is uniquely vulnerable to LLMs. Not a comforting thought, but it would explain a lot.
Really great post. I am one of those zoomer colleagues that *is* embracing AI tools with open arms. Though nothing nearly as extreme as using AI as a therapist or lover, that idea could make a whole blog post on its own, but I digress. I’ve been programming long enough to remember when code *was* written by hand (it might surprise, but I’ve been programming for literally more than a third of my entire life), and if you couldnt implement something, either you figured out how to or it didnt get written. Maybe its rose tinted lenses, but I hold those memories closely.
It’s hard not to get caught up in the idea that everyone is “doing circles around you” with AI tools, especially when talking about a professional environment, and the truth is, either you *have* to evolve, or die. But if youre writing things for yourself, truly, for yourself, dont think too deeply about how everyone on twitter is “using claude code to be a 10x developer 🚀.” I fear the day that programming *by hand* becomes riding a horse to get around when the automobile exists, though I dont think that will be for a while.
Truthfully, I am a cynic, and I *do* believe that AI tools will push people who refuse to change out of the industry, for better, or, more likely, for worse. As I do embrace this faster moving, ever evolving future, I too will mourn our craft along with you, and many others. Programming, for me, has defined a lot of who I am as a person, the people I met, the communities I’m in, have made me *me*, and I worry to think that culture could change, that I might be the last few to truly experience that, but the world keeps spinning, with or without my thoughts and ideas.
Nolan, this might be the best thing I’ve read about what it actually feels like to be a software engineer right now. The image of holding code like clay. The late-night debugging sessions. The pride of the artist’s signature on a GitHub repo. You’ve put words to something thousands of us are feeling but can't quite articulate, and you did it without falling into either breathless techno-optimism or dismissive cynicism. That’s hard to do. Most people writing about this stuff pick a side and dig in. You just told the truth.
Where I disagree is the ending. “The sun rises, the sun sets, I orbit helplessly around it, and my protests can't stop it.” That’s beautiful writing but it's also a choice to be a passenger. The knowledge we’ve built over decades doesn't become worthless. It becomes the foundation for a different kind of value.
I wrote a longer response to your piece through the lens of the five stages of grief, because that's what I’m seeing play out with the people I talk to about this. Denial, anger, bargaining, depression, and then an acceptance that isn't resignation but evolution.
If you’re interested: The Five Stages of Losing Our Craft .
I really enjoyed your piece, thanks for sharing. To be sure, this is an elegy, and I let myself get morose and sentimental because I was trying to give myself space to process my grief. I know exactly the kinds of senior developers you’re talking to because I was one of them (in many ways, this piece is a conversation with myself a ~year ago). In my case, I can say that trying to force certain tools on engineers from the top-down doesn’t work (it certainly didn’t for me – they just resist, same as if you forced a certain IDE on them).
The engineers I know who are most happy with the new AI tools are the ones who, unlike me, have not accepted passivity, but have tried to master the new tools. You’re right that I’ve been a bit passive; for instance, I’ve only really tried Claude Code so far. Whereas I know engineers who say things like “I tried Claude and Codex but now I prefer OpenCode with Kimi so I’m not locked in.” Or “I tried Ralph and Beads but now I’ve built my own orchestration system and issue tracker that matches my workflow.” That’s not me, but those engineers seem much happier than me! So one of my goals this year is to learn more from them.
My piece is also directed at another kind of engineer you don’t really mention, which is the AI holdout. These folks have strong moral or ethical qualms against GenAI. For them my “sun rises” paragraph is basically me quoting Paul Simon and saying “Who am I to blow against the wind?” In other words, the toothpaste is out of the tube, the horse is out of the barn, it's a lost cause, etc. I get no pleasure from saying it, and plenty of these holdouts are my dear friends who strongly disagree with me, but it's how I feel. You’re right that it's not helpful to advocate for passivity, but I was mostly just trying to describe my own headspace in the moment.
Personally, I don’t mind if AI makes traditional programming a thing of the past. What it does for me is enable me to write all the programs I’ve always wanted to but never had time.
On the other hand, if by introducing this many people get laid off and companies can be run by very few I have an interesting idea on how to fix that…
Tax companies based on one thing. The ratio of profit to the number of employees (while also guaranteeing a fair pay range). The less employees, the higher the taxes will be. If there’s a 1-man billion dollar company, well maybe we tax them 99% and they walk away with 1% of a billion a year – not bad. If they have thousands of employees maybe they get to keep 80% of that billion. I know I’m just throwing numbers around but you get the point… some way to tie people to employers the same way payroll reimbursement to