100%

We're already seeing this at the enterprise level. Companies have dictates from leadership that "if you're writing code manually, you're doing it wrong."

Okay, that kind of works for a while. We are indeed producing a shit-ton of code, but the reality is that engineers are pumping out code faster than the humans can understand and (honestly) review it. That sounds great until you realize that "hey Claude, read this Jira ticket and implement the feature in this code base" isn't really worth $200K/year.

This is all complicated by the fact that we're also losing our grasp on reality from the other direction because we have leadership air dropping AI generated manifestos on the product owners and product owners having to use AI to transmute all that shit into 1,500 word Jira tickets that are 10% necessary feature work and 90% LLM boilerplate.

So now you have software engineers whose job has changed radically to the point that the hardest part about being a software engineer is just filtering through AI generated artifacts from all directions just to try to get a feature out the door.

I see a large emphasis placed on headless agentic/vibe coding, what I don't see people talking about is how great guided coding is.

I have over a 15 YoE writing software and guided coding sessions - that is, using an editor like Zed or VSCode with an LLM integrated, writing code how you normally would but using a flash model to prompt away the annoying parts and/or plan - is as productive as vibe coding, produces significantly higher quality, is actually enjoyable, and you actually stay sharp.

Flash models (DeepSeek v4 flash) tend to be so fast that you don't have time for parallel agents, you lock in and rapid fire prompts, building high quality software while incrementally reviewing it as you go. VETO bad edits and try again or rewrite them manually.

By contrast, I have noticed headless agentic coding tends to be an unreviewable black box. The major issues I've found is that, even with a human-in-the-loop, you accumulate defects which compound and eventually you're spending millions of tokens to make trivial changes in a ridgid codebase.

Ultimately, tiny, highly cached, fast models like Qwen's 27b/a3b range or DeepSeek flash are highly capable and relatively inexpensive to run. Hoping people realise we don't need 14 trillion parameter models and I'll be able to buy some ram for my workstation

// The need for ongoing friction in long-term skill formation.

The subtitle of the story tells it all.

There are some people who seek out friction. Think about an athlete or a hardcore nerd.

The best engineers are ones who were fascinated with computers and learning as kids and persued it at every opportunity. Found their own friction in other words.

For those kinds of people, friction-seeking is the constant and what LLMs did is moved the point of where the friction occurs.

For example - the best engineers I've worked with didn't necessarily have lots of experience coding in assembly because that kind of friction was no longer necessary. But they could solve hard problems (and if a problem really required assembly they could go learn it)

What I think will be hit much harder by AI is the low tier engineer. Someone who was never truly curious and committed to it, for whom it was just a job. For example a typical offshore ticket pusher kind of person. That kind of person never went out to find friction and that's the kind of thing that's never going to fly again - if I want mediocre or average, the LLMs are sufficient

The snake eating it's own tail for llm software development has really been met with a shoulder shrug whenever it gets brought up. At best you might have a small cohort of developers that don't cook their brains with AI and their reward for that appears to be having to review terrible AI code written by people who have cooked their brains.

Completely unsustainable.

As a tech educator I 100% agree. LLMs are not going to become a "new compiler" where we don't have to worry about the code any more. There's a reason we trust deterministic systems.

I've been worried about this a lot, I even created an agent skill called do-i-understand that's designed for novice devs (and experienced too, because atrophy) where the LLM asks you questions about the PR you're about to submit. I've found it helps a lot: https://github.com/AnthonyPAlicea/skills/blob/main/skills/do...

One way or another, there will be a skill reckoning.

I strongly agree with the concept that cognitive friction is the engine of learning.

First and foremost, it's an issue of "dependency": if you stop training the "muscle" of logic and reasoning, it gradually atrophies, just like unused physical muscles. You become dependent on external tools that replace a capability you once had yourself.

A historical example that brought about a similar shift is this: when the production process moved from the craftsman's mind and hands to the Fordist factory (and the assembly line), the skill of building things shifted from human craftsmanship to anonymous, structured processes.

Bit by bit, traditional artisans lost their knowledge and "know-how." Today, having a piece of furniture in our home depends on a massive production and supply chain; the "average" person no longer has the ability to build it themselves.

