I spent a long time honing my trade and I did learn a lot in the process, so I want to believe this argument, I really do. But then I imagine it applied to a lot of pre-industrial era jobs and I am not so sure.
"Master, should I still learn to weave our beautiful Persian rugs by hand?"
"Yes, and... Have you seen one of these mass-produced rugs? They all look the same and their quality is terrible! And how would you ever operate one of those new machines if you don't know a good rug from a bad one? By learning to weave manually, you are also learning about choosing the right yarn, negotiating the right prices with the merchant down at the market, selecting a good apprentice to pass down the trade. All these things will always be useful!"
Yes, there are still artisans making and selling beautiful rugs at premium prices. But most people now are content with resting their feet on a cheap Ikea thing that they can replace every few years, so that market has shrunk to almost nothing.
Is it possible the size of the market for hand woven rugs has actually stayed the same, and the mass produced variety has simply filled the void for the large segment who were never able to afford them?
Yeah, the small, useful bits of code I've made this year at work could have been contracted out in years past (we're a tiny non-tech co). But in addition to expense, there's the hassle of coordinating it, QA, etc. Really dont need all that for a project that connects a couple APIs with a minimal UI to help automate something previously done by hand.
I don’t write the same program over and over again so I am always confused by how exactly this industrialization metaphor is supposed to map on to software development
Think of it this way, the Persian rug isn't the same pattern every time either. The base job is the same, but the implementation requires planning and the like. A rug making machine is good at creating the same thing over and over again, but not very good in being flexible.
Software... a lot of software is basically the same thing (database, api, frontend), the only difference is what data and business rules. But the act of writing code isn't very different. It's the what code to write where software engineers come in.
Hello all, I wrote this article to help students considering CS as a major.
My own son has just started university studying CS, so I have skin in this game.
I continue to believe in what I've said in this article despite being startled (like most people) by the advances in AI recently.
One thing that I have noticed since writing this article is that the most effective vibe coders are already excellent developers, which I think is in keeping with the themes I discuss here. While I do expect the amount of hand-written code to decline, I think that knowing how code (and technical systems) work is going to continue to be valuable and perhaps even more valuable. I have no crystal ball, but that's what I'm seeing right now.
It’s good but I kinda disagree with them stuck issue. Getting stuck is frustrating and having an easy way to get unstuck seems good.
However, the skill of having to try many different things and have patience and deal with an unproductive day and sleep in stuff, being able to pull yourself out of a hole, bootstrap deeper understanding in times when you feel helpless…it’s character building and incredibly valuable.
I feel like AI will allow people to have less resolve and determination, like looking at the crossword answers.
Yes, but they're still going to encounter those moments, just at different points.
The same way we never stopped encountering "Wait, what the hell?" moments when we had the internet and could search for problems instead of digging through textbooks or --help, they'll just run into those blocking moments at a higher level of abstraction, then have to backtrace the problem down to the level they need to understand to resolve the issue. Curious people continue to be rewarded with a higher ceiling, but the floor to get something functional is brought down.
The alternative is that AI just deletes software engineering as a discipline and everything gets vibecoded, which still seems unlikely even if the improvements continue to accelerate.
So even if the improvements continue to accelerate, even when you get to a point when an agent not just codes but also designs, optimizes for complexity and maintainability, you don't think software engineering as a human discipline gets deleted?
I am in a similar position. My son is a talented high school programmer considering colleges. He has expressed Anti AI sentiment to me. This article gives us a useful lens and I appreciated it a lot.
Yeah. I have worked with people who have a very low threshold for struggling and reach out the moment something isn't obvious. They never learn anything. They can go for years and years never growing or improving in any way.
The problem is AI lowers all barriers to reaching out. Previously you'd have to ask a real person, which might be embarrassing. I do wonder if I would have struggled as much if I didn't have to. I look at what's happened to people's bodies when they no longer have to do physical labour and I wonder if the same thing will happen to their minds.
The struggle is necessary to grow, sure. But we're free to choose and upgrade our struggles. After calculators and then computers, struggle in math levelled up.
> I think that knowing how code (and technical systems) work is going to continue to be valuable and perhaps even more valuable.
I think the art of refactoring will be more valuable than ever.
I'm having an LLM free day today, going through a lot of generated code, de-duplicating and making the abstractions more usable. It's quite enjoyable and improves my understanding of the code significantly.
Thanks for these insights. They made me think of AI as what a mechanic is for your car. He knows more and is more capable than you, and he can save you a lot of time vs if you had to do the dirty work yourself.
However, the more you know yourself about car maintenance, the more you will trust his diagnosis, solutions and the fairness of the money he asks for it. More generally, the more you will trust him to act in your interest instead of only his (or someone else's).
Thank you for the article but what about students who truly have no connections? It seems like a bleak time for us, none in my family work in even a corporation that would need tech people and my friends are in similar boat.
Luckily I was able to complete an internship lately (implemented EEVDF scheduler for Redox OS) but even then, the amount of Rust Junior jobs are so rare that it is proving to not be of much help.
"friends" is not limited to people that you grew up with, or studied with, or people that your parents knew. They can also be contacts that you made by reaching out, in social circles or through shared interests or tecnhical workshops, etc.
Out of school for awhile, but covering low-level topics, down to logic gates, assembly, and doing floating point math manually, is not something I _use_ every day, but was crucial both when programming in higher level languages, and now using AI tools to write code in higher level languages.
It feels like there will be a beefy "middle" where people can probably drop some of that context, and get a lot of productive things done with AI. But there will still be a need for people more deeply knowledgeable and educated. It's probably just not in the proportions we have today.
_Kind of_ like the boom of coding bootcamps. A lot of people got good work done going through a coding bootcamp, but didn't get the deep background that a CS major would.
Coding bootcamps didn't mean we don't need CS education, and neither will AI, I expect. But the numbers and jobs are definitely going to change.
Thanks for your thoughts! Can you explain why in your model being able to read code will stay any more important for tomorrow's coders than it is for today's managers? Is it resting on the assumption that tomorrows models will be worse at that than tomorrows coders?
1. my ignorance is massive so don't bet on my predictions. There's so much FUD. This is like the industrial revolution but on steroids.
2. I see the moat around software decreasing quickly. Therefore, I'm going to project that there will be fewer coders in software only companies (such as Adobe, SAS, or Intuit)
3. It will be easier to support software so I see the need for more technical entrepreneurs. Software is going to be an amenity with services, hardware, or support. The code itself isn't going to be valuable like its current form.
4. I would project there will be more programmers in the future, but not pure programmers. More like the 1970s programmers who had other professions but would create their own programs.
I'm not sure this is more significant than the industrial revolution, but it is certainly faster. I am withholding judgement until we start to see real world changes beyond symbol manipulation.
I agree there is little moat around code qua code now. I'm not sure that means there will be fewer coders, because the people in the best position to take advantage of this new technology are... coders.
I again agree that code qua code is becoming less valuable, but I think that ironically _understanding_ code (and systems) is going up in value. Complexity still grows super-linearly and so judicious technical decisions will need to be made.
I strongly agree with your last point and I am advocating for a "+CS" track here at Montana State, where non-CS majors can learn enough practical CS to be productive and then excel in their own major. I'm speculating a 3-4 class track with AI/vibe coding as part of it.
As someone who just started university studying CS as well, I really appreciate you writing this blog. I recently went into a bit of a p(doom) spiral worrying about CS, uni and maybe sort of an existential crisis and I had an discussion on HN with a more experienced person about it which went into similar topics[0]
Also, I wish for your son to have a good university experience and hope he makes great friendships and connections which help him throughout his life and I wish the best for his future and to enjoy the present as it happens :-D
> Is Coding → Prompting like Assembly → High Level Coding? […] I do not agree with this simile. Compilers are, for the most part, deterministic in a way that current AI tools are not.
It’s not quite about the determinism. It’s about being able to reason about the relationship between source code and compiled program with formal precision. You can predict which changes in the source code will lead to which exact changes in the behavior of the compiled program. The same isn’t the case about changes to an LLM prompt and the LLM’s output.
You could make an AI deterministic by fixing its source of randomness. That still wouldn’t allow you to reason about how its output will change when (for example) you add or remove a word in the prompt. The only way to find out is to run the LLM (= have the prompt run through the model and observe what comes out).
That is the fundamental difference. Changes to source code have predictable and reason-able outcomes. You generally don’t have to compile the code and test it to know how precisely the change will affect the behavior of the compiled program according to the semantics of the programming language. That’s the case even if the compiler uses some probabilistic heuristics for trade-offs in code generation, and hence isn’t deterministic on the machine code level.
To repeat, the difference is how you can reason about a compiler’s behavior versus an LLM’s behavior. Programming languages are designed such that you can reason about it. With LLMs it’s always an experiment.
I think you're wrong, the compilers are already unpredictable (or chaotic, better to say than nondeterministic, as someone pointed out). However the classical compilers limit the effect of unpredictability to resource use (such as CPU, memory and binary size), and not the "result" of the program.
Although even program results are not guaranteed, famously C standard leaves some things undefined and up to implementation.
So the analogy works as long as you understand that natural language itself (aka the prompt) doesn't give complete specification, and it's the LLM itself which selects a particular formalization. But in principle it's not much different from compiler electing to use an optimization and making program faster. Or using a particular flavor of stdlib.
In fact today even the execution itself is unpredictable. For example, a different input can cause cache eviction or branch misprediction, making a loop much slower. Or a different thread might execute on hyperthreading core, affecting the performance.
I think with LLMs, we will be in a long tail of finding those scenarios (where natural language leads to big misunderstanding) and fixing them.
But you're comparing vibe coding to using a compiler. This is an important comparison but you don't need to use LLMs this way; that's why, I think, senior engineers are more effective with LLMs than juniors.
When coding, a few things are happening. You build a representation of what you want to achieve in your head and translate that to code, aka "typing the code", which is actually a pretty complicated process but certainly not all of the entirety of the software engineering process. Then you review what you wrote and commit.
With LLMs you still maintain steps 1 and 3. you reason about the solution, translate it to English and then let the LLM do the "typing the code". Finally you review the output.
The output review is completely deterministic and you have the opportunity to even tweak the LLM's output to match your mental model. The nondeterministic nature of the LLM isn't super relevant because it just changes how much work you do in this step. At this point it's just like standard coding minus the typing. Ultimately it's still an objective relationship with the compiler. It's very much like how tech leads engineer a system through their teams.
Assuming that you truly understand and own every line of the LLM's output, the model is almost working like a macro.
It comes up a lot, it's almost not worth arguing as it detracts.
I might take on to saying that compilers are more deterministic than vibe coding, that should stop the vibecoders from arguing about how technically 1+1 is not deterministic because of UB in C or whatever.
That said, they'll probably start debating that something is either deterministic or it isn't, and we can answer that they couldn't be more wrong, and they'll answer that wrong is an absolute state and not subject to gradation, , and we can answer that of course it's relative, it's wrong to say a tomato is a vegetable, but it's more wrong to say it's a suspension bridge, and then we can finally go to bed because the online arguments have all been solved, the end, it's done.
You can vibe code without knowing what a function or a variable is. What is an int vs a bool vs a string. You can absolutely build something useful with today's technology without knowing how any of it works underneath. If you know how it works underneath you'll have a leg up on someone who doesn't, but what's the opportunity cost of knowing how that all works underneath. What are you missing out on and not learning while you're learning and reasoning about the aforementioned 1 & 3?
You can build lots of interesting things now without understanding the code, but the maximum complexity of what you build will always be defined by what the latest model and harnesses are capable of without architectural guidance.
If whatever you built is good enough for you, then the model was ipso facto sufficient. This has been true for many small projects since the first coding agents came out over a year ago.
I think the correct word to use is "chaotic", in the mathematical sense (e.g. double pendulum).
A tiny change in the inputs can result in a large (and hard to predict) change in the output. Non-determinism is a different axis completely, and some compilers are (semi-accidentally) NOT deterministic either (two runs are not byte identical)
Thank you for this; I think you've hit on a problem I have explaining this point. I tend to lean on the determinism aspect, but it never felt right.
As a sibling commenter said, I agree that the concept here is "chaotic". A small change in the input (the prompt) can create large (or not!), unpredictable changes in the output. And variations on that small input change can have wildly different effects on the output.
But a change (large or small) to C code will create predictable (large or small) changes to the assembly output.
I think this narrow view on determinism comes up a lot. Essentially any program can be made deterministic over single inputs by fixing all side-inputs. But there is determinism over classes of inputs too, eg. an algorithm given input X deterministically outputs X+1.
I think the wider view is usually what people mean when they talk about nondeterminism in LLMs. Maybe because computers are traditionally so deterministic the wide view is almost taken for granted by programmers.
It's not the narrow view, it's the only actual definition of determinism. Words have meaning. Determinism means "same cause = same effect". If the cause is underspecified and requires interpretation that varies depending on the interpreter, the whole concept is meaningless. Intelligence (human or machine) operates in an underspecified domain, it makes sense to talk about undefined behavior, misinterpretation, alignment, anything really, but not determinism.
Random number generators are deterministic. If you give it the same seed, you get the same result. But that does not mean that a human can predict, for a new seed, what the result will be.
only a Sith deals in absolutes. There's a big difference in the strength of the connection from input to output between LLM edits and writing the code.
Another thing about compiler, if your input(source code) is stupid and not follow the expected format, it will outright refuse to generate output for you, no matter how much you ask or whatever trick you pull.
With LLM, if your input is stupid, the llm may/may not nudge you and happy to continue with that input and gives it 100% effort.
I agree with basically everything said here, BUT i wish people would stop (mis)using the word "deterministic" in this way:
> Compilers are, for the most part, deterministic in a way that current AI tools are not. Given a high-level programming language construct such as a for loop or if statement, you can, with reasonable certainty, say what the generated assembly will look like for a given computer architecture (at least pre-optimization).
> The same cannot be said for an LLM-based solution to a particular prompt.
This is the correct and meaningful difference to point out here, but it has nothing to do with determinism. LLMs could be perfectly deterministic and still suffer from the same problem. The problem isn't that LLMs themselves are nondeterministic, it's that language is imprecise, and language models themselves are (for the most part) black box text processors. An imagined piece of functionality ("feature") has to pass through both of these somewhat opaque steps before it ends up as code, unlike code that is processed by a compiler, where both the constraints and the structured /formal understanding of the input are much stronger which allows us to reason about and trace the relationship between inputs and outputs in ways that we can't for LLMs and natural language.
I read this when it first came out (Feb 2026) - I agreed with it then, and I still agree with it now. But I also just think that knowing the fundamentals is important, some people really believe we're "skipping a step" and that won't be important. Either way, people who already have good fundamentals are probably going to be using them WITH LLMs, and it doesn't take a ton of practice to "keep up" with fundamentals (see an expert jazz guitarist play a C scale, rudiments come back quickly when they're engaged).
Are people still writing any code by hand? My VP doesn't even READ code anymore. I rarely write code, but I've found a great spot between "full offloading" and staying really in tune with the "actions" I'm taking as together they form the "whole" deliverable at the end of a project / task. I still try to understand what the problem is, I draft a solution to solve it, then sometimes I'll give that solution to AI, and other times I'll compare my solution with the AI solution.
But, for the most part, I believe I'm somewhere in the middle? (Yes it's faster to use AI to generate code, but I still want to see that code when it's done and make sure it matches the broader system)
I'm mostly curious what other devs experience is...
I write everything by hand still. I don’t believe speed vs quality trade offs are worth it. Somehow I’m still shipping as fast as my peers. Where LLMs have saved me time is in research and finding the right documentation.
You should be careful. It’s not just about being faster. LLMs can write more tests, more reliably, and find things that must be changed following a change that you might overlook, and find contradicting requirements so much better than humans. You can probably keep up in terms of speed , though I doubt it for nearly every programmer I’ve ever met including myself… but almost certainly not with the same level of quality and thoroughness, despite what people on HN seem to think.
I’ll be ok, I produce higher quality work than any LLM ever will. And if that time ever comes, which I seriously doubt, it’s not like it’s that hard to prompt.
LLMs will hallucinate edge cases or worry about things that just aren’t possible within context. It results in more tests than are needed. I personally dont think LLMs are any good at all.
A month ago I was still talking like you. Then I said to an insisting colleague, “watch I’ll try to vibe code a game engine and show you the crap it produces.”
Granted, this wasn’t my first game engine so I knew exactly what to say, but I was completely floored. GPT Sol & Astra at max effort was flawless at nearly everything I threw at it. I’m talking fully ground up, zero dependencies, just the primitives and SIMD. Fully featured engine done in two weeks with deferred 2-stage render pipeline, shadow maps, mesh shaders, MSAA, post processing, collision, physics, the works.
I even intentionally skipped a few important optimizations and went back to refactor them in, thinking there’s no way it can do a wholesale rewrite of major systems, but it did it. I got dry mouth from all the jaw dropping. My prompts got shorter and more ambiguous, so it would ask me clarify. I audited every line of code, and it was good (after adding two skills.md). I gave up. I’m a reluctant believer.
It sucks, but sadly these things are really good. Don’t be last contrarian, there’s nothing to gain. You’re just lying to yourself
I could keep pace until about half a year ago. But it meant hands-on typing code for the full work day. Now with claude I can produce similar output in 1-2 hours, most of the time is spent on iterating and having the LLM review the code and fix it by itself and then me testing everything. There is more risk of letting the LLM make judgements and building the wrong thing and me having a smaller chance of discovering holes in the requirements because claude is happy to confidently make the wrong decisions.
This is exactly the approach I’m limiting myself to: LLMs as a very smart rubber duck to assist in research and understanding complex systems. I have no interest in it writing the code for me, just like I have no interest in another person doing the same.
I am the engineer, I am the one that has the vision, and I am the one that needs to understand the thing down to the minute details.
That said, most systems I still write are not so complex I need a very smart assistant, so I rarely use LLMs at all; it is still a valuable skill being able to research and think hard for yourself. An LLM cannot think out of the box (of its training dataset), and there lie the discoveries and paradigm shifts that move tech forward.
I really and unironically applaud you, when the code you're writing has higher quality than the average AI produces AND it means something.
In the domains I get paid to work in, it simply doesn't matter.
The code was shit to begin with, because of hundreds of hacks due to underspecified or simply wrong requirements, bad code practices, architecture that couldn't keep up but was never fixed due to stubbornness...
Not saying we humans would do better or worse in general, just sharing my experiences.
I have customers where AI usage is absolutely forbidden and others where it's totally fine and colleagues vibecoded mess will come to bite them/us all.
I enjoy programming and producing high quality work. Why would I want to give up the thing I find fun and produce something subpar?
> The code was shit to begin with, because of hundreds of hacks due to underspecified or simply wrong requirements, bad code practices, architecture that couldn't keep up but was never fixed due to stubbornness...
My coworkers have always produced slop, even before LLMs. Unfortunately, as the lead on the project it’s still my responsibility to get that up to a certain quality level or at least make it isolated and malleable enough that it can be changed and we all won’t have a bad time doing it.
I guess what I’m saying is.. I get it. It’s hard to work with other people who are just pushing whatever is given by the LLM. But I still have fun doing it myself.
> I explain that, if they don’t write the code, they will not be able to effectively read the code. The ability to read code is certainly going to be valuable, maybe more valuable, in an AI-based coding future.
I'm not certain of this. Thinking back to when I first started in my career after graduation- I remember feeling like my ability to write code had improved greatly during my time in school. Meanwhile, my ability to read code felt like it had barely improved at all. Even now, after over a decade in the industry, while both skills have improved tremendously, I still feel like my ability to read and internalize code is not at the level I would like or assume it to be simply as a result of my experience.
It could very well be that reading and writing are two separate (though related) skills that require intentional practice and honing on their own. I can't speak for everyone, but reading code as a skill, for me, only really began to develop once I had a job where it was expected of me.
Maybe it's possible to learn to read code without learning to write it. It certainly feels like its possible to learn to write it without learning to read it.
Yeah I agree that reading is a different skill from writing, especially reading someone else's code - I think doing code reviews is a great and valuable skill that should be taught alongside but separately from writing code. Can you reason about someone else's code without immediately rewriting it or jumping to "Well I would have written it differently"?
It's an important skill to learn, as a lot of software developers enter the market as "selfish", thinking they should understand and / or own all code, and if there's too much code or too many other people, they will advocate for microservices so they can once again own their slice of code.
But that's coding; software engineering is coding at scale, over time, and for the last two you need a different (albeit complementary) skillset of both hard and soft skills (hard skills being reading / understanding / reasoning about code, soft skills being letting go of your own ego and giving constructive feedback)
Strong agree. School had me writing stuff myself on the order of a few KLOC at most, and maybe collaborating with a "group" in which at most 2 people actually did anything. What little exposure I got to reading a large codebase I didn't write, was all in personal projects trying to mod open source video games. I'm sure some people had more extensive experiences but that was my bachelor's.
First job had me using a programming language I wasn't super familiar with and trying to add a feature to a codebase 100s of KLOC, all written by other people. Definitely a sink-or-swim moment. My skills of reading and navigating the dreaded Other People's Code were all honed over the next dozen years.
That being said AI is a lot better at reading code than I am, as demonstrated by its ability to find incredibly subtle bugs in huge codebases. So I'm not even sure those code reading skills are all that useful now. When I have to review somebody else's code I get more mileage from pointing an AI at it and asking targeted questions like "how does this handle when a Foo's approval is revoked" than reading it myself line-by-line. I'm not saying I never use those reading skills but the ability to get the big picture, chase down deep callback chains, know where to look... those skills are likely to atrophy.
It's like using GPS vs. knowing the roads as well as a cabbie. GPS gets you pretty damn far for zero effort.
Reading code was always much harder than writing it and it's certainly the root of many NIH syndrome disasters. Writing helps, but you're right that these are two seperate and related skills.
Reading code is very hard because you have to build a mental model from code that others wrote. You’re trying to understand what they wrote, the intent behind that, and what’s wrong or missing - that’s just a fundamentally hard thing.
But building mental models based on data and communications from others is one of the most valuable problem solving and communication skills there is in business, precisely what Carson is getting at in his essay.
Don't think you can be a mature developer unless you can fluently read code. I tell everyone learning to code that reading code is equally important. In our world of AI tools reading code is turning out to be a key skill.
Not GP, but the main thing is that there is always some conceptual model being a good codebase. Meaning there’s the problem, then a given set of data structures and algorithms that forms a solution for that model.
It’s often hidden behind the syntax and implementation because of the layers of abstraction. A single operation (semantic wise) may be scattered over many statements, and some definition may be important in several subconcepts. It helps to be familiar with various technical concepts as possible. basic data structures like lists and trees, more advanced concepts like scheduling and concurrency, as well as platform concepts like files, process, networking,…
Why? Because they are implementation details that distract from the main conceptual model. It’s like how OpenBSD handle device discovery and configuration. Once you know that it’s a tree, you just need to remember how you build a tree and then most of the code are obvious. You can then discern the traversal stuff from the actual device configuration easily and know how to focus your reading.
I don’t think so. I strongly believe that writing and reading is pretty much the same, because they are strongly related to thinking. They are even secondary to the latter. I often interacted with juniors and other colleagues and those that do have issue with writing and reading often struggle with formalized thinking.
Taking a problem or a wanted behavior and dissecting it down to logical manipulation is hard for those people. They can go down one or two layers but then they got lost while building the necessary abstraction. You can observe it pretty much in real time as they’re losing track of assumptions for the current context. Thinking that way is a skill and once you can do it, reading and writing code is pretty much effortless.
Both learning to write and learning to read is merely a proxy of learning to think. Doing one while not doing the other is handicapping yourself for no reason.
I disagree with the author. I think as LLMs get better at coding it will be more likely that that fewer devs will be required to keep systems running and progressing, the bottleneck at my company is already new revenue generating ideas. We've seen a roughly 30% increase in speed of new features, so the same number of devs are building a lot quicker. I expect that to continue to increase. I also see a lot of Devs simply trusting that the code is correct, they are losing touch with the code.
I don't think I would encourage my kids to get involved with programming, instead I would encourage them to become entrepreneurs who might use some coding.
You can achieve similar increases in speed by for example working faster, using a more expressive programming language, omitting things like unit tests, or adding more developers - the real question or test is whether the pace is sustainable, if the output is functionally and non-functionally correct, things like that. Software engineering problems that aren't actually new but the awareness of which has been given a boost with the advent of LLMs and their (perceived, short-term) productivity and output boosts.
But who will maintain those features going forward?
> I also see a lot of Devs simply trusting that the code is correct, they are losing touch with the code.
My worry is that developers can't outsource their understanding to AI forever. It's a lot of risk for companies to be accumulating code faster than developers can understand them.
AI will maintain the features, unless you think we're going back to the old days? The job of a developer will become 1) writing and refining specs, 2) "managing" agents by answering questions, evaluating new models, new tools, etc, 3) testing and validating AI output.
Hey just because you mentioned specs, we went back from the huge amount of md files to no md files at all and having the code being self documented for our AI based workflow (we have projects using AI and others with human workflow).
If necessary there is tooling to generate docs from the code itself. There is also tooling for code quality and other things. You can also use AI to help build deterministic tools for specific code quality verification you may want - all major languages have established ways to parse the code and generate easy to inspect AST and code metrics that can be used for arbitrary quality measurements.
The entire “API” (all the code objects and functions interfaces) were carefully architected so their “contracts” are well determined, with very explicitly defined types. The machine written code now can evolve it directly and it has much less impact on context, which allows using very cheap and fast models and reduce a lot of expense while producing quality and predictable code output. Just a heads up if you are still using many md files and relying too much on the big frontier models.
if an agent so capable of maintaining the mess of AI slop, i bet it can also do these
>1) writing and refining specs, 2) "managing" agents by answering questions, evaluating new models, new tools, etc, 3) testing and validating AI output.
There are certainly lots of product-minded developers, but there are also lots of developers who couldn't design a product or come up with useful product features if their lives depended on it.
I do think perhaps LLMs could give product-minded developers more time to think about and refine those ideas, though.
In my experience, new ideas are mostly generated by people who are involved in non-software stuff
A software engineer isn't going to come up with a revolutionary new mining technique or robot or something. But someone who works at a mine might. Previously those people would go find a software engineer to try and validate their idea. Now they will go to AI
I dunno. Maybe I'm wrong, but I just don't see software engineers as being the best people to generate a lot of new ideas for domains outside of software engineering
This is why I have always advocated for getting my software engineers away from code occasionally and out into the field into whatever domain in which we're working.
We need to experience and see how the world actually works, the pain people are actually experiencing. I deeply believe we build better software that way.
Have a software engineer working for a mining company that's a good candidate to drag out into the field for a bit? Get 'em out there, encourage them to ask tons of questions.
Real example: my wife is a nurse who works for an insurance company to coordinate care for injured workers to help maximize their recoveries. I hear a ton about the stuff she has to do, and just having her tell me about how things work has given me a glut of ideas of how I could help her bypass all the administrivia so she can focus on helping the folks she's really passionate about helping. Wouldn't have had any idea about any of this, otherwise. Unfortunately for her, I don't work for her company so can do nothing about it, but the ideas!
> We need to experience and see how the world actually works, the pain people are actually experiencing. I deeply believe we build better software that way.
90% of the time when you really break down the "real" problems. You learned they aren't gon a be fixed by fucking software.
I wholeheartedly agree with you that software isn't the answer for everything; engineering teams get so deep in building that's all they can think of when faced with a business problem.
Less software coupled with operational changes would have helped many organizations I've witnessed across my career, but that's not politically palatable in a lot of places.
My experience (as someone who has almost exclusively worked as a software developer in non-software companies) is that my primary value add is the ability to recognize things that a computer can do easily, versus problems that are not solvable by throwing software at it.
For example, when I was working in a finance team, I'd come across all sorts of situations where someone had a task of "once a week, download this data from this application, apply the following transformations, then upload the results to this other application". Anybody reading this site would think "ah, that's like a dozen lines of code! We should automate that". But that thinking is incredibly rare outside of our field.
On the flip side of that, you'll have the people who think they can simply buy software that will solve all their problems. "No, ma'am, buying a fancy new Spend Management System will not magically make everyone know or care about the difference between 'GL 10754 - Employee Appreciation: Meals' and 'GL 10822: Employee Meals (Discretionary)'".
My take on it is that the ability to recognize automatable problems boils down to 1) having an intuitive understanding of algorithmic reasoning ( this solution comes in 4 parts, the first part can be divided into 3 separate problems, which...) 2) having an up-to-date understanding of the extant capabilities of computers. 3) having the kind of bull-headed hubris that makes someone say "Sure, we currently do it this way, but I can do it better".
And at the end of the day, those features end up meaning you need some sort of engineer.
This isn’t a skill exclusive to software developers though - there are a lot of domain experts who can identify these opportunities as well. Not a majority perhaps - it seems like 15-20% at my company - but more will develop this skill by working with AI.
If they can reason about software engineering enough to be able to successfully develop software, then they are software developers. (I’ve yet to see a person who can say “we can automate this!” without actually thinking like a programmer and yet reliably be correct about that.)
One of my hobbies is telling people with extremely elaborate Excel spreadsheets (the kind that companies run on) that they're programmers even though they didn't think they were.
Right, I work with several of these people, but they understand this. There is a real intimidation factor with general purpose languages, with all their tools and elaborate rituals. I feel the same way about alien platforms like z/OS. Oddly enough, many programmers are intimidated by Excel or at least never use it even when it is clearly a better tool for a particular task than the ones they are familiar with.
Domain expertise is good, but coupled with software knowledge is almost a superpower, when it comes to software projects.
I have seen projects that took 6 months when done by 1 expert + 1 engineer taking mere weeks when done by a single person who were good at both, in a competitor.
It will be faster to understand it, which will make it less valuable. I think I could point something like this to a curious AI software builder without a CS degree and tell them to have AI explain it and they could make up a significant chunk of what they're missing by not having a CS degree. https://www.cs.yale.edu/homes/perlis-alan/quotes.html
It could be that because we can rapidly generate customized programs that the dedicated software industry shrinks, but companies might stop buying/licensing software and instead bring more software engineers in house.
They already got rid of junior devs. You don't need them to get better as you're already right. Idk how the author can recommend comp sci. Juniors are more likely to win the lottery at this stage than get an offer.
> I also see a lot of Devs simply trusting that the code is correct, they are losing touch with the code.
My team has a non-engineer vibe coder who doesn’t know how to even use git, but managed to put together a large application that serves enterprise customers better than the real SWEs we had working on the project.
We’re in the process of porting their code into the main codebase, and it’s obvious to me, not so much them, that there is an insane amount of waste. But I’m not sure whether that’s a bad trade off, the end product works and llms get whatever he needs done.
OTOH, I’m an experienced SWE who is taking a stab at writing dev tooling in rust, which I don’t know and don’t have the time rn to learn. I am very aware there is a lot of waste, the project is obviously moving slower than if I was more involved with design. I was ok with the trade off but I’m growing antsy now.
All to say, it feels to me that vibe coded tech is a viable path so long as you accept what you’re going to get.
The one exception I see rn is when we try to do brownfield work, LLMs get very confused and simply cannot manage an old dog shit human written system with a new set of concepts floating in. Jury is out whether this will also happen with ai slop, but again maybe it just doesn’t matter
I've been managing a software project for several years now. It's gone through a few major iterations but those have only coincided when I've had other engineers to help me. The code is for testing new devices against a couple racks of equipment. What I had a few months ago has worked pretty well but there's been some issues with error handling and limit checking. I basically just work on the thing when I have time, amongst being a hardware development/production/test engineer. Little changes are easy but something like adding in a bunch of error handling is a lot for me. It's relatively easy with python but I'm an electrical engineer and this thing is so spaghettified that it's really difficult to crack into these crust test scripts to structure them the right way.
Over the past year, I've been trying to better document the equipment according to new QA standards. This also means I need a way to test the racks without production hardware. Everything goes hand-in-hand, how do you test a car without an engine? We finally got access to an approved IDE with a built-in AI model so I figured I'd try that out. I had been using our ChatGPT-equivalent tool for a few months for little scripts and questions but that's pretty ineffective for a major code base. That new IDE cranked out a slick certification application that does everything I need in about a day. I turned it back to my existing codebase for the production testing and gave it my wishlist of upgrades and features. Took about two weeks but I'm ready to push v1.0.
One of the main issues is that I'm not the one usually testing new devices, technicians are and they aren't always familiar with the software or equipment. Automating an entire test was a big effort a couple years ago and I got to the point where after a bunch of setup, you just click the GO button and sit back to watch. But now, AI has automated even more of the process so all of the stupid config files one had to setup previously are now automated. The various apps you had to run in the background are all built into one package. The silly little bugs I was dealing with for years have totally been wiped out with better error handling and monitoring of connections. It's amazing how well this new thing works and how much it actually looks like a real software engineer made it. It's even got simulators built in so we can test every part of it without needing actual equipment or the production units.
I've been wanting to find a new job for a while but this automation project has been holding me back. I've so badly wanted to complete it because I'm the one that wanted it in the first place. If I had like six months of dedicated time with the equipment (impossible, at best I get a couple weeks of downtime), I maybe could have made something similar but it would have been lousy code. With just two weeks of working with AI, I'm over the big hurdle. I've still got a few things to clean up before its ready for production but I'm basically 40 hours of work away from being at the point where I could just walk away. Hell, I just realized I could even have the AI write the manual as well.
> Maybe they don’t start as a “computer programmer” there, maybe they start as an analyst or some other role. But the ability to program on top of that role will be very valuable and likely set up a great career.
I believe this is the best advice in the thread.
The ability to build custom programs that solve real corporate problems is an invaluable skill:
- An accountant who can code is a 10x accountant.
- An analyst who can code is a 10x analyst.
- A procurement manager who can code is a 10x procurement manager.
The list goes on.
You don't need to be part of some new 21st-century enlightenment of Rust programmers. A bit of JS, Ruby, or Python here and there, layered on top of an existing corporate skill, is so valuable to a company it's crazy.
I think this is a way to be explored for juniors struggling on the job market today.
> However, I think that this is a temporary situation and that soon companies are going to realize that vibe coding at speed suffers from worse complexity explosion issues than well understood, deliberate coding does.
If you're working for a company where the the top level of management doesn't have a CS background, don't expect this to happen.
That’s just silly. It’s like saying that people who don’t have a legal background are incapable of understanding that the law will impact their decision making.
What I’m seeing is that managers understand the problem but are purposely ignoring it in the short term because they’re trying to stay competitive. It’s just another kind of technical debt but in different clothing.
It not silly at all. I'm not even saying it's a bad thing. From their point of view, they would rather have increased error rate if it means faster shipping speed. This is nothing new, AI just multiplied it. Startups especially want to ship fast and look at longevity later. Unless this drive is countered by someone up the chain who wants to do things properly, it will naturally happen and you can't do anything about it. Well you can, but then you will be explaining to your manager why your tasks are done so slowly when Chad Vibeson over there shipped 5 features and 100k lines of code last month alone.
No, but... is the better answer in my mind. Learning to code is a considerable commitment. It takes years to get good enough to produce professional-grade software. If you extrapolate from the improvements we've seen in coding AI over just the last 12 months, this is just a bad allocation of your time.
Instead, as the article points out, learn to become a translator between the real world and AI code generation. Learn about industries that are relatively underserved by technology. Don't build tools for developers or engineers. Learn about construction, mining, waste management, oil and gas, manufacturing, logistics, government... then become the link between that industry and AI's ability to add value.
(Emphasis on relatively underserved — all of these have high-tech versions in some places, but the future isn't distributed evenly.)
> If you extrapolate from the improvements we've seen in coding AI over just the last 12 months
This is the achilles heel of your argument. I think people sometimes conflate realizing unmet potentials of LLMs with significant improvements, since there’s not been a fundamental change in how LLMs work as significant as the advancements we see in their application.
I've programmed for 30 years so I'm probably mentally locked into thinking about the code underneath it all. But I never understood the details of the electrons moving around in the computer, and it took a long time to even consider what happened as my code trickled down the compiler/JIT, into the OS, down to the CPU.
I don't think it's productive to tell students today they must spend all their time understanding the code. Because it's clear now so many people will bypass that, even myself included. Some of the most fun I have with software these days is figuring out how to make it without looking at the code (for now on side projects only, see below).
I agree we're not quite all the way there yet to do this with large production systems. Yes, LLMs are highly fuzzy and non-deterministic things, but so are electrons! As computers improved we handled random bit flips that would occur due to a large number of unpredictable reasons. In either case, we have to reach a high enough confidence and redundancy bar that it doesn't hinder our productivity.
Raising confidence and redundancy in code output from LLM is still a nascent field. We're learning some things like "maybe unit tests don't work as well for LLMs as they did for humans", and "if the AI can self-evaluate in a loop against a factual number, it does a lot better".
But yeah, in this rapid wave of change I would consider "write the code yourself" more and more similar to "know how your CPU does branch prediction so your loops perform better", and the majority of our efforts will need to go into raising our confidence in this new fuzzy shape of software.
> But yeah, in this rapid wave of change I would consider "write the code yourself" more and more similar to "know how your CPU does branch prediction so your loops perform better", and the majority of our efforts will need to go into raising our confidence in this new fuzzy shape of software.
I mean, I benefited massively from reading Vol 1 of TAOCP and understanding Knuth's new assembly. Like, it hasn't been directly useful but I now have a deeper understanding of how my code actually executes, which has helped me contextualise performance problems.
So, I guess that I'm with the OP on this (this may change if we can figure out automated verification for software, at which point I'd be happy to mediate most things through an LLM with tools).
> For example, the ability to write, think and communicate clearly, both with LLMs and humans seems likely to be much more important in the future.
No, LLMs will do it for you.
> Some business folks look at AI and say “Great, we don’t need programmers!”, but it seems just as plausible to me that a programmer might say “Great, we don’t need business people!”
We won't need either.
> I think software architecture will become a more important skill over time: the ability to organize large software systems effectively and, crucially, to control the complexity of those systems.
No, LLMs will do it. It's no harder than solving complex math problems, so why wouldn't they?
> I try not to use LLMs to generate full solutions that I am going to need to support. I will sometimes use LLMs alongside my manual coding as I build out a solution to help me understand APIs and my options while coding.
> I never let LLMs design the APIs to the systems I am building.
Then you'll be left behind by those who do, because they'll ship faster. And surprise, the quality won't be any worse than yours.
They will ship faster what? Different software requires different levels of diligence. A pop-up web site for an event and a piece of foundational infrastructure code have almost nothing in common.
> the quality won't be any worse than yours.
Does the current practice support this claim? My claim is that with a kind word and a gun, I mean, with human expertise and LLM's ability to do intellectual legwork, it is possible to achieve more than with just an LLM.
>> we don’t need business people!
> We won't need either.
ROTFL. Did you see what e.g. good salespeople do? Very often they are more important for success than engineers, and I say it as an engineer.
>> the ability to write, think and communicate clearly
> No, LLM will do this for you
I hope this is said in jest. If not, I rest my case and just wait for the reality to land its sobering uppercut.
> I hope this is said in jest. If not, I rest my case and just wait for the reality to land its sobering uppercut.
The ASI believers would say exactly the same back to you. If a machine can think better than humans, then outsourcing thinking to it will get better outcomes, however degrading it is to humanity. Presuming, of course, the machines still listen to us when they are superior to us in all ways.
Well, it's sad that the professor's advice for how to get a job today is "networking", same as it always was. I feel bad for those who don't have family or friends who work in the industry.
I think you have a pretty narrow view of things if you consider "family or friends who work in the industry" as the only form of networking. Clubs, conferences, online communities, and build-and-release-useful-things are all effective forms of networking.
The job market is the pits and feels more like a game of musical chairs than an evaluation of aptitude and ethics. Lots of old paths are getting very narrow. Some are closing.
But we now have tools that let you just build big things, all by yourself. In this new world, bonafide coding expertise is helpful. But it's not required. New graduates should just get out there and start making things.
I think you have a significantly narrower view than them. Consider someone moving to a new city or someone getting out of jail. It takes time to do the networking you're talking about. People need to eat and networking doesn't fill your stomach.
And that's one of the risks of moving to a new city, and arguably one of the risks you take when you commit a crime worthy of jail.
As for the new city risk, you take that risk with the potential upside it could bring, but everyone will be wary. People new to a city are a risk because of all the reasons they might've left an old city.
The author shows his age by recommending that student to go into a cost center at Costco. In AI resume land you really need the keywords more than ever to both start and keep a career in this industry.
This article was similar to what I told people a year ago.
A year later and AI used properly is a better programmer than I am. Used properly means given meticulous guidance to write production quality code. I see very few people using AI properly now, but that will change soon, particularly if lower cost options become widespread (you need to spend a lot of time and tokens on testing and verification). It's not that delivering hand-written code will just decline, it's that it will be like writing assembly- something that's unsafe and needs to be justified.
The job of a programmer is now to be a technical lead and work through technical decisions with AI, write specs, and review work. But as AI gains intelligence and organizations figure out how to give it access to the information it needs, it will make better technical decisions than humans.
As long as a programmer can in some way produce more value/$ using AI then someone that doesn't know programming, then there's a huge value to programmers. But I don't see the place where AI can't go up the chain and do that itself as it gains more intelligence.
This is effectively true of any job that can be done at a computer. Although programming is one of the more difficult jobs its also one that is easy to train on.
My advice if one's main goal is job security would be to do something in the physical world.
I agree with OP. It’s already the case that when I write code by hand I forget to do stuff that an AI with good instructions would never forget. I struggle with Boolean conditions that get more complex than a few operators while the AI can easily explain and track things like that. Debugging in your head was necessary sometimes to figure out why something was doing unexpected things, now you ask an AI and explain the strange behavior and it will tell you exactly what the problem was in seconds. In summary, at least let the AI review your work, you will be surprised how many issues it finds. At some point it’s just not worth it trying to do things manually, it’s even becoming irresponsible, like not using a type system ( though even that argument was polemic once)
You are explaining why it’s safer “for you” to let AI write code for you, considering the safety here is being put forward in comparison to coding in assembly. That’s fair.
But it still doesn’t explain based on what principle and logic this is the case with regard to coding in a higher level language vs. assembly.
Let’s reframe the question: why do you think writing in assembly is less safe? Do the same reasons apply to AI coding? What are those reasons?
Don’t get me wrong, I think it’s good to let AI have a pass at the code, but this doesn’t lead to the above conclusion IMO.
LLMs will always be biased by the training set used on them. I don't see how they will become an entity that knows everything there is to know about a domain to make the correct decisions.
I know from experience that Claude will be confident about something, but when I push back it will concede quickly. And it will happily overly complicate the code, come up with made up requirements or rules that it inferred but are completely bogus.
I agree with practically everything you wrote here! I wrote a piece on how software engineering is changing and might continue to change, which makes some similar points, but less eloquently/concisely (https://henryarmburgjennings.com/blog/splitting-software-eng...)
Do you have a way I can subscribe to anything you write in future (RSS feed/Atom/mailing list)?
I can compare this to my early days. At first I was using Visual Studio like everyone else and relying on auto-complete and built-in symbols to figure out how to make something, or I would just copy and paste examples from the internet, and then tweak until something works. But what actually made me understand what I was doing was switching from an IDE to a simple code editor. Because then I couldn't use auto-complete as a crutch, I had to actually read the documentation, understand how a library is structured, which methods are supported, what the parameters are. This helped me slow down, learn the concepts, instead of blindly throwing things at the problem and seeing what sticks. And I'm having a similar experience with the AI now, it's easier to just prompt continuously, feels productive, but then I find a bug or bad logic and trace it down to a prompt where the LLM made a mistake that I wasn't aware of, and this happens a lot. The solutions it provides are rarely optimal and it's easy to fool yourself that it handles everything.
Do you take your hot air balloon up and trust where the wind takes you?
Do you sail across, into, and down the wind, using its power but still choosing where you go?
Do you cycle under your own power, lifting your saddle, tucking your head down, and trying to avoid the wind’s effects as much as possible?
All three are valid! Most people can’t sail or produce 400W with their legs, but most people can operate a hot air balloon burner. The capital expenditure part of this analogy might work as well:
the balloonists spends a reasonable amount of money to ride where the wind takes them;
the yacht crews spends fortunes to conquer the world as first-class wind masters;
the cyclists go it alone through sheer human strength and persistence, with a handful of them being astonishingly good at it.
(I cycle to work btw, albeit on a 50lb Pashley cruiser. Bike level autonomy at, erm, hot air balloon speed!)
I have no no need for this, but I guess beginners could ask AI about a programming task and instruct it to ask them questions on which step to implement next, so they learn how to write and architect good code. Basically have the AI walk you through it and make you think.
Weird that is exactly the theme in Ted Lasso Season 4 Episode 7 but the article seems to have been released February 27, 2026 while the Ted Lasso Episode was released September 16, 2026. Who's original idea was this?
I'm in the other camp. I do think we have achieved abstraction of what we know as code (and gaps are being filled rapidly). Today I'm able to build, improve, and maintain programs of decent complexity, all without writing or reading a single line of code. Programs that could have easily taken 6+ months is ready in hours. Determinism or not, I'm able to ship useful solid programs without coding. I even have an online course for non-coders to build and launch their ideas in under an hour.
Programmers make computer programs. LLMs make making computer programs more affordable and efficient, resulting in more computer programs and higher demand in programmers. We don't know what programming would be like in 10 years, but why would demand in well functioning computers go down?
I do a lot of interviews for my employer and anecdotally the current batch of college hires seems worse at answering the questions I give them than prior groups. I try to avoid leetcode style questions unless they tell me they've done competitive programming. Typically I ask a somewhat open ended question that requires implementing some complicated but not particularly tricky business logic. I used to be able to ask a few follow-up questions that added additional requirements but lately I've found candidates struggle to even finish the original question. It may not matter since the reality is LLMs could handle the sort of questions I ask just fine, but I do wonder what the long-term affects of this decrease in coding fluency will be.
but I do wonder what the long-term affects of this decrease in coding fluency will be.
Why there should be any long-term affects? That is simply the new reality of job interviews, and that's it. Coding fluency and leetcoding on interviews became worse because it's role in successfully passing the interviews has significantly decreased.
AI tools can be deterministic by setting the temperature to 0. This does allow it to behave as a high level programming language, contrary to what the article claims.
It's the architecture. That's the correct answer here. The current models produce good implementations. They're also quite good at identifying and planning for edge cases. But, today, a successful software project requires picking the right atoms for the job.
Some of the calculus for that picking will change, since volume of code that must be produced becomes less of an issue. And I don't doubt that models next year and year after will be able to make better formative architectural choices. But as it is now, I'm certain that actual systems handling real workloads require a human designer.
Someone who knows what good software looks like is empowered with agents. Someone without that knowledge isn't going to create a high quality system yet.
Didn't you guys have to handwrite your code during exams, at least the basic programming classes? I feel like that's an immediate reason you need to know how to code.
Definitely, that's an immediate test for whether or not you actually did any of your work. Even just asking for some basic pseudo code would be a good check.
> Computer programming is, fundamentally, about two things:
1. Problem-solving using computers
2. Learning to control complexity while solving these problems
Pretty sure your forgetting more than half of computing…
… 3. The modeling of external systems into code.
Modeling isn't solving a problem, it’s representing an external systems with a degree of fidelity. That’s different from solving a problem through transformation, albeit far harder to teach.
That's great but in the corporate world nobody cares about anything but ticking the boxes, shipping features and covering ass.
They will all virtue signal about how they're an "ethical" corporation that "prioritises humans" and "puts safety first". In reality they outsourced you to India because it was cheaper and now they're going to outsource you to AI because it's cheaper still.
The social contract is broken, there is no career in anything anymore, every single skill you can learn will be commoditised and automated and unfortunately thats a necessary evil. You will have to fight corporations and private equity for every scrap tho.
The only jobs that AI cannot take, by definition, are:
- Government mandated roles with legal accountability such as C-suite (all decisions will be made by AI but a human CEO/CFO must be legally accountable), various safety monitor roles that will likely be nothing more than Homer Simpson clicking Ok.
- Any job where the market is prepared to pay specifically for a human (think higher end daycare, nursing, waiting etc where wealthier customers will pay more for the status of having a real human)
- Ownership of a company, assets, anything - AI will never be allowed to own anything otherwise whats the point. The only way you'll be able to make money as a human doing something you might enjoy is if you start a company
It was always and will always be the case that you "futureproof" yourself in a field by getting the basics, not by following the latest trend that may or may not be relevant in a few months or years.
I never said sth about "going back" but we can have all the "skills" related to current models/agents completely replaces by new skills in a completely different paradigm in 5 years. The same way that the early "prompt engineering" skills are irrelevant now. But understanding how a computer and a program works in a fundamental level has stayed more around than any other trend.
The instinct to control complexity becomes vitally important in an age where AI junior coder can create millions of lines of redundant slop if not properly guided and limited.
> Is Coding → Prompting like Assembly → High Level Coding? […] I do not agree with this simile. Compilers are, for the most part, deterministic in a way that current AI tools are not.
I have a very different view of this, coming from C++. "Undefined behaviour". Compiler optimizations that only kick in if you align your chakras just right. Memory alignment and cache locality being completely vibe-based, relying on hopes and prayers that the CPU actually does what your mental model thinks it will.
In many ways it's EXACTLY like C++ -> Assembly. You never know what you ended up with until you run the benchmarks, just like you never know what your AI generated until you look at it!
"What do you mean? This worked in the debug build! Why does it crash in release?!"
But with a compiler you can see why the compiler did what it did, with AI you have a black box. Even if you fixed the AI model to be deterministic you could still not see why it produced the specific output for that specific input.
As the lowly programmer, rather than a compiler engineer or a CPU architect, I will never dig into the reasons why my tools decided to do something crazy. I'm much more likely to just try random things until it works. How is that different to how people use LLMs? Even here the opposite is true, the LLM enables me to ACTUALLY dig into the lower levels and work around those issues! It will happily dig into the Chrome source to find exactly why my page rendered weirdly, or why an optimization didn't kick in!
I mean, that's kinda on you, though, right? If you're just going to poke at your code until it works, that's your choice, I guess, but I wouldn't call it good programming.
The point is that it's reasonable and possible to predict the compiler's assembly output from high-level source. Maybe each individual can't do it, but they could, with a little learning.
With LLMs, you just can't predict the output for a given prompt, and can't predict how changing that prompt will change the output (or how much it will change the output). Even the people who build and work on LLMs every single day and know them intimately can't.
I think in few years LLMs would be so good that the programming language used by humans to build software would be natural human language. LLMs would abstract out high level programing languages the same way where we don't write assembly code today. Hence, I'm not sure how important it would be to learn programing languages.
However, it's totally make sense to learn theories and concepts behind computer science and engineering like networking, encryption/cryptography, etc. if someone wants to be a software developer in the future.
"It is no secret that the programmer job market is bad right now, and I am seeing good CS students struggle to find positions programming.
While I do not have a crystal ball, I believe this is a temporary rather than permanent situation."
Yep, any day now people will stop using AI and all the jobs will come back. Of course the author believes this if they're a professor. If students didn't think they had a job they wouldn't want to study comp sci and there would be no reason for professor for it, either. Even though they have a kid doing comp sci, gotta call them out of touch if they're not steering away that choice given what tech is today...
I feel like the better value will be in physical sciences where you are also solving problems, sometimes
concretely and sometimes abstractly, or even philosophy.
Sure, but it's not always feasible to divide work like that. If I'm working on a big problem and 2% of it is writing regexes, I'm not going to farm that work out to someone on my team who likes crafting regexes. That feels inefficient and kinda annoying. I'm either going to slog through it myself, or ask an LLM.
> “Yes, AI can generate the code for this assignment. Don’t let it. You have to write the code.”
I wrestle with this: In what world will _anyone_ suffer what we suffered by coding manually, reading docs, and posting in forums to learn when there's a magic "do it" button?
I don't think it's realistic that a 19 year old kid is going to troubleshoot some horrendous SQL query for 3 hours to figure out what's wrong when an AI can fix it in 3 seconds.
I don't know what the answer is tbh. Perhaps software engineering just "ends" with this latest batch of people. It's a game of chicken: can ai get good enough before the final wave of devs dies.
I'm right there with you, but I think we are in the minority. There aren't enough of us to sustain software development unless LLMs get good enough so this doesn't matter.
Yeah I've always said that the main skill needed to be a software developer is frustration tolerance. Personally I'm very glad to see so much of the ridiculous crap we put up with just disappear.
On the advice to junior devs to work intentionally and slower than their vibe-coding peers, I see an analogy to the advice given to student journalists at the start of newspaper subscriptions being replaced with online news access.
There will be a few developers that will work slowly and have the best understanding of the work at hand, but in my opinion the majority will be stuck at companies churning out whatever gets them paid.
Fast vibe-coded solutions that frees up time to work on more and more paying projects is what capitalism demands.
The Capitalism motivator rarely slows down by choice, because capitalism only cares about numbers going up, not people or their determination
Yes, and a lot of cope. No young person will read this, and "yeaah I should go to college to study for a CS degree." Job security is going to shit in most university specialties.
Unis are eating themselves alive; you have to be brain-dead to go there (maybe only to pursue a military officer career, as the world war ramps up) when the trades are so hot right now.
The target audience of this post is boomers and, I guess, some millenials not-yet-disu
illusioned with, who look fondly back on their education.
I think you underestimate the difference between white collar and blue collar work. The trades are not for everyone, and it's not a simple substitution to just pick another career track and be fine with it.
Programming is dead, learning to program is useless. You will never fix a single line of code produced by AI. You don't need to understand what AI delivered, or what language it used, you just need to run it to see it delivered what it was asked to build
Architecting is the new programming. Apps are a dime a dozen now, you can have your own excel, word, photoshop, quake, anything you want at the snap of your fingers, so apps worth will approach zero. What you do with apps is another story and there exactly is where value is
Business intelligence to use apps to increase productivity
"Master, should I still learn to weave our beautiful Persian rugs by hand?"
"Yes, and... Have you seen one of these mass-produced rugs? They all look the same and their quality is terrible! And how would you ever operate one of those new machines if you don't know a good rug from a bad one? By learning to weave manually, you are also learning about choosing the right yarn, negotiating the right prices with the merchant down at the market, selecting a good apprentice to pass down the trade. All these things will always be useful!"
Yes, there are still artisans making and selling beautiful rugs at premium prices. But most people now are content with resting their feet on a cheap Ikea thing that they can replace every few years, so that market has shrunk to almost nothing.
reply