John Carmack is a personal hero of mine, so it pains me to say this:
Carmack hasn't produced anything noteworthy since AI was invented, therefore, how productive can it really be?
It could be he is doing incredible work in private... but it could also be that he's lost in the weeds, because AI is so counterproductive while feeling the opposite?
I remain a skeptic.
> because AI is so counterproductive while feeling the opposite
Wow that resonated by a scary amount.
Again I don't get what people on HN are doing? Our client wants something: I mumble in my phone what they want, with some spec docs we had / made by mumbling in our phones: a working system comes out, we test it with our client, we fix. We sign a SLA, get paid 100k, a few weeks have passed. I mean, we should not measure everything in money, but for lack of a better measure for productivity, I cannot see how anyone finds it counterproductive. This was strictly impossible for our small team before recent AI and hiring more people didn't work for the pricing. Our profits jumped, revenue jumped, client count jumped. What are people here doing exactly that they are not riding the gravy train and even reporting all these negative AI experiences?
We do spend all our time either code reviewing or talking with clients but the latter was already the case and the former was just better spaced out over time as this would before take many months.
If it works for you, great! Just keep going. I only have the nagging question that if itâs so easy, why would the clients not do it by themselves? Certainly they understand their problems better than you and they can adapt to rising issues faster if their in-house team does it themselves. And certainly what kind of AI you can access, they can too and perhaps even more. So what will remain your value propositions?
Iâm a critical user, not a categorical denier. But there are certain categories where I see the current AI face a wall: fitting new ideas, or existing code into an existing architecture particularly. Or work on the backend when constraints are not strictly enforced (for various historical reasons). Schematic understanding is still an issue.
Sometimes additional chunkings and detailed planning/instructions suffice. But other time, humans are still the best vehicles to code.
Don't underestimate the power of motivated reasoning. Certain people don't like AI coding for various ideological reasons, and so they will, not coincidentally, consistently fail to find it productive or helpful.
Ya, AI is very good at generating number, be that code for software, images for ads, or banal prose for company blogs. AI not so good at growing corn, cooking eggs, biulding houses, running fiber, treating disease, changing brake pads, loading a truck... or any of the other millions of physical-world jobs on which the economy is biult.
If you company is all about creating things that go on the internet, sure, AI is your thing. But for most companies the internet is a communications tool rather than a product. Those companies are not seeing the claimed productivity gains.
Can you elaborate on this with real-world examples you've experienced?
Not GP, but I can.
I'm currently working on porting a mid-sized project to a new architecture, new programming language and of course adding new features.
Getting a new feature implemented is quite easy. You spend a few hours brainstorming specs with the agent, then ask it to implement it. This gives you extremely frequent code drops that add a new brick, add a new feature, etc. All of this with 100% code coverage (we also have mutation testing, strongly-typed code, standard and custom linters, etc.)
Then you look at the code. Code that has passed review, generally. You realize that the database schema has been broken silently, and that the agent has rewritten the tests or the golden fixtures to match. You realize that it has made assumptions that contradict the specifications and the product is going to break once it's in the hand of users. You realize that the 100% code coverage is essentially a convenient lie, because the code and tests have been written to make passing easy. You realize that none of the security golden rules have been followed, and that has managed to happen because the agent has somehow deactivated linting.
Why did it pass reviews? Well, because of deadlines. And because there is simply so much code (and so much unparsable/misleading documentation) that it's simply impossible to review all of this. And because things move so fast that nobody understands the CI pipeline anymore, and the explanations of the agent are convincing enough that surely, it knows better than you?
On the upside, bugfixing becomes so fast! Just add a new test, wait a few dozen minutes, and a new Merge Request appears. With equally convincing/misleading explanations, and something else broken.
After ~4 months, we had a bare bones deliverable, which we're now steadily expanding. If we had had to write the product manually, I suspect that it would have taken us at least one year, possibly two. So, that's the productivity increase. The productivity decrease is that what we have is not a product but a glorified demo, something that will work very nicely on the happy path, but on any other path, all bets are off.
AI amplifies existing process. For people without sufficient clarity I imagine it amplifies that lack of clarity, which is where it is factually unproductive while it still âseemsâ to be productive (producing slop).
At the end of the day, LLMs are still tools.
I mean his post boils down to "Get on the bandwagon because you might otherwise miss out. All the cool kids do AI now."
There are valid concerns there (and you should probably be playing around with LLMs), but he voiced none of them. He just led with a metaphor about obsolescence and then continued spreading FOMO with an authoritative voice.
Perhaps he is actually lamenting being the out of touch kung fu master, but his pride won't allow him to articulate the ways in which he identifies with that?
He also runs an AI company now called Keen something. So heâs yet another biased hypester at this point.
We are going from the era of manual, line-by-line mental model transcription to one where software engineers can focus on data structures, software architecture and algorithms.
I love being able to quickly bring out the program that is already running in my head without having to worry about the grind of typing it into a format that the compiler understands. Dealing with API names. Syntax. Language quirks. Library gotchas. A sizeable portion of my successful career as a software engineer was spent on the tiresome process of interacting with a text editor/IDE to get a program to do what I wanted.
I was there when people were still coding assembly. A slow torture where the simplest things took forever to get right.
Once I've mentally solved the problem, the fun is mostly over for me. Pure vibe coding is dull and unsustainable with current technology for all but the simplest systems; AI-assisted coding, on the other hand, rekindled my passion for computers.
I like your constructive outlook and I want to believe that we can now focus on the bigger picture, but I'm not really seeing it around me. Most everyone I know that's "AI-pilled" has spent the newfound capacity on throughput instead of altitude.
Is anyone actually seeing a shift towards improved structure rather than more code, faster? We seem to be living in the Gatling-gun version of the picture John Carmack drew when modernity also ushered into precision marksmanship...
Are those people working on products or platforms? Platforms still have to be rock solid and deliver performance guarantees to the products built on top of them.
The people who are using AI to improve what they were already doing anyway, aren't going around expounding "I made this with AI!"
Like one of my personal projects is a sort of "middleware" for Godot, and it needs to be lean, precise and match certain rules, because it's meant to be used by many games, so I can't blindly trust AI to generate code for it, it'd be too sloppy,
BUT Codex reviews have been a great help in finding bugs that would have taken me ages to even notice on my own. Some of those AI findings helped me overhaul entire subsystems, still manually coded.
>> Is anyone actually seeing a shift towards improved structure rather than more code, faster?
Yes. At work we recently finished a complete rewrite of the platform. The old codebase got abandoned and two new codebases got stood up. Previous stack was Phoenix LiveView and the new one is Phoenix API + Vue /w TypeScript. Zero code shared between the two. We took the opportunity to re-architect a lot of the core functionality and get rid of the tech debt that had been hounding us and killing our velocity for the past six years.
We finished the rewrite in two months. A little over 700k LoC total. 95% of it was planned, orchestrated and written by AI. We could have gotten it done faster, but we were well aware of the potential for slop and thus paid an absurd amount of attention to (and tokens for) code quality. For example, there is a 100% test coverage requirement in both server and client, combined with AI-driven review rules that say all tests must be non-vacuous, plus a ton of invariants enforced via deterministic checks. Everything from standard linting and formatting rules to AI-necessitated stuff like "comments cannot be more than five lines each" is in there. At the end of each week, we get together for ~30 minutes to review each bug that was fixed that week (there haven't been that many) and try to figure out if more deterministic checks can be added (or new ones extended) to prevent that class of bug from re-appearing. We actually have an Architecture epic with a dedicated Fable agent orchestrating all the initiatives and tickets in it and keeping track of improvements (and the occasional regression). So things like accessibility, usage of shared helpers, enforcement of common patterns, etc. are all kept track of.
The difference between the old codebase and the two new ones has been night and day. The new codebases, combined, are ~35% larger than what we had before, and yet there are way fewer bugs (we actually got suspicious at first and had to check to make sure our logging instrumentation was configured correctly). Performance is also stellar, features have been a lot easier to add and extend, and everything is a lot easier to find. When someone asks a question or has an issue we have a pretty good idea of what part of the codebase to look in and we're usually right.
It wasn't all unicorns and rainbows. Not everyone on the team was proficient with AI-driven development, so they had to be brought up to speed quickly and taught the tools and also what works and doesn't. Code reviews were also difficult and time-consuming. We had to deal with our anxieties about working in two new codebases none of us had authored much code in ourselves. What made all of it worse was that we were racing towards a deadline imposed by external factors so we all ended up working a lot of hours. It was essentially between getting it done this summer or waiting until next summer and we bit the bullet and did it. It absolutely would not have been possible without AI.
That is interesting, but... is it actually improving structure?
We're mid-way through a similar process at work. Rewriting a legacy app in a new language, with new architecture and new features.
And it's a mess.
We're at 10x loc (admittedly, the new programming language is more verbose than the old one), comments make no sense. Yes, we have ~100% coverage, but most of the tests are meaningless. The agent keeps removing our tests to replace them with tests that are easier to pass, breaking code invariants, removing all the engineered data structures and replacing them with stringly-typed code, etc.
And of course, given the number of LoC (and the fact that the agent rewrites so much code all the time), it's physically impossible that all of them were reviewed by a human being.
AI made it possible, insofar as upper management would never have greenlit the project without AI, but I can't escape the feeling that we're building on quicksands.
LLMs are a game-changer. You work more for less money.
> We finished the rewrite in two months. > racing towards a deadline imposed by external factors so we all ended up working a lot of hours.
2 months of 80 hour weeks is 4 months of regular weeks. Can you clarify how many hours your team was putting in? And how large was your team?
Could you share more about how you guys set up the rewrite? I am interested in the shape of the software as well as how you achieved (or aimed to achieve) high quality.
> We are going from the era of manual, line-by-line mental model transcription to one where software engineers can focus on data structures, software architecture and algorithms.
Focusing on data structures, architecture and algorithms is what competency in programming has looked like since forever. Building systems out of smaller pieces gets you there.
If your complaint above is that you were struggling with syntax and reading documentation, one might ask if you failed to progress past beginner levels, and now AI is just your cheat-code?
Do you remember how bad documentation was? I still have nightmares about Twisted.
And I have wonderful lucid dreams about MSDN.
Also, are you implying that docs became better in the AI era?
> Focusing on data structures, architecture and algorithms is what competency in programming has looked like since forever
yes, being able to bang out leetcode hard from head on an interview on paper matters so much... oh wait. it does not.
in the real world, outside of interview questions, it hardly matters. when it comes there, I'll optimizite it, but getting the first system up and running in a way I want is way more fun & challenging. need a lock free ringbuffer? I'll look up what's the latest way to build it. or just ask my AI.
> yes, being able to bang out leetcode hard from head on an interview on paper matters so much... oh wait. it does not.
That's about reciting standard data structures like stack and queues. I think parent is talking more about the design of primitives for the domain of the software. That requires creativity and insight.
I think you are not interpreting GP in the most charitable way. He simply said that not having to manually write all the code lets him spend his energy on bigger things. That is different from "struggling with syntax".
It is the same. I mean many mainstream languages made thinking in datastructures hard. Not a coincidence why functional languages, Haskell, F#, OCAML, Scala, Clojure, LISP, etc. had their enthusiast, as they felt just like what you claim.
The datastructures already did the heavy lifting. The syntax was not something to struggle with, but it was the natural way to stick the bits together.
JavaScript for one never gave me this feeling, and I always felt that either the language, or the libraries, but something was always a struggle to overcome. (Python too... seriously, working with collections is a pain in the "pythonic" way for someone who has experienced LINQ... and for most line of business apps it is all about working with collections.)
> We are going from the era of manual, line-by-line mental model transcription to one where software engineers can focus on data structures, software architecture and algorithms.
That would be lovely.
It's sad that we're being forced to vibe code, though, because my day-to-day experience of that is that the agent does not respect the data structures I feed it, nor the architecture, nor the algorithms.
> Pure vibe coding is dull and unsustainable with current technology for all but the simplest systems; AI-assisted coding, on the other hand, rekindled my passion for computers.
Agreed.
How can you have proper real understanding of data structures and algorithms without at same time having line-by-line mental model?
Or do you blindly trust what machine tells you at whatever time you are communicating with it?
Architecture I might give not needing line-by-line model. But I really doubt the same with data structures and algorithms. Those are in the end build from lines.
Djikstra seemed to manage?
https://en.wikipedia.org/wiki/Edsger_W._Dijkstra#Use_of_tech...
Seems to indicate to me that he had full mental model of everything. Whole thing in his head at once. Clearly having it in mental model sentence by sentence.
AI would here be the word processor.
Everyone who writes enthusiastically about AI already has the benefit of having worked without AI. They have been schooled in the basics. Enough of us know about data structures, concurrency, networks, language design etc. from the ground up that the knowledge is passed on. I worry about the world that we will be living in when a whole generation has skipped learning the basics the hard way. Given the attendance rates at various educational institutions, I fear that day is already here.
Herodotus wrote about finding people living in the ruins of a great city (Babylon) who had no idea who built it or how they built it.
The city of London was abandoned for about 400 years and fell into ruins after the people who built it left.
We know that use of AI has a negative result for students: https://pivot-to-ai.com/2026/09/08/students-who-dont-use-ai-...
Right, I weirdly feel like we are entering an era where industry doesnât invest that much in training the next generation - it feels like a rich getting richer scenario in all aspects of society
I think mathematics is feeling that concern with training acutely. The average math department pays its way by teaching in all forms and all levels: they donât bring in the magnitude of grant money that concretely impacts a universityâs budget. But they are already dealing with the consequences of that - thatâs why universities that are cutting due to âlow student demandâ are going after math programs.
> I worry about the world that we will be living in when a whole generation has skipped learning the basics the hard way.
Have you been schooled in farming? Raising livestock? Milking cattle?
Does your ability to cook good food depend upon your ability to till soil and sow seeds?
I don't mean that in ass way but re: what other comments said:
> it feels like a rich getting richer scenario in all aspects of society
That's a problem with society, not technology.
Holding back technology won't fix society.
> Have you been schooled in farming? Raising livestock? Milking cattle? Does your ability to cook good food ...
Pushing that analogy, AI is the equivalent of automating everything from tilling, growing, all the way to cooking. It is as if the human is involved at the beginning in specifying what they want, and at the end, in plating up the food and consuming the product. The next generation will have no clue about the entire farm-to-table chain.
It's not there yet, but rapidly making it a reality.
Also, there is no one "tech". Different pieces of technology have different levels of effect on the world, and different timelines in which the world can come to terms with it. AI is the thermonuclear weapon introduced to a musket world ... it came upon us suddenly, and instantly flattened the talent/merit based economy. Now everyone has access to the same exoskeleton; the difference between muscles is not important.
The second huge difference between AI (and ordinary tech) is that a literal handful of people are in control of its economics. That kind of power breeds fascism.
> That's a problem with society, not technology.
Semantics. The tech directly enables the incredible power imbalance, and helps seize the means of consensus and debate and reporting. There is no incentive/mechanism left to fix society. An advanced society like the US is weaponized against vaccines, and social media and AI are to blame.
> That kind of power breeds fascism.
uhmmm and what have y'all been doing to prevent fascism and wealth inequality up until the point -before- AI became a thing?
What did you do about the mandatory government IDs required to access the internet?
What did you do to reduce police brutality and unaccountability in the USA?
AI is the ONE thing that COULD give the common peasantry a chance.
..maybe that's why so many fires are being stoked against it.. *thinking emoji*
I haven't been schooled in farming, but my understanding of food has greatly increased since we started growing our own vegetables.
Yes, but that still has little bearing on actual cooking skills, no?
Ironically, this post comes off as out of touch. The purpose of the various martial arts isn't just to win in a life-or-death brawl or murder people as efficiently as possible. Similarly, the point of programming isn't just to generate as much code as possible, or only to be more "productive".
In Musashi's era, meaning the late 1500s, kendo (sword fighting) was absolutely about being as "productive" (read: lethal) as possible.
As it happens, this was also the era when firearms had just been introduced to Japan. In 1575 Oda Nobunaga demolished the Takeda cavalry at the Battle of Nagashino, marking the first time firearms had been used at scale in Japanese combat, and in 1600 Musashi participated in the decisive Battle of Sekigahara where both sides used them extensively.
The end of the Sengoku Jidai was triggered by a warlord (Nobunaga) who equipped his armies with massed ashigaru levies armed with long spears and tanegashima arquebuses. It was absolutely a technological brawl where the valiant highly trained cavalry of warlord's like Takeda Shingen got mowed down by the bullets of musketeers stationed behind well prepared and covered firing positions.
If it was still going on today, the warlords would be adopting drone warfare and vibecoded 3d printed cruise missiles.
Japanese martial arts generally come in 2 forms. -do (the way) and -jitsu (the art). -do forms are about self improvement, -jitsu forms are about effectiveness. You can see this with judo and jujitsu. Carmac is clearly aware of this difference as he says:
"We arenât there yet, but carefully writing code completely by hand is moving from a -jitsu to a -do. "
IIRC Carmac has done judo (I'm not sure to what level).
Code in most organizations is a means to an end to produce an actual product.
The job of a SWE is to not produce the most sublime readable code with cute language bells and whistles that you can show off to your other programmer friends. Yes its fun to do and interesting, but the main value in writing code is to express your intent so you and other people that are working with you can actually build something of value.
Software has value to the people on your team reading it. The product that you create with your software has a far wider impact than just that. As such, there is for _sure_ optimization pressure on "professional software engineering" to be more productive and actually make the product better to use, faster, with more features users like. The user typically does not care that you used a new C++26 feature, as much as I enjoyed writing it for them.
If I can produce features for users faster and I can iterate on them faster, this is a boon to me. I can program by hand for fun all I want in my spare time, but if I want to produce value for someone else, it is economically infeasible for me to be a luddite, and I will simply be outcompeted. Previously you were outcompeted by smarter teams who out executed you (and who also worked more), and now you can be out executed by basically anyone using an LLM who actually understands that the end goal is making a product that is pleasant to use and actually has utility, not code that is pleasant to read.
You can be an "performative/artisanal programmer" just as you can do "performative/artisanal martial arts." Just know that there will not be a large market for it in the real world.
You're reducing programming to its utility in producing exchange value in the captitalist political economy. That's what "value" means in this context. That's exactly what I'm pointing out. Programming is more than that, if you can think beyond your current economic constraints. Your life's activity ought to be more than just a tool for producing capitalist exchange value.
Does cooking food serve any purpose beyond mass producing food for restaurants to sell?
Absolutely correct take. People are so caught up in doing the bidding, they forget what it is all about.
People are used to paying for food. They delight in paying more for highly rated Michelin starred food, even. Software is the opposite. People really really hate paying for software. It should all be free! The fact that making an additional copy of a piece of software is basically free vs creating an additional plate for dinner is very much not, has a lot to do with that. For sure. But it also means that I don't see a future where the "capitalist political economy" truely "values" aka pays seriously good money for a bespoke, handcrafted, no AI slop here, version of Photoshop to be run only once, and then you poop it out later.
Products in most organizations are an end to making profit.
The job value of an SWE is to maximize that profit. It doesn't matter if the product is better to use, faster, with more features users like - that's an early 20th century model of value production.
What matters is how much money the company can extract from its customers, and how little it can pay its employees. Use dark patterns, increase lock-in, and switch to a rental system with recurrent payments. Minimize employee benefits, require broad non-compete agreements, have long vesting periods and lay people off before its reached, or simply fire them and order the others to pick up the slack using AI.
If you want to write software meant to please the user, do that for fun in your spare time -- though remember that your employer still owns your IP, so it's not like you can create a market competitor.
Alas, the above was meant in sarcasm but is all too true.
The Luddites were not opposed to machines. They were opposed to bad labor practices, with machine-breaking as way of applying pressure on employers.
> But donât be the out of touch Kung Fu master, heir to lifetimes of tradition, that gets mauled by an amateur MMA fighter.
Seems like a fundamentally poor analogy. Software development is collaborative, not competitive.
'Make sure you don't fall behind!!!' is my least favourite type of post about ai. There's resllt nothing to learn about ai. You're just typing and telling it what to do.
This is like saying there's nothing to learn about programming, you're just telling a computer what to do. :)
It's partly true, but where this logic gets stuck is software engineering, for both the cases.
Just telling the AI what to do won't get you to good software, especially when you want to use dozens of agents working in parallel, when you have something correctness sensitive, when you want the AI to try and solve a research problem you have a hunch about but not a concrete solution.
but the solution, ironically, is not learning more about ai, but learning more about good software engineering, so you can tell when the ai is not doing it
No, software engineering is fundamentally changed because of AI. No amount of digging our heads in the sand is going to undo that.
For example, the traditional best practice cycle of "small incremental change, code review, test, commit" is pretty much obsolete now. The way ten collaborating agents can make short work of a complex project is not something that fits in with our existing software engineering wisdom at all.
We are still trying to figure out the new science of software engineering. And the best way to get better now is to just figure out what works and what does not for your use case.
the point of AI hype is to increase shareholder value.
The system that solved Navier-Stokes certainly was not about OpenAI engineers just typing and telling it what to do.
The recent advancement in math with the Riemann Hypothesis by Jared Sumner was basically him saying "you can do it! keep going!", however.
> In 2022, he left Oculus to work on his AGI startup, Keen Technologies
https://en.wikipedia.org/wiki/John_Carmack
oh
This resonated with me as someone who: has read the book of 5 rings (translated), has done quite a lot of martial arts and has been coding for ~50 years.
I work for myself developing apps and selling online. So I have no employer pushing to use AI. But I feel a bit like a dinosaur watching the incoming comet.
Currently, I just use MSCopilot as enhanced StackOverflow and I find it useful for that. But I have been nowhere near Cursor, Claude, harnesses, agents or 'vibe coding'.
It seems my options are:
1. Keep use AIs as an enhanced StackOverflow (e.g. to answer questions about APIs)
2. Embrace the new AI coding tools
Really not convinced about option 2. I don't trust AIs with code bases that I have built over 20 years. Also, I'm not far off retiring and I'm not sure I can be bothered to completely change how I work (again). Would be interested to hear what conclusions any fellow coding dinosaurs have come to.
Get a daily email with the the top stories from Hacker News. No spam, unsubscribe at any time.