The exact same thing is happening to software.

We are the (now "former") software craftsmen.

It believe the most likely consequence of AI is to promote generalists: people who have a domain expertise, can work cross discipline, and has enough programming knowledge to keep the LLMs on track. I don't think 'pure' software engineers will end up being as highly valued as the last decade though I also think that will be true for other disciplines as well. Just as an example, in signal processing, it's not uncommon to have a person designing the general algorithm and another person dedicated to implementing the algorithm in the embedded system. With the quality of coding agents, it's not really necessary to have both of those people anymore. A person who is moderately experienced in both can do the job now.

Yes, and it doesn't matter.

Writing code in programming languages is a skill/necessity created by us to instruct computers what we want them to do

Initially in the 60s, this was done by connecting circuits one way or another (think ENIAC). Then we devised "programmable" computers and devised a bunch of codes (computer code instructions) that abstracted away those cables.

The we created Programming Languages to further abstract away the hardware complexity, and to be able to write down our wishes in a way that is more transferable between us humans, but that is still computable by machines.

But with LLMs and neural networks, at some point these abstractions wont be necessary.

The computers will still be making computations, but the way we tell them what we want is going to evolve.

It's fascinating.

This seems sadly very true. Just yesterday I was implementing some slightly tricky javascript (not my main language) on hover show n neighbours to each side, and if a deficit on either side, expand to the other side. After about 20 minutes of struggling to get the offsets just right, I succumbed to just asking an agent to do it.

I'm sure I'd still be able to do it, but was saddened that I didn't get it as quickly as I think I used to be able to. Atrophy might already be in play.

TBH it was already pretty bad. There is a stark difference between the best and the average in my experience. The top, say, ten percent of coders are vastly better than anyone else when it comes to anything but boilerplate glue code(which is still needed and is better done by average coders anyway).

This is speaking from my experience as a systems/c/c++ guy. If you are a js web frontend guy, python, or whatever I have no idea if this applies to you.

We are spending sooo much for our intellectual time and energy on discussions about alchemy-like experiments with different models, agents, harnesses, orchestrations.

And there are huge amounts of time, energy, and writing sunk into arguing about AI or trying to convince people of the danger or problems.

Sadly all of this is taking time away that could be spent on real progress and learning about coding/FP/PL/algorithms/type theory/etc.

I'm looking forward to having the same experience as COBOL engineers did after retirement: companies backing up the brinks truck to anyone with the skills to keep the lights on.

There have always been opportunities for those who seek out the less traveled paths.

If all your peers are only accepting what LLMs tell them then you should do the opposite. Spend some of your time writing code by hand, especially when working at a new layer of the system or on new things you've never looked at before.

While the agents churn out more CRUD crap in the background spend your attention learning how everything works.

