The Software Engineering Identity Crisis
annievella.com
annievella.com
It doesn't surprise me though, most of the people working on this are the same that had been promising self-driving cars. But that proved to be quite hard, and most of them moved on to the next thing which is this. So maybe a decade from now we'll be directing AIs instead of writing code. Or maybe that will also be difficult, and people will have moved on to the next thing they will fail to replace with AI.
In my experience it’s literally the only model which can actually code beyond auto-complete. Not perfect but a completely different tier above the rest.
The progress made since the start has been wild, and if it keeps increasing, even at a much slower pace, it's gonna be even better.
That's like people looking at N64 games saying "wow, these new 3D graphics sure look like ass, they'll never catch on and replace 2D games". Or like people looking at the output of early C compilers going "wow, this is so unoptimized, I'll stick to coding in assembly for my career since nobody will ever use compilers for serious work".
It boggles my mind how ignorant people can be about progress and disruption based on how past history played out. Oh well, at least more power to those who embrace the new tech early on.
Why would embracing it early before it is useful give you more power?
Back with N64 or C compilers, we didn't talk about energy requirements on the level of small countries and billions of dollars to even compete with the status quo. You're like one of those guys in the fifties, thinking it'll only be a few more years until we're all commuting in flying cars powered by nuclear reactors.
I’m sure somebody said that, but I don’t think it was a common sentiment.
Rather, people said that there were still some cases that required some assembly programming. And it is true. It’s just a niche. One they gets smaller over time. If you are a generalist it makes sense to retrain. If you are a specialist, there’s some level of socialization where you can get away with continuing to program assembly.
Like, how is some hesitance towards the possibilities of this specific implementation of AI "ignorant of the progress and disruption of history". A casual glance at the headlines around blockchain ~ 6 years ago should invite some skepticism.
I think in some ways this is like looking at the difference between Camera only self-driving vs all the tools. I think it's quite possible LLM's look more like camera-only self-driving which will continue to get marginally better but may never solve the problem, and we're still waiting on the insight/architecture that will bring us full AGI.
I'll be back in line for the iPhone 3G, thank you.
I would guess that's one of those "pick any two" things, given how many construction projects, repair, "life happens" stuff goes on in a modern city
That said, unless I'm totally missing something they have a self-solving problem with that since the Waymo's all carry around cameras, lidar, and presumably radar so I would expect that they update the maps as they go. Come to think of it, that's very likely why I originally saw them roaming around the city with drivers in them: testing the pathfinding and mapping at the same time
I would believe at some point this is possible though, since at least if they send the data home about things that "don't match" with their precise maps, they can easily use as much compute as they want on the servers to get the maps updated.
The job has changed before, it will change again. It may get easier to enter the industry, but the industry will still exist and will still need subject matter experts a decade from now.
I also don’t like English as a language to express requirements, it’s not strict enough and depends too much on an implicit context. Whatever high-level abstraction we end up with it cannot be something that results in the wrong implementation because the agent incorrectly read the tone of the exchange.
That can easily be said of most Product Manager > SWE relationships too though
There are people on hacker news daily arguing this
In otherwords, they are cheaper mid to entry level employees which don’t get sick or have emotions. I think most people would agree with this.
One of the reasons well informed curious people tend to underestimate the value of LLMs despite their flaws is they underestimate the amount of routine work that could be automated but is still done imperfectly by humans. LLMs lower the barrier to entry to halfway decent automation and eliminating those jobs.
Where I’m not sold yet is on the whole idea of bots that go off and do their own thing totally unsupervised (but increasingly, you are having models supervise one another).
Which means we're doing it backwards.
AI writes code as well as a committee of StackOverflow users but reads it without breaking a sweat. Use AI to do the harder part.
he's the creator of django and has been writing about coding with LLMs since the beginning. he was one of the first people to report about prompt injection and hallucinations. you will learn about the strengths and weaknesses of coding with LLMs if you approach his blog with an open mind.
Probably quantum computing. That seems to be the next hyped up product.
It turns out that to be a good 3D printer, you need to be really good at CAD, and measuring stuff with Vernier calipers. That’s like prompt engineering.
Then there was the nozzle temperature, print errors, and other strange results — call those hallucinations.
Once I had designed something that I needed many instances of, it was great. But for one-offs, it was a lot of work. So it goes with AI.
I kind of wonder if there's a way to make ai-accessible software.
For example, lets say someone wrote some really descriptive tutorial on blender, not only simple features, but advanced ones. added some college texts on adjacent problems to help prevent "falling flat" at more difficult tasks.
could something like that work? I figure LLMs are now just reading simple tutorials now, what about feeding them advanced stuff?
> It doesn't surprise me though, most of the people working on this are the same that had been promising self-driving cars.
Where did you pick that up? That's just pure hallucination (ironically). Also what are you implying, that Tesla made LLM now? If I have to guess their amount of contribution to LLM it'd be way closer to 0 than 'most'.
It's one of those things that is so easy to say but has no actual truth.
Things like system design thinking and architectural design are not solely tasks performed by managers or specialised roles.
Software developers need to wear multiple hats to deliver a solution. Sure, building out new features or products from scratch often get the most glory an attention. But IMO, humans still have the edge when it comes to debugging, refactoring and optimisation. In my experience, we beat AI in these problems because we can hold the entire problem space/context in our brains,and reason about it. In contrast, AI is simply pattern matching, and sure it can do a great job, but only stochastically so.
LLMs are effectively optimisation algorithms. They can find the local minima, but asking them to radically change the structure of something to find a much simpler solution is not yet possible.
I'm actually pretty excited about LLMs getting better at coding, because in most jobs I've been in the limiting factor has always been rate of development rather than rate of idea production. If LLMs can take a software architecture diagram and fill in all the boxes, that would mean we could test our assumptions much quicker.
The AI is great at doing all the implementation grunt work ("how do I format that timestamp again?" "What's a faster vectorized way to do this weird polars transformation?" "Can you write tests to catch regressions for these 5 edge cases which I will then verify?").
When I find myself missing domain knowledge, my first action is to seek it. Not to try random things that may have hidden edge cases that I can't foresee. The semantics of every line and every symbol should be clear to me. And I should be able to go in details about its significance and usage.
Editing code shouldn't be a bottleneck. In The Pragmatic Programmer, one of the advice is to achieve editor fluency. And even Bram has written about this[0]. Code is very repetitive, and your editor should assist you in reducing the amount of boilerplate you write and navigating around the codebase. Why? Because that will help you prune the code and get it in better shape as code is a liability. Generating code is a step in the wrong direction.
There can be bad docs, or the information you're seeking is not easily retrievable. But most is actually quite decent, and in the worst case, you have the source code (or should). But there are different kind of docs and when someone is complaining about them, it's usually because they need a tutorial or a guide to learn the concepts and usage. Most systems assume you have the prerequisites and will only have the reference.
> Many of us don’t just write code - we love writing code.
Excuse me, I HATE writing code.
Code is the thing that is in the way between what I want to computer to do and the computer doing it. If AI reduces that burden, I would be the first to jump on that wave.
GUI programming still sucks. GPU programming still sucks. Embedded programming still sucks. Concurrent programming still sucks. I can go on and on.
I was actually having this discussion with somebody the other day that 99% of my programming is "Shaving Yaks" and 1% actually focused on the problem I want to solve.
When AI starts shaving the yaks for me, I'll start getting excited.
Code is an awful abstraction to capture chains of thoughts, but it’s the best we’ve got. Still, caring about syntax, application architecture, concurrency, memory layout, type casting, …—all of that is just busywork, not making the robot go beep.
> application architecture,
I think you got carried away with your analogy there, because I can assure you that if the LLM generates kafkaClient.sendMessage everywhere for latency sensitive apps, that's not gonna go well, or similar for httpClient.post for high throughput cases
Wow the first one is quite judgmental. FWIW, I'm the same way, I like writing some code, but definitely not all code. Writing CRUD boilerplate for a schema? No thank you, AI is more than welcome to take that.
I derive my joy from getting something done, making it actually usable by the business side, and ultimately have it to generate revenue.
But you're really NOT focused on the planes that kill only 75% of the crew and passengers. Just think! In ten years, we'll know how to build a plane!
Please stop telling me that we already have designs for planes that work. I don't want to hear that anymore."
In the grander scheme of things, what matters is if their products can still sell with AI coders making it. If not, then companies will have to pivot back to finding quality - similar to offshoring to the cheapest, getting terrible developers (not always) and a terrible product, then having to rehire the team again.
If the products do sell with AI coders, then you have to reckon with a field that doesn't care about quality or craftsmanship and decide if you can work like that, day-in-day-out.
Looking to corporate work as an out for your creative desires never really worked out. Sure there was a brief golden age where if you worked at a big tech company you could find it but the vast majority of engineers do utilitarian work. As a software engineer your job as always been to drive business value.
Edit: and yes, I am all too aware of the "market can remain irrational longer than you can remain solvent" adage as applied to this situation.
or systems where performance and reliability are paramount
Since when has that not been the case? Neglecting or even actively avoiding performance and reliability is why almost all new software is just mediocre at best, and the industry is on a decline. AI is only going to accelerate that.
It will come, even if we are a couple of years away.
They are mostly deterministic.
LLMs can also provide the equivalent of an -S switch.
Not entirely sure what I'd do with an LLM -S switch. Debug the output/intermediate representation of the LLM, knowing that the next time I press "enter", it's probably going to give me an entirely different output?
But then, aren't we all happy that we moved from human computers and to electronic computers with programming languages and compilers?
However, I do think that they will pave the way towards another technology that will work better. Possibly some hybrid neurosymbolic approach. There are many researchers working on this, and the current hype around LLM will help fund them. Sadly, it will also add considerable amounts of noise that might hinder their ability to demonstrate the usefulness of their solutions, so no clue when that future happens, if it does.
For now.
If the goal is deliver business value, an argument can be made that one could leverage AI for bits of code where high skill isn't required, and that that could free up the human developer to focus on places where high skill is more important (high level system architecture, data model designs, simpler user experiences that reduce the amount of work overall).
If a dev just used pure "vibe coding" to generate code and didn't provide enough human oversight to verify the high-level designs, then you can definitely get into an issue where the code gets out of control, but I think there's a middle ground where you have a hybrid of high-level human design and oversight and low-level AI implementation.
I think the line between how much human involvement there is versus pure AI coding may be a sliding one. For something like a startup that is unsure if their product is even providing enough user value, it might make sense to quickly prototype with AI to see if a product is viable, then if it is, rewrite parts with more human intervention to scale up.
I’m currently prepping for some upcoming interviews, which is involving quite a bit of deep digging into some technical subjects. I’m enjoying it, but part of it feels… pointless. ChatGPT can answer better than I can about the things I’m learning. It is detracting quite a bit from my joy, which would not have been the case 5 years ago
You see the process and the questions they ask and evaluate how they distill the responses. The more you let the candidate use sources, the closer it is to day-to-day work.
A somewhat similar equivalent to yesterday's copying and pasting a Stack Overflow or w3 schools solution is blindly copying and pasting a chat response from a quick and vague prompt.
But someone who knows how to precisely prompt or use the correct set of templates is someone with more critical thinking skills that knows when to push back or modify the suggested solution.
Knowing the small % of difference can make a big difference long term in code readability, reliability, and security.
The other big alternative to all of this is strict debugging. A debugging test or chain of thought around quickly identifying and fixing the source of problems. This is a skill whose needs will probably increase over time.
But while HR would love to make me a full-time interviewer, it rarely makes business sense. So we end up with unqualified people using what they were told are good signals for hiring talent.
I'm far less motivated to learn technical topics now than I was even two years ago. I used to crack books/articles open pretty frequently largely for personal reasons but much of my motivation to do so has been removed by the presence of LLMs.
I think I occupy a sweet spot now with my current skill set - AI can’t solve the problems I work on - but it can really help empower my workflow in small doses. Nevertheless, it’s a moving target with lots of uncertainty, and the atrophy of my skill and passion is palpable even in the past 6 months.
I used to pay for O'Reilly, I have a pile of software/programming/computer-related books, and meh I just don't care for it like I did.
I'd page through stuff at night, and the last year especially have really de-motivated me.
> And now we come full circle: AI isn’t taking our jobs; it’s giving us a chance to reclaim those broader aspects of our role that we gave away to specialists. To return to a time when software engineering meant more than just writing code. When it meant understanding the whole problem space, from user needs to business impact, from system design to operational excellence.
Well, I for one never cared about business impact in general sense, nor did I consider it part of the problem space. Obviously, minding the business impact is critical at work. But if we're talking about identity, then it never was a part of mine - and I believe the same is true about many software engineers in my cohort.
I picked up coding because I wanted to build things (games, at first). Build things, not sell things.
This mirrors a common blind spot I regularly see in some articles and comments on HN (which perhaps is just because of its adjacency to startup culture) - doing stuff and running a company that does stuff are entirely different things. I want to be a builder - I don't want to be a founder. Nor I want to be a manager of builders.
So, for those of us with slightly narrower sense of identity as software engineers, the AI thing is both fascinating and disconcerting.
That doesn't mean you are a salesperson. It means you are more connected to the users and their problems.
It's kind of like me saying, "I'm not a soldier - being a soldier means exercising a lot, following orders, and occasionally killing people", and you replying, "well take out the two words 'killing people' and the rest still applies to you".
The thing is, part of the reason AI requires supervision is because it's producing human-maintainable output in languages oriented for human generation; It is my belief we're at a reality akin to the surgence of the first programming langages - a mimick that allows humans to abstract away machine details and translate high-level concepts into machine language. It is also my belief that the next step are specialized AI languages, that will remove most of the human element, as an optimization. Sure, there will always the need for meatbags, but big companies will hire tens, not thousands.
At my early days, I learned more reading code from much senior engineers and began to appreciate it. An effective seasoned senior writes a beautiful poetry that conveys deeper meaning and solves the entertainment(erm… business requirement) purpose. If the seniors retire and the juniors are no longer hired, then where do LLMs get new data from?
In all sense of things, I suspect we’ll see more juniors getting hired in coming years and few seniors present to guide them, same as how we previously had few db specialists and architects giving out the outline and the followers made those into actual products.
Abstraction can be thought of as a system of interfaces. The right abstractions can totally transform how a human or machine interpret and solve a problem. The most effective and elegant machines will still make use of abstraction above machine code.
Perspective is everything, and it's hard to have perspective of the entire system on the ground floor. Getting the priors right, or getting the LLM to first consider different grammars can greatly simplify the problem and its solution.
You can think of learning as decontextualization of input data into pure relational constructs. Application, then, is the recontextualization of some relational construct in order to apply generalized relations and insights to problems of different shapes and sizes. Understanding a concept thus means mastering the decontextualization and recontextualization of a set of relations.
Using a DSL instead of pure machine code is an example of recontextualization, and it can totally change how a model understands and processes input and what kind of output is produced.
LLMs essentially read their own code when producing it, so if they lose the abstractions then they can lose the context around what they were doing and why they were doing it. It also makes it harder for them to modify their existing code.
I could certainly believe that it's plausible that there's a low level representation that LLMs would find easier than our own languages though - but an existing IR is unlikely to be it.
Also more practically speaking, LLMs struggle to write in languages that they don't have a large training dataset for.
Fyi you can do this today. Ask for a flying cape dog and have a stl you can print into a physical object.
Less flexibility yes, but a huge improvement in usefulness and productivity.
Since day one I've always liked to build things much like the author, my first line of HTML to CSS, frameworks, backend, frontend, devops, what have you. All of it a learning experience to see something created out of nothing. The issue has always been my fingers don't move fast enough; I'm just one person. My mind can't sustain extended output that long.
My experience with AI has been incredibly transforming. I can prototype new ideas and directions in literally minutes instead of writing or setting up boilerplate over and over. I can feed it garbage and have it give me ballpark insights. I can use it as a sounding board to draw some direction or try to see a diff angle I'm not seeing.
Or maybe it's just the way that some people use AI coding? Like it's some magic box and if you use it you wont' understand anything or it's going to produce some gibberish? Like a form bikeshedding where people hold the "way" they code as some kind of sacrosant belief. I still review near every line of code and if something is confusing I either figure it out and rewrite it or just comment on what it's doing if it's not critical.
You are still in charge and you still need to read the code, understand it, make sure it’s factored properly, make sure there’s nothing extraneous..
But ultimately it’s when you demo the thing you built (with or without AI help) and when a real human gets it in their hands, that the real reward begins.
In the future that’s coming, non-engineers will be more and more able to make their own software and iterate it based on their own domain expertise, no formally educated software engineers in sight. This will be outrage fuel for old-mindset software engineers to take to their blogs and shake their metaphorical walking-sticks at the young upstarts. Meanwhile those who move with the times will find joy in helping non-engineer domain experts to get started, and find joy once again in helping their non-engineer compatriots solve the tricky stuff.
Mark my words, move with the times people. It’s happening with or without you.
Of course that could be my info bubble (Bluesky instead of twitter, newsletters, slightly less attracted to shiny than I used to be)
Anybody else feel the same?
Vibe coding doesn't care about the implementation details, so Svelte is dead.
A unified codebase might be better for humans. But a FE/BE database is better for AI, because you have a clear security boundary, separation of concerns, and well-known patterns for both individually.
I'm not ideologically against LLMs as a technology or the usage of them, but I do believe there is an inherent unfairness in the way a small set of companies have freely hoovered up all of this work meant to enhance the public commons (often using the most toxic and anti-social web crawling robots imaginable) while handwaving away what I believe are important copyright considerations.
I'd rather just not release my own source code anymore than help them continue to do that.
As for whole apps, I never agree with its code style... ever. It also misses some human context. For example, sometimes, we avoid changing code in certain ways in certain modules so as to get it more easily reviewed by the CODEOWNER of that part of the codebase. I find it easier to just write the code "the way they would prefer" myself rather than explain it in a prompt to the LLM losslessly.
The best part of it is getting started. It quickly gives me a boilerplate to start something. Useful for procrastinators like me.
Problem is it doesn't know the layer of utilities we have and just rewrite everything from scratch. Which is too much duplicatation. I have to now delete it and type correct code again.
One advantage I have seen is that, it can defenitely translate / simplify what my collegues say, fix typos or partial-words. Which is very useful when you are working with lot of different people.
The code quality isn’t great but it’s a lot easier to have it write tests, and other code, and then go back and audit and clean.
Feels absolutely awful but whatever.
I dunno, it just doesn’t seem, like, all that thought out to me.
Most of our job is fixing slop. Previously this was slop produced by low quality cut rate developers in countries known for outsourcing. Now it’s just fixing AI slop and foreign outsourced slop.
We’re all just swimming as the AI wave comes crashing on every developer out there - we can keep swimming, dive or surf. Picking a strategy is necessary but it would probably be good to be able to do all of the above.
At this point, I am totally confused. When I attend expensive courses from Google or Amazon, the idea in the courses are that, tech has become sooo complex(I agree, look at the number of ways you can achieve something using aws infinite number of services), we need some code assistants which can quickly remind us of that one syntax or fill out the 10000th time of writing same boilerplate or quickly suggest a new library functions that would take several google searches and wading through bad documentations on another 5h of SEO spam or another 50 StackOverflow with same issue closed as not focused enough/duplicate/opinionated.
It is like, they want to sell you this new shiny tool. If anyone here remembers the early days of Jetbrains IDEs, the fans would whirl and IDE would freeze in middle of intellisense suggestion, but now those are buttery smooth and I actually feel sad when unable to access them.
Now, on the outside in news, media, blogs and what not, the marketing piece is being boosted a 1000x with all panic and horror, because a certain greedy people found that, only way to dissuade brilliant people from the field and not bootstrap next disrupters by signaling that they themselves will be obsolete.
Come to think of it, it is cheap now. First idea was to hire them when investments were cheap and disruption risk was high, then came the extinction of ZIRP when it was safe to stop hoarding them as no investment means less risk of disrupters, but if some dared, acquire and kill in the crib. Then came bad economy, so now it is easier to lay them off and smear their reputation so they can’t get the time of the day from deep pockets. Final effort is to threat the field by fake marketing and media campaign of them being replaced.
This panic drama needs to stop. First we had SysAdmins maintaining on-prem hardware and infra. But Aws/Gcp/Azure/Oracle came along to replace them to only move them up the chain and now we need dedicated IAM specialist, certified AWS architects, Certified Azure Cloud Consultants and what not.
Sorry for the incoherent rant, but these panic and “f*k you entitled avocado toast eating school dropout losers, now you’ll be so screwed” envy social media posts are so insane and gets so much weird, I am just baffled by the whole thing.
I don’t know what to believe, big tech telling me in their pretty courses and talks about how my productivity and code quality will be now improved, or the media and influencers telling me we are going to be so obsolete (and avocado toast eating dropout, which I am not). Only time will tell.
In the meantime, the more I see demos of impressive LLM building entire site from everyone and their pet hamster, the more number of Frontend engineering jobs popup daily on my inbox(I keep job alerts to watch market trends and dabble in topics that might interest me).