I have been consistently skeptical of LLM coding but the latest batch of models seems to have crossed some threshold. Just like everyone, I've been reading lots of news about LLMs. A week ago I decided to give Claude a serious try - use it as the main tool for my current work, with a thought out context file, planning etc. The results are impressive, it took about four hours to do a non-trivial refactor I had wanted but would have needed a few days to complete myself. A simpler feature where I'd need an hour of mostly mechanical work got completed in ten minutes by Claude.
But, I was keeping a close eye on Claude's plan and gradual changes. On several occasions I corrected the model because it was going to do something too complicated, or neglected a corner case that might occur, or other such issues that need actual technical skill to spot.
Sure, now a PM whose only skills are PowerPoint and office politics can create a product demo, change the output formatting in a real program and so on. But the PM has no technical understanding and can't even prompt well, let alone guide the LLM as it makes a wrong choice.
Technical experts should be in as much demand as ever, once the delirious "nobody will need to touch code ever again gives way to a realistic understanding that LLMs, like every other tool, work much better in expert hands. The bigger question to me is how new experts are going to appear. If nobody's hiring junior devs because LLMs can do junior work faster and cheaper, how is anyone going to become an expert?
It’s refreshing to hear I’m not the only one who feels this way. I went from using almost none of my copilot quota to burning through half of it in 3 days after switching to sonnet 4.6. I’m about to have to start lobbying for more tokens or buy my own subscription because it’s just that much more useful now.
I'm still not ready to sing praises about how awesome LLMs are, but after two years of incremental improvements since the first ChatGPT release, I feel these late-2025 models are the first substantial qualitative improvement.
Think about it: when you (an expert) solve a bug, you're not just generating correct code. You're making dozens of micro-decisions about scope, trade-offs, and edge cases that an LLM won't know.
The gap between "I solved this issue" and "I can explain why I solved it THIS way" is enormous. Most devs only keep the former (the code), and lose the latter (the reasoning).
In the AI era, experts need tools that capture how they think, not just what they write. That changes the game from "LLM vs human" to "LLM + augmented human judgment."
The principal engineers who will win are those who build compounding knowledge of their own decision-making patterns.
This is so clearly a losing strategy. So clearly not even staff level performance let alone principal level.
Massive job cuts, bad job market, AI tools everywhere, probable bubble, it seems naive to be optimistic at this juncture.
This is the fundamental problem with how so many people think about LLMs. By the time you get to Principal, you've usually developed a range of skills where actual coding represents like 10% of what you need to do to get your job done.
People very often underestimate the sheer amount of "soft" skills required to perform well at Staff+ levels that would require true AGI to automate.
LLMs may be accelerating the process, but definitely not the cause.
If you want a career in technology, a durable one, you learn to adapt. Your primary skill is NOT to master a given technology, it is the ability to master a given technology. This is a university that has no graduation!
If you're a great programmer, can you can stop using Angular and master React? Yes. Can you stop telling the computer what to do, and master formal proof assistants? Maybe. Can you stop using the computer except as a tool and go master agricultural technology? Probably not. (Which is not to say you can't be a good programmer at an agritech company)
Let’s talk about the industries the computer killed: travel agents, musician, the entire film development industry, local newspapers built on classified ads, the encyclopedia industry, phone operators, projectionists, physical media industries, and a few dozen other random industries.
We aren’t special because we are coders. Creativity and engineering thoughtfulness will still exist even with LLMs, it will just take a different form.
I remember a cinema theater projectionist telling me exactly that while I was wiring a software controlling numeric projector, replacing the 35mm ones.
[citation needed]
It has just merely moved from "almost, but not entirely useless" to "sometimes useful". The models themselves may perhaps be capable already, but they will need much better tooling than what's available today to get more useful that that, and since it's AI enthusiasts who will happily let LLMs code them that work on these tools it will still take a while to get there :)
[citation needed]
:P
This thing has changed the way I work. I barely touch my editor to actually edit anymore, because speaking into the chat field what changes I want it to make is more efficient
The tooling does need to get better, yes, but anecdotally, I do a fundamentally different job (more thinking, less typing, less sifting through docs, less wiring up) than 3 months ago
So much of my career was spent on especially rummaging in docs and googling and wiring things up. I believe that's the same for most of us
If we truly value human creativity, then things that decrease the rote mechanical aspects of the job are enablers, not impediments.
Society can interpret sociopathy as damage and route around it, if we do the work to make it happen. It will not happen by itself without effort.
I see unreliable software like openclaw explode in popularity while a Director of Alignment at Meta publicly shares how it shredded her inbox while continuing to use openclaw [1], because that's still good enough innit? I see much buggier releases from macOS & Windows. The biggest military in the world is insisting on getting rid of any existing safeguards and limitations on its AI use and is reportedly using Claude to pick bombing targets [2] in a bombing campaign that we know has made mistakes hitting hospitals [3] and a school [4]. AI-generated slop now floods social networks with high popularity and engagement.
It's a known effect that economies of scale lowers average quality but creates massive abundance. There never really was a fundamental quality bar to software or creative work, it just has to be barely better than not existing, and that bar is lower than you might imagine.
[1] https://x.com/summeryue0/status/2025774069124399363
[3] https://www.reuters.com/world/middle-east/who-says-has-it-ha...
[4] https://www.nbcnews.com/world/iran/iran-school-strike-us-mil...
After 40 years in this industry—I started at 10 and hit 50 this year—I’ve developed a low tolerance for architectural decay.
Last night, I used Claude to spin up a website editor. My baseline for this project was a minimal JavaScript UI I’ve been running that clocks in at a lean 2.7KB (https://ponder.joeldare.com). It’s fast, it’s stable, and I understand every line. But for this session, I opted for Node and neglected to include my usual "zero-framework" constraint in the prompt.
The result is a functional, working piece of software that is also a total disaster. It’s a 48KB bundle with 5 direct dependencies—which exploded into 89 total dependencies. In a world where we prioritize "velocity" over maintenance, this is the status quo. For me, it’s unacceptable.
If a simple editor requires 89 third-party packages to exist, it won't survive the 5-year test. I'm going back to basics.
I'll try again but we NEED to expertly drive these tools, at least right now.
What's missing is another LLM dialog between you and Claude. One that figures out your priorities, your non-functional requirements, and instructs Claude appropriately.
We'll get there.
There are already spec frameworks that do precisely this. I've been using BMAD for planning and speccing out something fairly elaborate, and it's been a blast.
> neglected to include my usual "zero-framework" constraint in the prompt
And then your complaint is that it included a bunch of dependencies?
AI's do what you tell them. I don't understand how you conclude:
> If a simple editor requires 89 third-party packages to exist
It obviously doesn't. Why even bother complaining about an AI's default choices when it's so trivial to change them just by asking?
You call it a trivial instruction, but it is not trivial. It was a core requirement for your own design that you neglected to specify. This is not different than leaving out any other core requirement for a engineering specification.
Most people would NOT want this requirement. Meaning most people wouldn't care if there are package dependencies are not, so the agent 100% did the right thing.
This isn't to say that they're perfect or bug-free, but they generally don't just save time but increase the quality of your final product.
Writing your own implementation of third-party functionality that already exists has its place, but it's generally something you implement later as an optimization for very specific reasons.
The pattern that helps: put your invariant constraints (zero-framework, no external deps, specific language version, etc.) in a structured template that gets included with every prompt. CLAUDE.md does this at the project level for Claude Code. For one-off prompts it requires more discipline — which is exactly the gap I built flompt (https://github.com/Nyrok/flompt) to address. Visual constraint block you can reuse across prompts.
You have decades of expert knowledge, which you can use to drive the LLMs in an expert way. Thats where the value is. The industry or narrative might not have figured that out yet, but its inevitable.
Garbage in, garbage out still very much applies in this new world.
And just to add, the key metric to good software hasn't changed, and won't change. It's not even about writing the code, the language, the style, the clever tricks. What really matters is how well does the code performs 1 month after it goes live, 6 months, 5 years. This game is a long game. And not just how well does the computer run the code, but how well can the humans work with the code.
Use your experience to generate the value from the LLMs, cuase they aren't going to generate anything by themselves.