I do way more experiments with way more things by taking advantage of LLMS. When I have them do research I use that as a starting point for my own reading (but don't blindly trust them).

I find I am learning more faster.

Change is an opportunity. Use it to your advantage. Let other people while and moan while you get things done.

Most computer science programs don't teach "coding" though. There is pretty heavy emphasis on datastructures, algorithms, and system design. I don't think AI atrophies those skills / knowledge as much as the coding language and I think in many cases actually improves them, especially if you are reading the code that is produced and at least understanding the flow of it.

I agree that AI reliance is hurting engineer's language understanding, but I don't know how much we should care.

I often think back to the early GPT days before agents as maybe the last time I will deeply learn a technical subject. I think that was when I actually learned the most as I had to stay completely in the loop. I had recently started a new job and had to work with k8s for the first time. Using GPT to help me implement new services and help me diagnose and fix issues with kubectl taught me so much.

Now with agents I don't have any insights into what its doing with kubectl and would have no reason to learn how it works (other than my own curiosity).

I agree that the human no longer gains expertise, but I am not sure that will matter in the long run.

So far I think I have learned far more from LLMs than I've lost to them. I forget some syntax, definitely. But I now reach for a much wider range of tools that I have become familiar with because of LLMs.

So, partly agree, partly disagree.

I fall into the category of senior engineers who benefit from LLMs for all the reasons mentioned in this post. I find it's possible to agree completely with sentiments like this and still feel as if this is all written in the sand below the high tide line, and ten years from now nobody will care about this.

Horsemanship and sailing were both specialized skills of high value to society, and now they're not. But in each case there was probably a liminal period, when being an accomplished horseman or sailor was still valuable, even as motors were taking over. Eventually that period ended, as the new generations without those skills found ways to get by with cars and motorboats.

Forcing friction the way this post describes won't work because the genie is out of the bottle.

A much easier way to force friction is to expect everyone to read the code they are producing. Yes read all of it and understand what it's doing.

A lofty bar sadly.

I don’t think there’s a big societal problem here, except that the agentic programming developers may be out of a job like the rest of us. If AI continues improving it will just keep taking over whatever skills are involved in the current AI coding meta are. If it stops improving then the meta will stabilize and after 10 years everyone will have longevity in it.

I also see no evidence that AI programming is a difficult skill that cannot be learned by any intelligent person in much shorter amounts of time than previous professional skills required.

Great read that brings some rigor (or at least cites rigor) to what has otherwise been anecdotal.

> then what is the path for one to become an expert so they can effectively use these tools?

The article briefly mentions guard rails and I think on the same note we need the AI agents we use for coding to encourage learning and comprehension in its users. Right now it’s completely voluntary and on the onus of engineers to put in the effort to learn since, as the article states, the friction that led to some degree of required learning is gone.

I think we now entering this state where code is cheap but good well made programs will be rarer then ever, a lot of crap can be made and a lot of programs made without ever thinking the problem through properly will occur.

It might be like how an archeologist since the invention of plastic can date the period of the soil as post plastic, if one could cut open the software stack of the coming systems that will be built in the near future one would could data that code as post agentic LLM as programs are going to be mostly bloated ad-hoc, poorly thought-out and patched in a way that does not concern it's self with the correctness of the algorithms or data structures chosen.

I am not Anti-AI but I think it's going to be interesting and I am surprised at how bad a program ends up when one tries to "vibe code", though often ends up working, though in isolation and when used with discipline (that the tools themselves psychologically make it harder to do) can produce some very good code and being able to use loops to solve difficult problems or problems that simply would have require banging ones head against the problem many times is very profitable.

Not just coding expertise. Wrote this a little over a year ago [1] on this exact topic.

[1] https://web.archive.org/web/20250623100834/https://ryanglove... (sorry for archive link, have a backlog to migrate old posts to my new setup).

I hope that this will expose the true value of education. It's a new scale perhaps, but not a new problem. We sit in classrooms even though books and YouTube videos make available the teachings of far more illustrious teachers than the one in front of us. We watch things written out agonizingly slowly in chalk. We learned to do algebra and calculus even though we had our TI-86s and Mathematica. We learn in Haskell and Scheme even though those are rarely used later. We write toy compilers and write essays and repeat experiments with known outcomes in labs. We do it to learn how to think, how to build. We just have to be even more deliberate about it now.

Does anyone else feel like the web has become so "readable" it is illegible?

I have such a hard time quickly reading pages like TFA. Headings, bullets, line-spacing, width, link hover animations, even the font. Even reader mode defaults aren't great for me.

Compared to, for example, https://www.paulgraham.com/best.html

I'm still waiting to see how LLMs have made the world a better place because it honestly feels like its done the opposite.

I wonder if we will eventually see the same drop in general knowledge we saw with manual driving (in some parts of the world), cursive handwriting, clothing repair, etc. Of course, coding was never as prevalent as these practices in the general population, so it might be harder to measure, but I feel we will definitely see it taught less in schools, harder to find resources, etc. in the coming decades, becoming more of an underground hobby.

I’m still resisting the AI flood. I use it but I do read code without its help. I also make sure I have the muscle memory of stuffs that will be tested in interviews — somehow big techs have forgotten that maybe they shouldn’t test people on coding problems.

So basically I’m still doing things manually for everything that preserves my edge for interviews and as a technical person. But I use AI to generate diagrams and documentation, as well as operation scripts that no one is supposed to memorize.

> This applied friction is directly what builds "developer intuition" (or "taste"). The Germans have a great word for this: Fingerspitzengefühl (fingertip feeling). It’s the muscle memory that triggers when a developer looks at something and thinks, “yeah...this is probably going to cause problems.”

No, we do not have that word for that.

Yes, we have that word. No, it does not mean that.

Any LLM proofreading could've told the author that, for that matter.

__

What Fingerspitzengefühl actually means could be described as "tact", a precise approach to something and general attention to detail that leads to success. Or.. the lack of all of that leading to blunt failure.

__

I would of course comment with more Fingerspitzengefühl for the emotional needs of the author if the writing wasn't just a sales funnel for their courses and whatever else (+ posted by them themselves.)

My personal antidote is to write unassisted Zig in my spare time (though C would be fine as well). While I can't back with data I certainly feel sharper.

> JetBrains, a major player in developer tools, recently completed a study of junior and novice developers

The article links to this as the study: https://dl.acm.org/doi/epdf/10.1145/3632620.3671116. It doesn't appear to be related to JetBrains in any way?

Alternate take: How many people have known how to program in assembly for the last 30 years or so? It's been a skill on the decline. Good compilers made that happen.

Hobbyist programming expertise unaffected

Genuine curiosity in learning how stuff works, not necessarily for financial gain, e.g., from a salary or using web to deliver ads

No real "pressure" for hobbyist to use "AI"

IMO as end user, some of the best software available was originally written by a single unpaid author, not salaried teams

Some of the worst software ever written was produced by overpaid teams

Hobbyists may use relatively old, handwritten code to learn from

That's not necessarily bad. Software quality has declined over time

It appears to be a pattern where I work "expert novice" eventually causes serious incident but is unable to root-cause on their own.

They've become a meat proxy[0] prompting LLM to root cause for them and the ability to fix is capped by LLMs ability, not the engineer's.

I've tried to convince management before this happened and yet here we are.

[0] https://gruhn.me/blog/2026-08-03/

Saw a quote comparing pre-LLM code to pre-WWII steel, low-background steel, essentially.

This happened before with “real” engineering. Engineers a hundred years ago used to be proficient with slide rules and mental math and 3D assembly by hand. Products designed in that era often lasted a hundred years, like Singer sewing machines and Lada cars and 500 year old churches. Now things aren’t built like they used to be, and few people can rebuild civilization by hand like they did. But the world moves on fine!

I do understand the sentiment of applying "constraints" over AI usage to certain scopes of our development work.

This has an issue in practice.

As an example, Function Programming (FP) has a high constraint on programming, where some don't even have loops (gotta use recursions all the way), and almost no state mutation (Exlixir I believe have a mutable state? forgot).

FP sounds great with all those constraints. But what about the adoption?

It's hard to switch your mindset, and not as natural, thus long leraning curve, and not as wide adopted <- productivity goes down as all others need to know and use it well. That's why still imperative and OOP languages are ruling the world.

Same for these constraints. The author promoting using AIs only to subsets (no coding? wtf) is something the majority won't follow. Yes, the constraints sound great, but at what cost? By the time one learns everything, and everyone moves along with AI building stuff fast and cheap, they will be left behind.

---

I do not like the author trying to make his points authoritative by using Halo effect using quotes from the industry and could have had been taken out of context (That's where AIs mess up the most, they only get chunks of text and lost context of before and after exerpts).

In my company the knowledge is starting to be devalued.

People are distrusting whole swaths of concepts because they do not understand how things actually work.

Like going away from zerotrust architecture to holding open a long polling connection.

At least I seem to remember that long polling wasn’t that great, but i start to even doubt myself.

Anyone wondering how the Roman Empire was wiped out? I guess we will find out soon

Substantiveness of this article notwithstanding, I do want to point out that the author also runs (or is planning on running) a programming course which to me may be a slight conflict of interest. I think the author may altogether be well-intentioned, but it IS something that I'm going to keep in the back of my mind as I consume this content.

> LLMs can detect patterns at a scale that no human ever could, but patterns only get you so far.

This is asserted without evidence, and from a scientific standpoint, unjustified.

First, "detect patterns" makes it sound like a classification task, "is this a picture of a cat". But LLMs transform the input.

For example, an LLM can translate text between two languages while properly handling the names of the people described, no matter what those names are. That shows they are representing the text in a somewhat abstract way, that they can perform operations on that representation, and also convert it to useful output.

And, what I just described is the most general form of information processing algorithm. Science is not aware of any limitations in principle on such systems.

I am not saying LLMs have no limits, but "they only recognize patterns, and that is a true limit" is not a good argument.

Writing code was never the job. It was a small part of the job that can now be delegated to AI.

Eliciting the right requirements and user needs. Creating a sound architecture and design. Validating final product meets the requirements. Ensuring there is good test coverage. You know `Engineering`. Mechanical and Electrical engineers didn't go away because of CAD.

when the tool becomes a crutch you end up with a limp.

at work, i can tell that people are not thinking and losing the ability to thinking hard.

I keep coming back to what LLMs "really" are. Recursive autocomplete, it keeps choosing the best fit for the next token. This really demystifies it for me. It also reinforces that is not "reasoning", so there's no hidden mental model.

I think this is more “gray” than this. I feel like I can rip through ideas more quickly then ever before and as a result get a lot better at designing systems and (for my work) get a lot better at designing data/model experiments.

But I empathize with the author. I think the frustration comes from the fact that other folks in your organization use these tools to “get by” more effectively then before. In the past, a disinterested engineer might ship less under the umbrage of a difficult engineering problem. With the pressure to “ship more” now that there’s AI, the same engineer is using AI to spam PRs to prove they’re working, even the quality of work is low (because quality of thought is low).

Yes, but it's also building other skills. There's no friction to learning something new anymore, and that's really quite amazing.

E.g. I've gotten pretty good at git thanks to AI because it forced me into more complex workflows. I still can't remember the commands but I really grok the concepts and terminology on a far deeper level than before, where I made a conscious effort to stay on the happy path lest I get into some odd state I don't understand. Pretty sure those "odd states" would seem quite clear to me now.

Would you work for less money and use AI ? Or would you step out - professionally - of the industry and program for passion and fun ?

I think that is a question we are all mulling about these years.

Our expertise has been packaged into a 200$ product and the competition has become ourselves.

I've, more than once, gone long spans of time doing purely management and architecture level work, then returned to programming. A little rusty? Sure. But I never forgot how to program or lost the skills that actually matter. Seems mostly like a non-issue for people already in the field.

The real issue will be with people that never learn it in the first place.

And even that isn't so bad, learning programming isn't some insurmountable hurdle. It took me less than 6 months from no knowledge to my first job.

Fair enough, let's say that happens.

But what we're gonna manage the codebase in, then? What kind of language?

Will it be a natural language, or a formal one?

I feel that "coding" cannot collapse. Coding is just translation from natural to formal language. Somebody needs to write the specs. And writing/maintaining them in natural language brings a lot of fun - shifting interpretation, inconsistency, missing specification, etc.

I don't think it's progress for the field of SW engineering. But at least more "shareholder value" will be created.

Yep.

In my experience human design -> agent code -> agent review -> release -> agent observer, does not (at all!) work. One absolutely has to be understand what is going on, how the system works, how the H/W works, etc, to catch agent errors.

The proposition of us losing those skills is terrifying.

Maybe AI will get better and we truly won't need a human in the loop. Then please also have all PRs signed by whatever model wrote them, and do not come to me for trouble-shooting.

Coders should be treated as as well as as other software users. Tools like Claude code, Antigravity, and others are applying AI to solving that problem.

I know how to create a multi year P&L projection from scratch. It gives me some insight into how much capital a startup will need to get to breakeven. A good AI tool that creates that same spreadsheet in minutes should also be able to explain why different businesses have different shaped cash flow troughs. I don't think people using tools like that is bad even if they don't gain deep insight.

It's pretty simple.

You treat the AI like a junior.

You make it write pseudo code in the tickets.

Then you make it write code in the tickets for the tricky stuff.

Have it reference relevant documentation/APIs.

Then there is no lost knowledge.

(Still, sometimes it sneaks in some "helpful" belt and suspenders, but for the most part, I know everything that is going on in the code base with this method.)

Software engineering >> Coding. How many times do we have to keep repeating this. Author wrote a fucking marketing piece.

Stop the FUD for profit

Something I noticed trying to learn rust through models, they're inherently tuned to just finish everything with even the slightest provocation so it's very hard to use them to actually learn anything, they kinda just want to do everything themselves.

At some point it won’t be realistic to ask a human to solve a technical problem any more. I’m not suggesting it will happen soon but I can at least imagine that day coming. Whereas before modern “AI”, that possibility wasn’t even on my radar.

Sewing expertise is going to collapse from sewing machine reliance

This just feels like someone whining about how ORMs result in $#1tty data access code because lazy programmers don't take the time to learn how to use a database.

When that happens, (developer thinks using an ORM means they don't need to know how to use a database,) the project eventually fails. It's the same thing with AI; just like companies learned that they need to make sure developers actually know how to use a database, companies will learn that their engineers actually need to know how to program.

The boss says we should do it this way. The boss hasn’t got a clue about how to do it. But he knows what he wants, more or less. And we can fill in the details. And we don’t make a stink about him not knowing exactly how things work. That doesn’t serve anyone. And he still thinks that he knows how to do it. Because he tells us how to do it and it gets done.

Now everyone can be the boss.

I am not personally worried on this front. It is a near-certainty that something catastrophic will happen in the not-too-distant future because of the issues Lars raises in the essay. Not until that moment occurs will there be a broader industry-wide reckoning. Most likely it will get expressed in breathless language like "you'll never believe the crazy gains we got from adding tests!" (or whatever).

I feel pretty good asserting that, as always, a few smart leaders will recognize early that quality and stability are the new game now that we have speed 'for free.' And then there will be incumbents whose eventual demise will merely be accelerated.

A list of things, that were supposed to lead to our intellectual demise:

- Writing (starting from Platos Phaedrus)

- Printed books

- Photography

- Typewriters, keyboards

- Telephones

- Recorded music

- Television

- Wikipedia

- GPS navigation

- Smartphones

- Automation in aviation, medicine, industries

And so what? How do you think people are going to be working on software in 10 years. They're going to use coding agents and harnesses that work much better than the current ones (although I don't think we're getting anything but incremental improvement from here on out). They will run on commodity hardware. I first got paid for writing code in 1999, I've worked at publicly traded software companies and failed startups, in every language out there. And if LLMs "atrophy" the expertise I built up over those years, then so what? What is lost, exactly? I stopped programming in C++ about 10 years ago when Rust seemed to get good. I no longer remember a lot of the specialized knowledge I had in C++. My life goes on. I am now becoming an expert at building software with agents. The problem is still the same, you still have to apply engineering principles. You just don't have to write the code.

look to past examples. when the greeks developed writing, people complained that the youth were losing the ability to memorize much content. and that is true, but with writing they were able to do better still and that old skill -- though useful -- was lost.

Wasn't everyone making these arguments for the last 50 years with each wave of advances and convenience? "Real programmers use [current_tech - 1]."

I mean, they were right, then, too. My meaning is that expertise already collapsed several decades ago.

--

One of my favorite talks of all time:

Jonathan Blow, Preventing the Collapse of Civilization (2019)

https://www.youtube.com/watch?v=ZSRHeXYDLko

This seems right to me, but I think that it's likely that we haven't fully figured out how to integrate AI into coding imo. I think there is user side thing that we haven’t fully worked out yet.

Hand weaving expertise has also collapsed.

I believe it. I haven't written code since March.

I was thinking about this anti AI sentiment and how it is related to American individualism. In socialist countries like China there has never been a protest related to data centres or job loss etc. unlike in the USA. Because the large scale impact of AI on the country is exclusively a net positive. The reduction of the individuals cost of labour by also reduces perceived egalitarianism which is the mental model used by ultra capitalists to allow themselves to sleep at night whilst homeless people beg for food on the streets.

The long term impact of AI on society is exclusively a net positive if utilised in the correct way. But most of the westerners lack faith in government fiscal policy and think that they are going to be left destitute when they can no longer provide for themselves. When in fact UBI is going to be the most likely outcome.

They are myopically focusing on the short term labour market effects of AI on their own profession instead of realising the long term utopian societal outcome.

"We need to ban AI because I'm going to lose my job!" - This is only said by someone who is winning in their society and wants to maintain the status quo not by those who slipped through the cracks.

[copy and pasted comment from a similar post]

While true, I'm not sure it matters.

It kinda seems like wishful thinking on our part as software engineers that one day we'll be able to go "Hah, miss me now?" but that just isn't the writing that I see on the wall.

Over the past year, I've AI-generated two large pieces of software over 2000 commits without having much depth in either domain, and my ability to deliver value as a veteran software engineer has only shrunk over the months or it can be trivially extracted into a reusable markdown file like "design bar: ensure things 'by construction' where possible", a lesson I learned viscerally over decades.

It's surprisingly late for him to notice. But wait til you think through the consequences of the already collapsing human capacity for extended written composition, which is orders of magnitude more significant.

I personally write lots of code manually and use AI to review it.

Sounds like a good compromise, if not even positive from many points of view.

Of course it will. Doesn't matter though. Coding expertise is no longer valuable.

What is valuable now is productivity. Which in today's day and age is the ability to quickly and efficiently drive AI.

Hence the never-ending growth and spewing out of tooling: harnesses, TUIs, multiplexers, agent frameworks, software "factories", etc, etc.

Software engineers are chasing opportunity and expertise in the only thing that's left.

I think the hope of the business end is that coding expertise will at some point no longer be needed at all.

Ever since I was a teenager, I started to develop cyclical bouts of existential crises.

While I have been feeling better for quite some time, I feel another starting to brew. While I was never one of the fabled 10x or rockstar developers, I still derived a lot of enjoyment and and sense of purpose from my work.

With the utility of LLMs becoming more ubiquitous by the day, what purpose can I provide anymore? I struggled greatly to get where I am today, and while it might not be impressive to any of my fellow programmers, I am still proud to be a programmer.

I obtained a degree in CS because I found the entire field to be fascinating. I had great passion for learning many of the subjects. What I learned in my degree changed my life forever. I seriously went from one of the, "What's the point in learning most math if you never use it?" to being absolutely infatuated with the subject. (I'm still bad at math, but that does not detract from my pleasure).

With the utmost certainty, I did not push through all my struggles just to prompt LLMs all day. Maybe's its my insecurities manifesting, but I want people to say, "You did a great job" and not "Claude did a great job." I understand the Buddhist were likely correct. My suffering really does come from my attachment, but at the same time, I do not want to let it go.

I have no opposition to using LLMs as tools. I think a fine balance can be achieved. LLMs can even be exceptional learning tools when used appropriately.

If programming is just a means to an end to you, then you will receive no ill judgements from me. We all have different motives in life. But programming has always meant something more to me.

I used to think this was a problem. But now? I don’t think it matters.

Why? Because people are going to get so much more ambitious about the stuff they build with AI, that code expertise for the stuff they are building is already scarce anyway. People will choose difficult and less popular languages, and will replace open source packages with stuff built entirely in-house by AI.

Going forward, there is no choice except for AI to fully replace the need for code expertise. Depending on humans won’t be scalable.

Very few people know how to hand set typography anymore, but many of the conventions still exist and people don't have to understand the origin of a lot of them to use them properly.

I'm seeing it happen in real time. I've seen several folks claim they "vibe-coded" something and upon review it's some seriously low quality garbage. Unfortunately it's just "functional enough" where it's encouraging the one who talked to the robot to continue thinking they can code for some reason.

It is important to ensure that any LLM code is named and shamed.

As always, the innovators will thrive and become the new experts in the field. Everyone else will die out.

It's impossible to buy the FUD that expertise will somehow vanish because people use AI. People come in a variety of capabilities, challenges, and personal interests. Expertise varies from person to person. Those with personality traits that are more likely to take risks and persist against adversity will be the innovators and experts. We've seen this played out countless times.

You have to ignore everything you know intrinsically but can't articulate about innovation, technology, and evolution to drink this FUD Kool-Aid.

One interesting feature of vibe coding is that it allows you to write code in specialized areas where you have no expert knowledge. That makes the code effectively impossible to review in any useful way.

For example, I have a vibe coded Python monstrosity which I use for stitching together scans of large format negatives. The enlarging lens that I use for scanning has strong chromatic aberration in the red channel but is otherwise very sharp†. I got Codex to figure out some way of using the green and blue channels to sharpen the luminance while preserving the color information from the red channel. I sort of vaguely understand how this works, but not nearly well enough to review all the horrid numpy code that implements it.

For my use case, there is really no reason to look at the code, as I am only interested in the output. As disconcerting as it is, I feel that this is going to become more and more normalized. Looking at the code that your LLM generates will become like looking at the assembly output of your C compiler.

† This makes a lot of sense, if you think about the color of a darkroom safelight...

Coding expertise was on a downward trend way before AI arrived. Does nobody remember how most "engineers" were literally copying and pasting snippets from StackOverflow they didn't understand, and the snippets usually had tons of bugs? How many of you know Assembly well? How many of you can decompile a program, or write your own compiler or VM? How many of you could pass a computer science course (that you didn't take at Uni)?

We've been hearing about the demise of skills since before the invention of the loom. The only skills we've truly lost are for things nobody uses or makes anymore. What actually happens is, we develop a new tool that's better than the old tool, and we get good at using the new tool. We then have a class of people whose job it is to maintain the new tools. We don't need that many of them because the whole point is to eliminate that labor.

Your jobs as software engineers are going away, it's that simple. Your new job is to use the AI tools to make products. Somebody else's job will be to make the AI a better software engineer.

> AI models lack judgment

Very interesting is how divisive is this statement. In that almost every response is either hard agree or hard disagree.

Does agreement come from observer judgement, or lack thereof?

We're all posers - unless you can implement square root in machine code, you're not a Real Programmer™

Coding expertise is going to collapse from compiler reliance (1985 Turbo Pascal detractors)

I'm also concerned about people asking an opaque machine for an answer and stopping there instead of going to different sources, evaluating their credibility, exercising their own ability to construct their own worldview from disparate facts and opinions.

Going to? It already is.

It may bifurcate the average skill from the skill of figuring out new solutions.

Are engineers still making 100s of thousands a year still just for vibe coding while a nurse and other skilled / highly trained medical professionals working their butt off make half of that?

Do we think there is going to be a correction for the vibe coders?

Pardon I know such question is controversial but thinking ahead.

I hate to day this, but most coding work isn't hard at all - for a human or AI. There are a lot of important skills around coding, but for most people, much of the time, they are not doing any coding that is particularly challenging, difficult, it novel.

If you have a truly hard problem - sure write some code or take a hybrid approach. Still, let's not pretend this is what most people are tasked with.

"Assembly expertise is going to collapse from compiler reliance".

Ah yes. Selling courses is the oldest grift in town, which is what the author here is doing.

To be fair nobody codes in ASM and things are fine for decades.

Except sloppy experts.

Keep in mind also that LLMs are currenctly heavily subsidized. Once VCs money are gonna run out, you will see the real price, and your 200K per year dev is probably nothing.

I learned BASIC, Pascal and x86 Assembly language by the age of 14-15. None of which I remember (nor care to). The strict instructions (aka language) we gave the compiler was not the point. Those experiences taught me how to think logically, and over time develop a taste/structure for how software should be built, as well as foot guns to avoid. I don't know how you teach that without coding, but the "coding expertise" was always a means to an end. LLMs are just another abstraction layer above programming languages, machine language, etc.

That's the whole scam. It's a ransom with more steps.

First they fuck up your codebase with so much slop that no human does (or could) understand it.

Now if you want to keep making bug fixes, you're on the hook for whatever Anthropic wants to charge you.

The solution is to make AI developers the scapegoat. Fire the people at the top of the AI leaderboards, with malice. Otherwise, lazy AI-addict developers are going to destroy what remains of your company's IP.

"Punching card expersite is going to collapse from interactive terminals reliance"

And math skills are going to collapse from calculator reliance.