GitHub CEO: manual coding remains key despite AI boom
techinasia.com
techinasia.com
In No Silver Bullet, Fred Brooks argues that the hard part of software engineering lies in essential complexity - understanding, specifying, and modeling the problem space - while accidental complexity like tool limitations is secondary. His point was that no tool or methodology would "magically" eliminate the difficulty of software development because the core challenge is conceptual, not syntactic. Fast forward to today: there's a lot of talk about AI agents replacing engineers by writing entire codebases from natural language prompts. But that seems to assume the specification problem is somehow solved or simplified. In reality, turning vague ideas into detailed, robust systems still feels like the core job of engineers.
If someone provides detailed specs and iteratively works with an AI to build software, aren’t they just using AI to eliminate accidental complexity—like how we moved from assembly to high-level languages? That doesn’t replace engineers; it boosts our productivity. If anything, it should increase opportunities by lowering the cost of iteration and scaling our impact.
So how do we reconcile this? If an agent writes a product from a prompt, that only works because someone else has already fully specified the system—implicitly or explicitly. And if we’re just using AI to replicate existing products, then we’re not solving technical problems anymore; we’re just competing on distribution or cost. That’s not an engineering disruption—it’s a business one.
What am I missing here?
Most problems businesses face have been seen by other businesses; perhaps some knowledge is in the training set or perhaps some problems are so easy to reason through that a LLM can do the "reasoning" more-or-less from first principles and your problem description.
I am speculating that AI will help with both sides of the No Silver Bullet dichotomy?
What happens after that, I have no idea.
Seems like OpenAI (or whoever wins) could easily just start taking over whole industries at that point, or at least those that are mostly tech based, since it can replicate anything they can do, but cheaper. By that point, probably the only tech jobs left will be building safeguards so that AI doesn't destroy the planet.
Which sounds niche, but conceivably, could be a real, thriving industry. Once AI outruns us, there'll probably be a huge catastrophe at some point, after which we'll realize we need to "dumb down" AI in order to preserve our own species. It will serve almost as a physical resource, or maybe like a giant nuclear reactor, where we mine it as needed but don't let it run unfettered. Coordinating that balance to extract maximal economic growth without blowing everything up could end up being the primary function of human intelligence in the AI age.
Whether something like that can be sustained, in a world with ten billion different opinions on how to do so, remains to be seen.
But it does raise the question, how much of our work is true innovation? When I reflect back on my previous projects, most of them are just copying some feature that other services already have. For these, an AI may be even better than humans in the near future, with less appetite to put a personal stamp on the feature, and perfectly happy to copy a boring but predictable standard. How much of tech industry employment does that type of stuff account for? Because it's going to disappear.
There were other projects that were maybe slightly innovative, but that innovation could have been summed up in a couple sentences, and everything else derives from that. And I imagine that's about what the future of these kinds of projects will look like. Sum up your innovation in a couple sentences, and let the AI figure out the rest. And slowly, AI can start proposing its own slightly-innovative things based on what users want or what it understands about the world, and start running this e2e as well.
I've only worked on a couple projects that were what I'd call cutting-edge. But even these, it's kind of like a combination of new technology, new trends, new products, new user needs, all coming together in a way that, is it really innovative? Or when you're aware of all these things, is the "innovation" obvious? And if so, can an AI be made to maintain awareness of such things, and identify the "obvious" innovations?
I guess that's the trillion-dollar question. And we'll probably find out the answer sooner than we'd like.
It sounds to me like a corporate equivalent of a drug-fueled rager. They want everything good now while deferring all the expenses to tomorrow.
Once you remove all the roadblocks with syntax and language blindspots, the high cost of refactoring, the tedium of adding validation and tests, the challenges of integrating systems... suddenly, the work becomes more pure. Yes, you need to know how to do advanced structural things. But you don't need to learn very much about all the rest of it.
And we very quickly get to a point where someone who can break down problems into tidy Jira tickets is effectively programming. Programming was never really about learning languages but making computers do things, which is a transferrable skill and why so many engineers know so many languages.
Even the simplest tickets sometimes that end up requiring a one line change can require hours of investigation to fully understand/stamp the effects of that change.
And perhaps I havent used the greatest or latest, but in my experience LLMs break down hard st anything sufficiently large. They make changes and introduce new errors, they end up changing the feature, or worst case just ouright break everything.
Id never trust it unless you have an extensive amount of good tests for validation
I've seen it written that the main reason managers tend to want to get rid of SWEs is because they don't understand how to interface with them. Using an LLM solves that problem, because you don't need a nerd to operate it.
Oh god please kill me
That’s because software is nebulous enough that you can get away with promising the moon to customers/boss, but in the next meeting, you’re given a reality check by the SWEs. And then you realize the mess you’re thrown everyone in.
Managers knows how to interface with SWEs well (people interface with professionals all the time). Most just hates going back to the engineers to get real answers when they fancy themselves as products owners.
SWEs are also about the most expensive kind of employee imaginable. I imagine that’s incentive enough.
Until you do. LLMs are great ar building prototypes but at some point if you don’t know what you’ll doing you’ll end up with an unmaintainable mess and you won’t have anyone to fix it.
I mean LLMs perhaps are capable of doing that too but they still need to be guided by people who are capable of understanding their output.
Being able to reduce the number of engineers that you need by e.g. 80% would still be a great deal though.
In other words, they are not good managers. A good manager should be able to work with all kinds of people with different backgrounds and personalities.
It's certainly how actually using AI in earnest feels, I have been doing my best to get agents like Claude to work through problems in a complex codebase defined by enormous amounts of outside business logic. This lack of ability to truly intuit the business requirements and deep context requirements means it cannot make business related code changes. But it can help with very small context code changes, ie incidental complexity unrelated to the core role of a good developer, which is translating real world requirements into a system.
But I will add that it shouldn't be underestimated how many of us are actually solving the distribution problem, not technical problems. I still would not feel confident replacing a junior with AI, the core issue being lack of self-correction. But certainly people will try, and businesses built around AI development will be real and undercut established businesses. Whether that's net good or bad will probably not matter to those who lose their jobs in the scuffle.
So it seems AI will just let us stretch further and make more accidentally complex systems.
E.g the most complex deployments are not the ones that are the least error prone or require the least amount of intervention.
2. The level of expertise and skill required to set it up and maintain
And I’m saying this as someone who kind of adopted AI pretty early for code and who learned how to prompt it.
The best way to make AI worth your time is to make it work towards a predictable output. TDD is really good for this : you write your test cases and you make the AI do the work.
But when you want a visual result ? It will have no feedback of any clue, will always answer "Ok, I solved this" while making things worse. Even if the model is visual, giving it screenshots as feedback is useless too.
Software engineering for any non-trivial problem means a baseline level of essential complexity that isn't going away, no matter the tool, not even if we someday "code" directly from our minds in some almost-free way via parallel programming thought diffusion. That's because (1) depth and breadth of choice; and (2) coordination/socials, mostly due but not uniquely related to (1) are the real bottlenecks.
Sure, accidental complexity can shrink, if you design in a way that's aligned with the tools, but even then, the gains are often overhyped. These kinds of "developer accelerators" (IDEs, low-code platforms, etc.) are always oversold in depth and scope, LLMs included.
The promise of the "10x engineer" is always there, but the reality is more mundane. For example, IDEs and LSPs are helpful, but not really transformative. Up to a point that people are being payed right now and don't use them at all, and they still deliver in a "economically justifiable" (by someone) way.
Today it's LLMs. Tomorrow it'll be LISP Machines v2.
Small businesses often understand domain less, not more, because they cannot invest as much as big businesses in building expertise. They may achieve something within that limited understanding, but the outcome will limit their growth. Of course, AI can help with discovery, but it may overcomplicate things. Product discovery is an art of figuring out what to do without doing too much or not enough, which AI has not mastered yet.
(and certainly Google's newest AI model is actually a step backwards on this front)
Add to that that nothing changes for difficult work. Writing a driver still requires hardware knowledge ... of the actual hardware. Which AI doesn't have ... and doesn't make any attempt to acquire.
I've seen articles that this part can actually be fixed. If you create a loop where the AI is forced to slowly build up low-level knowledge it can actually find this sort of things. But you need 10 expert AI researchers to do anything like this.
(frankly I don't see how this part could be fixed by better AI models)
What's in danger is the coding job consisting of "write me a form with these 20 fields". The 100% repetitive ones.
Stakeholders (client, managers) have been "vibe coding" all along. They send some vague descriptions and someone magically gives back a solution. Does the solution completely work? No one knows. It kinda works, but no one knows for sure.
Most of the time, it's actually the programmers' understanding of the domain that fills out the details (we all know what a correct form submission webpage looks like).
Now the other end has become AI, it remains to be seen whether this can be replicated.
Obviously we don‘t as phone numbers can be split in up to 4 fields with conflicting varieties of validation or just be one field.
millions of forms around the web would like to have a word… :)
decades of building garbage-barely-working forms is a proof that we just do not know (much like we (generally) don't know how to center a div on the page so once-per-year, without fail, top story on HN is "how to center a div" :) ).
What they have: An undergraduate intern who is a former used car salesperson used to BSing their way through life.
just look at software: cost of duplication is basically zero and here we are paying subscriptions (to huge profits) every month for it
switching to a true post-scarcity economy is gonna take more than just technology i think...
GenAI is such a boon at present because it occasionally delivers acceptable mediocrity to PMs and Stakeholders who will accept said mediocrity because they have no real clue what they (or their customers) actually want. It’s a system of roles and output that delivers based on patterns in incomprehensively large data sets, provided to humans who cannot hope to validate that information is accurate or legitimate (and not just random patterns in a large enough data set), but passed along as gospel from digital machinegods. To a withering empire obsessed with nostalgia and whose institutions are crumbling beneath them, GenAI appears as a savior; to those confident in their position in the world order, it is merely a thin tool in a larger toolbox, to be used toward greater ends rather than middling output.
Those who understand the specification problems are in a position to capitalize off such monumental shifts, while those blindly chasing get-rich-quick schemes, grifts, and fads will be left behind.
Is this just business domain knowledge and good communication?
After using Claude Code to vibe code some stuff, it seems to me that AI doesn't eliminate accidental complexity, it just creates more of it and takes away some of the pain of really bad APIs.
- Articles about tricky nature of tech debt aren't written by people who call the shots on whether the team can spend the entire next week on something that a customer can't see.
- Articles about systems architecture aren't written by people who decide how much each piece of work was significant for business.
- Books on methodologies are optional read for engineers, not essential for their job, and adoption happens only when they push it upwards.
Most of the buzz about AI replacing coding is coming from people who don't see a difference between generating a working MVP of an app, and evolving an app codebase for a decade and fixing ancient poor design choices in a spaceship which is already in flight.
I've even seen a manager who proposed allocating 33% time every day on 3 projects, and engineers had to push back. Such old and common knowledge that it doesn't work is apparently still not a job requirement in 2025. Despite that organizing and structuring project time allocation is management competency and not an engineering skill, it is de-facto entirely up to engineers to make sure it's done right. The same managers are now proud to demonstrate their "customer focus" by proposing to ask AI to resolve all the tech debt and write all the missing tests so that engineers could focus on business requests, and same engineers have to figure how to explain why it didn't just work when they tried.
To talk about complexity is to repeat the same old mistake. I am sure most engineers already know and I am yet to see an experienced engineer who believes their job will be taken by simple prompts. The problem we should be talking about should be titled something like,
"Software Engineering Has Poor Management Problem, and AI is Amplifying It"
on this topic I suggest everybody who works in our industry to read Peter Naur's "Programming as Theory Building"[1] and a nice corollary from Baldur Bjarnson: "Theory-building and why employee churn is lethal to software companies"[2]
[1]: https://pages.cs.wisc.edu/~remzi/Naur.pdf [2]: https://www.baldurbjarnason.com/2022/theory-building/
Downside is there is much more non essential busy work because of which people had their jobs and now loads of those people will lose the job.
People who do work on real essential complexity of systems are far and between. People who say things like "proper professionals will always have work" are utter assholes thinking mostly that "they are those proper professionals".
In reality AI will be like F1 racing team not needing pit workers and have only drivers, how many drivers are there like 20 so it is 10 teams each having 2 drivers. Each team has 300-1000 people that do all the other things.
If you go to corporate level let's say 1 person working on essential complexity requires 10-20 people doing all kinds of non essential stuff that will be taken over by AI, or to be realistic instead of 10-20 people that person will need headcount of 5.
That is still 15 people out of job - are those people able to take over some essential complexity in a different company or different area of the same company, some would but it is also if they would like to do it. So those people will be pushed around or end up jobless, bitter whatever.
That is not great future coming in.
A terrifyingly large percentage of people employed to write software cannot write software. Not even a little. These are the people that can be easily replaced.
In my prior line of work I wrote JavaScript for a living. There were people doing amazing, just jaw dropping astounding, things. Those people were almost exclusively hobbyists. At work most people struggled to do little more than copy/paste in a struggle just to put text on screen. Sadly, that is not an exaggeration.
Some people did what they considered to be advanced engineering against these colossal frameworks, but the result is just the same: little more than copy/paste and struggle to put text on screen. Yes, they might be solving for advanced complexity, but it is almost always completely unnecessary and frequently related to code vanity.
Virtually none of those people could write original applications, measure anything, write documentation, or do just about anything else practical.
> So how do we reconcile this?
Alienate your workforce by setting high standards, like a bar exam to become a lawyer. Fire those people that fail to rise to the occasion. Moving forward employ people who cannot meet the high standards only as juniors or apprentices, so that the next generation of developers have the opportunity to learn the craft without rewarding failure.
This would work if the world was willing to pay for software. So at the very least you'd have to outlaw the ad-based business model, or do what lawyers do: things that are absolutely critical for software development (think "program needs to be approved or it won't execute", that deep) that normal people aren't allowed ... and unable ... to do.
The only purpose of software is automation. All cost factors should derive from that one source of truth. As a result the only valid concerns should be:
* Lowering liabilities
* Increasing capabilities
From a business perspective that means not paying money for unintended harms, and simultaneously either taking market share from the competition or inventing new markets. If your people aren't capable of writing software or your only options are free choices provided to you then you are the mercy of catastrophic opportunity costs that even the smallest players can sprint past.
I think there is a promise of that in AI and LLMs (but I remain skeptical, because I it needs a formal and not ad hoc definition). The idea you can build the systems using a fuzzy human language and the things will somehow work out.
They've started a business selling the exact opposite message to everyone who will buy it
This is very much up for debate and the weakest point of the argument I think. If developers are now 2-3x (remains to be seen..) as productive what will happen to the job market?
I suppose it depends on how much potential software is there that's not currently viable due to cost? How much would scope be increased on current products?
That doesn't sell stock. Firing high paying employees sells a lot of stock.
I don't think anyone thinks engineers are going away. But companies will hire less employees to do the same amount of work, and they won't pay engineers more.
I wonder if the independent studies that show Copilot increasing the rate of errors in software have anything to do with this less bold attitude. Most people selling AI are predicting the obsolescence of human authors.
Even if code is the right medium for specifying a program, transformers act as an automated interface between that medium and natural language. Modern high-end transformers have no problem producing code, while benefiting from a wealth of knowledge that far surpasses any individual.
> Most people selling AI are predicting the obsolescence of human authors.
It's entirely possible that we do become obsolete for a wide variety of programming domains. That's simply a reality, just as weavers saw massive layoffs in the wake of the automated loom, or scribes lost work after the printing press, or human calculators became pointless after high-precision calculators became commonplace.
This replacement might not happen tomorrow, or next year, or even in the next decade, but it's clear that we are able to build capable models. What remains to be done is R&D around things like hallucinations, accuracy, affordability, etc. as well as tooling and infrastructure built around this new paradigm. But the cat's out of the bag, and we are not returning to a paradigm that doesn't involve intelligent automation in our daily work; programming is literally about automating things and transformers are a massive forward step.
That doesn't really mean anything, though; You can still be as involved in your programming work as you'd like. Whether you can find paid, professional work depends on your domain, skill level and compensation preferences. But you can always program for fun or personal projects, and decide how much or how little automation you use. But I will recommend that you take these tools seriously, and that you aren't too dismissive, or you could find yourself left behind in a rapidly evolving landscape, similarly to the advent of personal computing and the internet.
It will also still happily turn your whole codebase into garbage rather than undo the first thing it tried to try something else. I've yet to see one that can back itself out of a logical corner.
That's not true at all.
...
It's only pretending to be happy.
A well-designed agent can absolutely roll back code if given proper context and access to tooling such as git. Even flushing context/message history becomes viable for agents if the functionality is exposed to them.
Will they fail to do it in practice once they poison their own context hallucinating libraries or functions that don’t exist? Absolutely.
That’s the tricky part of working with agents.
But the second you start iterating with them... the codebase goes to shit, because they never delete code. Never. They always bolt new shit on to solve any problem, even when there's an incredibly obvious path to achieve the same thing in a much more maintainable way with what already exists.
Show me a language model that can turn rube goldberg code into good readable code, and I'll suddenly become very interested in them. Until then, I remain a hater, because they only seem capable of the opposite :)
> Show me a language model that can turn rube goldberg code into good readable code, and I'll suddenly become very interested in them.
They can already do this. If you have any specific code examples in mind, I can experiment for you and return my conclusions if it means you'll earnestly try out a modern agentic workflow.
I doubt it. I've experimented with most of them extensively, and worked with people who use them. The atrocious results speak for themselves.
> They can already do this. If you have any specific code examples in mind
Sure. The bluetooth drivers in the Linux kernel contain an enormous amount of shoddy duplicated code that has amalgamated over the past decade with little oversight: https://code.wbinvd.org/cgit/linux/tree/drivers/bluetooth
An LLM which was capable of refactoring all the duplicated logic into the common core and restructuring all the drivers to be simpler would be very very useful for me. It ought to be able to remove a few thousand lines of code there.
It needs to do it iteratively, in a sting of small patches that I can review and prove to myself are correct. If it spits out a giant single patch, that's worse than nothing, because I do systems work that actually has to be 100% correct, and I can't trust it.
Show me what you can make it do :)
That's not true in my experience. Several times now i've given Claude Code a too-challenging task and after trying repeatedly it eventually gave up, removing all the previous work on that subject and choosing an easier solution instead.
.. unfortunately that was not at all what i wanted lol. I had told it "implement X feature with Y library", ie specifically the implementation i wanted to make progress towards, and then after a while it just decided that was difficult and to do it differently.
See, this is the kind of conception of a programmer I find completely befuddling. Programming isn't like those jobs at all. There's a reason people who are overly attached to code and see their job as "writing code" are pejoratively called "code monkeys." Did CAD kill the engineer? No. It didn't. The idea is ridiculous.
I'm sure you understand the analogy was about automation and reduction in workforce, and that each of these professions have both commonalities and differences. You should assume good faith and interpret comments on Hacker News in the best reasonable light.
> There's a reason people who are overly attached to code and see their job as "writing code" are pejoratively called "code monkeys."
Strange. My experience is that "code monkeys" don't give a crap about the quality of their code or its impact with regards to the product, which is why they remain programmers and don't move on to roles which incorporate management or product responsibilities. Actually, the people who are "overly attached to code" tend to be computer scientists who are deeply interested in computation and its expression.
> Did CAD kill the engineer? No. It didn't. The idea is ridiculous.
Of course not. It led to a reduction in draftsmen, as now draftsmen can work more quickly and engineers can take on work that used to be done by draftsmen. The US Bureau of Labor Statistics states[0]:
Expected employment decreases will be driven by the use of computer-aided design (CAD) and building information modeling (BIM) technologies. These technologies increase drafter productivity and allow engineers and architects to perform many tasks that used to be done by drafters.
I saw this a decade ago at the start of my professional career and from the start have been product and design focused, using code as a tool to get things done. That is not to say that I don't care deeply about computer science, I find coding and product development to each be incredibly creatively rewarding, and I find that a comprehensive understanding of each unlocks an entirely new way to see and act on the world.
[0] https://www.bls.gov/ooh/architecture-and-engineering/drafter...
He couldn't land a job that paid more than minimum wage after that.
This is a phenomenon that seems to be experienced more and more frequently as the industrial revolution continues... The craft of drafting goes back to 2000 B.C.[0] and while techniques and requirements gradually changed over thousands of years, the digital revolution suddenly changed a ton of things all at once in drafting and many other crafts. This created a literacy gap many never recovered from.
I wonder if we'll see a similar split here with engineers and developers regarding agentic and LLM literacy.
What academics are you rubbing shoulders with? Every single computer scientist I have ever met has projects where every increment in the major version goes like:
"I was really happy with my experimental kernel, but then I thought it might be nice to have hotpatching, so I abandoned the old codebase and started over from scratch."
The more novel and cutting edge the work you do is, the more harmful legacy code becomes.
In my case, I am referring to a deep appreciation of code itself, not any particular piece of code.
I have similar view of the future as you do. But I'm just curious what the quoted text here means in practice. Did you go into product management instead of software engineer for example?
At that point it's less "programmers will be out of work" as "most work may cease to exist".
- The cost of failure is low: Most domains (physical, compliance, etc) don't have this luxury where the cost of failure is high and so the validator has more value.
- The cost to retry/do multiple simulations is low: You can perform many experiments at once, and pick the one with the best results. If the AI hallucinates, or generates something that doesn't work the agent/tool could take that error and simulate/do multiple high probability tries until it passes. Things like unit tests, compiler errors, etc make this easier.
- There are many right answers to a problem. Good enough software is good enough for many domains (e.g. a CRUD web app). Not all software is like this but many domains in software are.
What makes something hard to disrupt won't be intellectual difficulty (e.g. software harder than compliance analyst as a made up example), it will be other bottlenecks like the physical world (energy, material costs, etc), regulation (job isn't entirely about utility/output). etc.
This is not entirely sensible, some code touches the physical / compliance world. Airports, airplanes, hospitals, cranes, water systems, military they all use code to different degrees. It's true that they can perhaps afford to run experiments over landing pages, but I don't think they can simply disrupt their workers and clients on a regular basis.
Also note unlike say for physical domains where it's expensive to "tear down" until you commit and deploy (i.e. while the code is being worked on) you can try/iterate/refine via your IDE, shell, whatever. Its just text files after all; in the end you are accountable for the final verification step before it is published. I never said we don't need a verification step; or a gate before it goes to production systems. I'm saying its easier to throw away "hallucinations" that don't work and you can work around gaps in the model with iterations/retries/multiple versions until the user is happy with it.
Conversely I couldn't have an AI build a house, I don't like it, it demolishes it and builds a slightly different one, etc etc until I say "I'm happy with this product, please proceed". The sheer amount of resource waste and time spent in doing so would be enormous. I can simulate, generate plans, etc maybe with AI but nothing beats seeing the "physical thing" for some products especially when there isn't the budget/resources to "retry/change".
TL;DR the greater the cost of iteration/failure; the less likely you can use iteration to cover up gaps in your statistical model (i.e. tail risks are more likely to bite/harder to mitigate).
They didn’t just see layoffs. There were the constant wars with Napoleon and the War of 1812 causing significant economic instability along with highly variable capital investments in textile production at the time. They we’re looking at huge wealth disparity and losing their jobs for most meant losing everything.
What many Luddite supporters were asking for in many parts of England were: better working conditions, a raise to minimum wage, abolishment of child labour, etc. Sabotage was a means to make such demands from a class that held almost all of the power.
Many of those protestors were shot. Those who survived and were laid off were forced into workhouses.
The capitalists won and got to write the history and the myths. They made it about the technology and not the conditions. They told us that the displaced workers found new, better jobs elsewhere.
Programmers, while part of the labour class, have so far enjoyed a much better bargaining position and have been compensated in kind. Many of us also complain about the quality of output from AI as the textile workers complained about the poor quality of the lace. But fortunately the workhouses were shut down. Although poor quality code tends to result in people losing their life’s savings, having their identities stolen, etc. Higher stakes than cheap lace.
History is not repeating but it sure does rhyme.
It is not a reality since it has not happen. In the real world it has not happened.
There is no reason to believe that the current rate of progress will continue. Intelligence is not like the weaving machines. A software engineer is not a human calculator.
Perhaps LLM can be modified to step outside the circle, but as of today, it would be akin to monkeys typing.
I’m getting maybe a 10-20% productivity boost using AI on mature codebases. Nice but not life changing.
10-20% productivity posts have been happening regularly over the course of my career. They are normally either squandered by inefficient processes or we start building more complex systems.
When Rails was released, for certain types of projects, you could move 3 or 4x faster almost overnight.
But I can't quite articulate why I believe LLMs never step outside the circle, because they are seeded with some random noise via temperature. I could just be wrong.
But once you add repo context, domain knowledge etc... programming languages are far too verbose.
The issue with natural language isn’t that it’s impossible to be precise, it’s that most people aren’t, or they are precise about what they want it to do for them, but not what the computer needs to do to make it happen. This leads to a lot of guessing by engineerings as they try to translate the business requirements into code. Now the LLM is doing that guessing, often with less context about the broader business objectives, or an understanding of the people writing those requirements.
No.
Some were concerned that the output of compilers couldn’t match the quality of what could be done by a competent programmer at the time. That was true for a time. Then compilers got better.
Nobody was concerned that compilers were going to be used by capitalists to lay them off and seize the means of producing programs by turning it into property.
Treating LLMs as a scaffolding tool yields better results at least for me personally. I just brain dump what I'm thinking of building and ask for it to give me models, and basic controllers using said models, then I just worry about the views and business logic.
Here's a fresh example that I stumbled upon just a few hours ago. I needed to refactor some code that first computes the size of a popup, and then separately, the top left corner.
For brevity, one part used an "if", while the other one had a "switch":
if (orientation == Dock.Left || orientation == Dock.Right)
size = /* horizontal placement */
else
size = /* vertical placement */
var point = orientation switch
{
Dock.Left => ...
Dock.Right => ...
Dock.Top => ...
Dock.Bottom => ...
};
It sort of makes sense: once the model has "completed" an if, and then encounters the need for a similar thing, it will pick an "if" again, because, well, it is completing the previous tokens.
Harmless here, but in many slightly less trivial examples, it would just steamroll over nuance and produce code that appears good, but fails in weird ways.
That said, splitting tasks into smaller parts devoid of such ambiguities works really well. Way easier to say "store size in m_StateStorage and apply on render" than manually editing 5 different points in the code. Especially with stuff like Cerebras, that can chew through complex code at several kilobytes per second, expanding simple thoughts faster than you could physically type them.
AI stands for Artificial Intelligence. There are no inherent limits around what AI can and can't do or comprehend. What you are specifically critiquing is the capability of today's popular models, specifically transformer models, and accompanying tooling. This is a rapidly evolving landscape, and your assertions might no longer be relevant in a month, much less a year or five years. In fact, your criticism might not even be relevant between current models. It's one thing to speak about idiosyncrasies between models, but any broad conclusions drawn outside of a comprehensive multi-model review with strict procedure and controls is to be taken with a massive grain of salt, and one should be careful to avoid authoritative language about capabilities.
It would be useful to be precise in what you are critiquing, so that the critique actually has merit and applicability. Even saying "LLM" is a misnomer, as modern transformer models are multi-modal and trained on much more than just textual language.
Lots of us are interested in technology that's actually available, and we can all read date stamps on comments.
> But it ain't here yet buddy . . . we can all read date stamps on comments.
That has no bearing on the general trajectory that we are currently on in computer science and informatics. Additionally, your language is patronizing and dismissive, trading substance for insult. This is generally frowned upon in this community.
You failed to actually address my comment, both by failing to recognize that it was mainly about using the correct terminology instead of criticizing an entire branch of research that extends far beyond transformers or LLMs, and by failing to establish why a rapidly evolving landscape does not mean that certain generalizations cannot yet be made, unless they are presented with several constraints and caveats, which includes not making temporally-invariant claims about capabilities.
I would ask that you reconsider your approach to discourse here, so that we can avoid this thread degenerating into an emotional argument.
They were obviously not trying to make a sweeping comment about the entire future of the field.
Are you using ChatGPT to write your loquacious replies?
OP said “AI can very efficiently apply common patterns to vast amounts of code, but it has no inherent "idea" of what it's doing.”
I'm not going to patronize you by explaining why this is not "very precise", or why its lack of temporal caveats is an issue, as I've already done so in an earlier comment. If you're still confused, you should read the sentence a few times until you understand. OP did not even mention which specific model they tested, and did not provide any specific prompt example.
> Are you using ChatGPT to write your loquacious replies?
If you can't handle a few short paragraphs as a reply, or find it unworthy of your time, you are free to stop arguing. The Hacker News guidelines actually encourage substantive responses.
I also assume that in the future, accusing a user of using ChatGPT will be against site guidelines, so you may as well start phasing that out of your repertoire now.
Here are some highlights from the Hacker News guidelines regarding comments:
- Don't be snarky
- Comments should get more thoughtful and substantive, not less, as a topic gets more divisive.
- Assume good faith
- Please don't post insinuations about astroturfing, shilling, brigading, foreign agents, and the like. It degrades discussion and is usually mistaken.
> AI can very efficiently apply common patterns to vast amounts of code, but it has no inherent "idea" of what it's doing.”
Are you saying that AI does have an inherent idea of what it's doing or is doing more than that? Today?
We're in an informal discussion forum. I don't think the bar we're looking for is some rigorous deductive proof. The above matches my experience as well. Its a handy applied interactive version of an Internet search.
If someone has a different experience that would be interesting. But this just seems like navel-gazing over semantics.
No. I stated that OP cannot make that kind of blanket, non-temporally constrained statements about artificial intelligence.
> We're in an informal discussion forum. I don't think the bar we're looking for is some rigorous deductive proof
We're in a technology-oriented discussion forum, the minimum bar to any claim should be that it is supported by evidence, otherwise it should be presented as what it is: opinion.
> this just seems like navel-gazing over semantics.
In my opinion, conversation is much easier when we can agree that words should mean something. Imprecise language matched with an authoritative tone can mislead an audience. This topic in particular is rife with imprecise and uninformed arguments, and so we should take more care to use our words correctly, not less.
Furthermore, my argument goes beyond semantics, as it also deals with the importance of constraints when making broad, unbacked claims.
It seems you don't recollect how much time passed without any big revolutions in AI. Deep learning was a big jump. But when the next jump comes? Might be tomorrow, but looking at history, might be in 2035.
According to what I see, the curve has already flattened and now only a new revolution could get us to the next big step.
My 2035 prediction actually seems pretty optimistic. It was more than 20 years that we haven't seen any big AI revolutions, so 2045 would be more realistic.
And it seems our current AI is also not going to get us there any faster.
Artificial, as in Artificial sand or artificial grass. Sure, it appears as sand or grass at first, but upon closer examination, it becomes very apparent that it's not real. Artificial is basically a similar word to magic - as in, it offers enough misdirection in order for people to think there might be intelligence, but upon closer examination, it's found lacking.
It's still impressive that it can do that, going all the way back to gaming AIs, but it's also a veil that is lifted easily.
1. There was no error on line 91, it did some inconsequential formatting on that line 2. More importantly, it just ignored the very specific line I told it to go to. It's like I was playing telephone with the LLM which felt so strange with text-based communication.
This was me trying to get better at using the LLM while coding and seeing if I could "one-shot" some very simple things. Of course me doing this _very_ tiny fix myself would have been faster. Just felt weird and reinforces this idea that the LLM isn't actually thinking at all.
However, I can't just say "on page 123..." I've found it's better to either provide the quote, or describe the context, and then ask how it relates to [another concept]. Or I'll say "at the end of chapter 6, Bob does X, then why Y?" (perhaps this is similar to asking a coding LLM to fix a specific function instead of a specific line?).
My favorite examples of this have been sitting with living human authors and discussing their books — usually to jaw-dropped creators, particularly to Unknowns.
Works for non-fiction, too (of course). But for all those books you didn't read in HS English classes, you can somewhat recreate all that class discussion your teachers always attempted to foster — at your own discretion/direction.
And now you've learned that LLMs can't count lines. Next time, try asking it to "fix the error in function XYZ" or copy/paste the line in question, and see if you get better results.
> reinforces this idea that the LLM isn't actually thinking at all.
Of course it's not thinking, how could it? It's just a (rather big) equation.
54 def dicts_to_table_string(
55 headings: List[str], dicts: List[Dict[str, str]]
56 ) -> List[str]:
57 max_lengths = [len(h) for h in headings]
58
59 # Compute maximum length for each column
60 for d in dicts:So are you.
You need to give LLMs context. Line number isn't good context.
a line number is plenty of context - it's directly translatable into a range of bytes/characters in the file
I can choose to use a screwdriver to hammer in a nail and complain about how useless screwdrivers are. Or I can realize when and how to use it.
We (including marketing & execs) have made a huge mistake in anthropomorphizing these things, because then we stop treating them like tools that have specific use cases to be used in certain ways, and more like smart humans that don't need that.
Maybe one day they'll be there, but today they are screwdrivers. That doesn't make them useless.
Am I living in a different timeline than these guys ?
In my timeline, the tech job market is terrible, and AI is the worst for junior developers, because they aren't learning what they should by doing.
Aka, 80% of the work being done by 20% of the people. The problem is you still have to hire the other 80% of the developers to also get those 20%
It also requires a fair bit of wisdom to know where the software is expected to grow, and how to architect for that eventuality.
I can't picture an LLM doing a fraction of that work.
At a certain point, huge prompts (which you can readily find available on Github, used by large LLM-based corps) are just....files of code? Why wouldn't I just write the code myself at that point?
Almost makes me think this "AI coding takeover" is strictly pushed by non-technical people.
But we still have lots of boilerplate code that's required, and it's really good at that. If I need a reasonably good-looking front-end UI, Claude will put that together quickly for me. Or if I need it to use a common algorithm against some data, it's good at applying that.
What I like about AI is that it lets me slide along the automation-specificity spectrum as I go through my work. Sometimes it feels like I've opened up a big stretch of open highway (some standard issue UI work with structures already well-defined) and I can "goose" it. Sometimes there's some tricky logic, and I just know the AI won't do well; it takes just as long to explain the logic as to write it in code. So I hit the brakes, slow down, navigate those tricky parts.
Previously, in the prior attempt to remove the need for engineers, no-code solutions instead trapped people. They pretended like everything is open highway. It's not, which is why they fail. But here we can apply our own judgment and skill in deciding when a lot of "common-pattern" code is required versus the times where specificity and business context is required.
That's also why these LLMs get over-hyped: people over-hype them for the same reason they over-hyped no-code; they don't understand the job to be done, and because of that, they actually don't understand why this is much better than the fanciful capabilities they pretend it has ("it's like an employee and automates everything!"). The tools are much more powerful when an engineer is in the driver's seat, exercising technical judgment on where and how much to use it for every given problem to be solved.
Copy and paste with find and replace has never taken me that long for boilerplate though. The time saved here is razor thin imo
What's happened since the 1970s is, programming has undergone prestige inflation to the point where programmers are looked to for decisions regarding the actual business procedures, and usually they just don't have the business knowledge or wherewithal to do that. The systems analyst has faded into memory. And as Milt Bryce said, "If this country built bridges the way it builds systems, we'd be a nation run by ferry-boats."
(Wow I sound triggered! sigh)
A man is a human.
“Manual” comes from Latin manus, meaning “hand”: https://en.wiktionary.org/wiki/manus. It literally means “by hand”.
I too can sling a bit of Latin. ;)
Here is one phrase, in which one word, malus, is like an off-by-one error from your manus word, so to speak :) :
nemo malus nisi probetur
https://www.google.com/search?q=nemo+malus+nisi+probetur
From the AI overview (need to at least try that out a few times after all the talk about Google enshittification like by Cory Doctorow in this year's PyCon US keynote:
>Nemo malus nisi probetur" is a Latin legal maxim that translates to "No one is evil unless proven." It signifies that a person is presumed innocent until proven guilty in a court of law. This principle is fundamental to legal systems that value fairness and due process, ensuring that accusations are substantiated before a person is considered culpable. Here's a breakdown of the phrase:
Nemo: No one
malus: Evil, bad, wicked
nisi: Unless
probetur: Is proven, is shown, is demonstrated
this is okay! it's a sign of your humanity :)
Wait does it? This is a new idea to me, in what way could "manual" have a negative connotation?
Are people really that against doing things manually nowadays?
Are they cool and useful? Yes.
Do they reason? No. (Before you complain, please first define reason).
Are they end all be all of all problem solving and the dawn of AGI? Also no.
Once we actually bring some rationality back into the radius of discourse maybe we'll actually begin to start figuring out how these things actually fit into an engineering workflow and stop throwing around ridiculous terms like vibe coding.
If you are an engineer, you are signing up to build rigorously verified and validated system, preferably with some amount of certainty about their behavior under boundary conditions. All the current hype-addled discussion around LLM seems to have had everything but correctness as it's focus.
[^1]: It shouldn't take a CEO but many people, even technologists, who should be more rational about whose opinions they deem worthy of consideration, m seem to overvalue the opinions of the csuite for some bizarre, inexplicable reason.
> Do they reason? No. (Before you complain, please first define reason).
Defining reasoning is the problem. No, they don't reason in the same way as humans. But they seem to be able to go through reasoning steps in some important way. It's like asking if submarines swim.
The opposite is true of LLMs. Much of the sales pitch of these companies is that these things are capable of some form of reasoning that is in 1:1 correspondence with human reason. Not true. That's what makes this whole segment of the industry snake oil. It's not complete bunk because they do have some utility, but these companies know what they are doing when they use the term reason in all their marketing and papers. They are, in fact, trying to sell you the submarine because it can "swim".
Lots of changes where describing them in English takes longer than just performing the change. I think the most effective workflow with AI agents will be a sort of active back-and-forth.
Usually the CEO or investor says 30% (or some other made up number) of all code is written by AI and the number will only increase, implying that developers will soon be obsolete.
It's implied that 30% of all code submitted and shipped to production is from AI agents with zero human interaction. But of course this is not the case, it's the same developers as before using tools to more rapidly write code.
And writing code is only one part of a developer's job in building software.
And those without understanding what the number means or how it was derived write misleading articles.
The problem with today’s LLM and GI solutions is that they try to solve all n steps when solving the first i steps would be infinitely more useful for human consumption. I’ve yet to see a fully modular solution (though MCPs partly solves it), where I can just say, “Hey, using my specific coding style based on my github, solve problem x, based on resources a, b, and c and only a, b, and c.” I would also like to see a more verbose/interactive coding AI, where it will ask incremental questions as it traverses a problem tree.
Why not look at Bob who takes like 2 weeks to write tickets on what they actually want in a feature? Or Alice who's really slow getting Figma designs done and validated? How nice would having a "someone's bothered a developer" metric be and having the business seek to get that to zero and talk very loudly about it as they have about developers?
Google itself said 30% of their code is AI generated, and yet they had a recent outage worldwide, coincidence??
You tell me.
"It's got tests"
"Who wrote the tests?"
"It did. So?"
They're "tactical tornados"[0] with a jetpack
[0] A term from the book A Philosophy of Software Design - people who constantly chuck out "working" code with no design. Tactical programming vs Strategic programming
AI just cannot reason about logical things reliably. And no one noticed because the AI had made several other sweeping changes, and the noise drowned it out.
Look, manual coding (and art, and media, and IT, and others) will always be needed. GenAI was never going to replace these jobs wholesale, or even permanently displace workers. The fact this is trending in an APAC-focused site suggests the real message is, “we don’t want our outsource farms thinking this [GenAI] will replace you.”
Prediction of tokens was never going to lead to AGI. All it’s going to accomplish is instilling a deep, traumatic hostility in the populace towards further automation right when we need it the most.
To expand -
1. Models "reason" and can increasingly generate code given natural language. Its not just fancy autocomplete, its like having an intern - mid level engineer at your beck and call to implement some feature. Natural language is generally sufficient enough when I interact with other engineers, why is it not sufficient for an AI, which (in the limit), approaches an actual human engineer?
2. Business wise, companies will not settle for augmentation. Software companies pay tons of money in headcount, its probably most mid-sized companies top or second line item. The endgame for leadership at these companies is to do more with less. This necessitates automation (in addition to augmenting the remaining roles).
People need to stop thinking of LLMs as "autocomplete on steroids" and actually start thinking of them as a "24/7 junior SWE who doesn't need to eat or sleep and can do small tasks at 90% accuracy with some reasonable spec." Yeah you'll need to edit their code once in a while but they also get better and cost less than an actual person.
As a standard pleb though I can understand why this world; where the people with connections, social standing and capital have an advantage isn't appealing to many on this forum. If anyone can do something - other advantages that aren't as easy to acquire matter more relatively.
And then the last 25 years happened.
Now people are predicting the same thing will happen, but with AI.
The problem then, as is now, is not that coding is hard, it's that people don't know what the hell they actually want.
Software companies make a single copy and sell it a billion times. The revenue per employee is insane. The largest companies are trying to make the best product in the world and seek out slight advantages.
The cost saving mindset you are describing is found in companies where software isn’t a core part of the business.
The entire application is powered through several AI agents, I had a look at their code and had to throw up, each agent is a single Python file of over 4000 lines, you can just look at the first 100 lines and tell its all LLM generated code, the hilarious part is if I paste the code into ChatGPT to help me break it down, it hits the context window in like 1 response!
I think this is one of the main problems with AI code, 5 years ago every time I took on a project, I knew the code I was reading and diving into was written by a human, well thought and structured. These days almost all the code I see is glue code, AI has done severe damage by enabling engineers who do not understand basic structures and fundamentals write 'code that just works'.
At the same time, I don't blame just the AI, cause several times I have written code myself which is gluecode, but then asked AI to refactor it in a way I want and it is usually really good at it.
This is kind of vague. What kinds of contributions he's talking about? Adding features, refactoring, removing dead code, optimizing, adding new tests?
The article mentions boilerplate. Is that all current coding AIs can do?
> For instance, spending too much time explaining simple changes in natural language instead of editing the code directly.
Why not write the code directly then? Even less friction.
Again, _it all depends on the kinds of contributions AI can make_.
The fact that they're being vague about it tells me something. If you had a bot that can fix tests (or even get you 90% of the way), you'd be boasting that everywhere. It would be an extraordinary evidence and you'd be very proud of it.
If someone made a PR to my repo adding a bunch of automated boilerplate, I'd be pissed, not encouraged to make it work.
I think an over-reliance, or perhaps any reliance, on AI tools will turn good programmers into slop factories, as they consistently skip over a vital part of creating high-quality software.
You could argue that the prompt == code, but then you are adding an intermediary step between you and the code, and something will always be lost in translation.
I'd say just write the code.
With AI, instead of starting with zero and building up, you can start with a result and iterate on it straight away. This process really shines when you have a good idea of what you want to do, and how you want it implemented. In these cases, it is really easy to review the code, because you knew what you wanted it to look like. And so, it lets me implement some basic features in 15 minutes instead of an hour. This is awesome.
For more complex ideas, AI can also be a great idea sparring partner. Claude Code can take a paragraph or two from me, and then generate a 200-800 line planning document fleshing out all the details. That document: 1) helps me to quickly spot roadblocks using my own knowledge, and 2) helps me iterate quickly in the design space. This lets me spend more time thinking about the design of the system. And Claude 4 Opus is near-perfect at taking one of these big planning specifications and implementing it, because the feature is so well specified.
So, the reality is that AI opens up new possible workflows. They aren't always appropriate. Sometimes the process of writing the code yourself and iterating on it is important to helping you build your mental model of a piece of functionality. But a lot of the time, there's no mystery in what I want to write. And in these cases, AI is brilliant at speeding up design and implementation.
I know the tools and environments I am working in. I verify the implementations I make by testing them. I review everything I am generating.
The idea that AI is going to trick me is absurd. I'm a professional, not some vibe coding script kiddie. I can recognise when the AI makes mistakes.
Have the humility to see that not everyone using AI is someone who doesn't know what they are doing and just clicks accept on every idea from the AI. That's not how this works.
Software is incredibly easy to verify compared to other domains. First, my own expertise can pick up most mistakes during review. Second, all of the automated linting, unit testing, integration testing, and manual testing is near guaranteed to pick up a problem with the functionality being wrong.
So, how exactly do you think AI is going to trick me when I'm asking it to write a new migration to add a new table, link that into a model, and expose that in an API? I have done each of these things 100 times. It is so obvious to me when it makes a mistake, because this process is so routine. So how exactly is AI going to trick me? It's an absurd notion.
AI does have risks with people being lulled into a false sense of security. But that is a concern in areas like getting it to explain how a codebase works for you, or getting it to try to teach you about technologies. Then you can end up with a false idea about how something works. But in software development itself? When I already have worked with all of these tools for years? It just isn't a big issue. And the benefits far outweigh it occasionally telling me that an API exists that actually doesn't exist, which I will realise almost immediately when the code fails to run.
People who dismiss AI because it makes mistakes are tiresome. The lack of reliability of LLMs is just another constraint to engineer around. It's not magic.
This strikes me as an absurd thing to believe when there's almost no such thing as bug-free software
For example, a research document could sound good, but be complete nonsense. There's no realistic way to verify that an English document is correct other than to verify it manually. Whereas, software has huge amounts of investment into testing whether a piece of software does what it should for a given environment and test cases.
Now, this is a bit different to formally verifying that the software is correct for all environments and inputs. But we definitely have a lot more verification tools at our disposal than most other domains.
Software is incredibly easy to verify compared to other domains.
It's right there in the quote.
I agree but I have a hunch we're all gonna be pushed by higher ups to use AI always and for everything. Headcounts will drop, the amount of work will rise and deadlines will become ever so tight. What the resulting codebases would look like years from now will be interesting.
Why wouldn't your boss ask ChatGPT directly?
The truth is that those devs who has been replaced should not have been hired in the first place as the companies were already overstuffed.
> Source: The Times of India
what in the recycled content is this trash?
Did I miss Nat Friedman stepping down? Does the new guy think having ICE as a customer is ok, too?
I stopped reading after this.
That these "geniuses" think they can replace humans, not only for knowledge work, but also for labour is laughable for any one who has worked with LLMs.
In practice, pure LLM suggestions often feel detached from your actual codebase—missing intent, architectural constraints, or team conventions. What helped us was adopting a repo‑aware evaluation approach with tooling that: - Scans entire repos, generates architecture diagrams, dependency maps, and feature breakdowns. - Surfaces AI suggestions grounded in context—so prompts don’t float in isolation. - Supports human-in-the-loop validation, making it easy to vet AI‑generated PRs before merging. - Tracks drift, technical debt, and cost per eval, so AI usage isn’t a black box.
The result isn’t autopilot coding—it’s contextual assistance that amplifies developer decisions. That aligns exactly with Dohmke: use AI to accelerate, but keep the engineer firmly in the driver’s seat.
Curious if others have tried similar repo‑aware AI workflows that don’t sacrifice control for speed?
So out of nowhere both my brother and my wife, without concerting themselves (they don't live on the same continent), are now taking coding lessons. Not AI related: just learning to code in Python.
And suddenly I'm winning lots of cookie points: my wife realizes that coding is not something that's that simple and that it's really the coders who have it easy with AI.
As for the AI boom: it's another tool. I use it daily (and pay for it). But it's still just a tool.
Wake me up when 95% of Linux's kernel code is written by an AI.
I wanted some jq script and it made an incomprehensible thing that usually worked. And every fix it made broke something else. It just kept digging a deeper hole.
After a while of that, I bit the bullet and learned jq script. I wrote a solution that was more capable, easier to read, and, importantly, always worked.
The thing is, jq is completely documented. Everything I needed was online. But there just aren't many examples to for LLMs, so they choke.
Start asking it questions about complexity classes and you can get it to contradict itself in no time.
Most of the code in the world right now is very formulaic, and it's great at that. Sorry, WordPress devs.
It's a powerful tool, but it's not that powerful.
I had great success with niche programming languages by feeding it the documentation and a couple of projects.
AI is becoming a helpful assistant, but it is still far from replacing real engineering skill.