Join the discussion

Write your take first — we'll ask for email only when you're ready to publish.

  • Hacker News
  • Article was flagged from the front page after criticism of Meta. You know, if free speech isn't allowed maybe we should contact Zuckerberg directly if that is what you want.
  • At the risk of sharing an unpopular take, this reads a lot like someone who decided how they feel about LLM-driven engineering ~5 months ago and doesn’t seem to reflect the current reality.

    (Or they’re working in an organization with lower budgets and not cranking the frontier models of today)

    I fully agree about the cost/sustainability parts, but to suggest you can’t build a high quality coding/verifying/iterating loop for _most_ problems is disingenuous.

  • 5 months ago people said the exact same things, you know. That this stuff was how it was 5 months before that, and doesn't reflect the current reality.
  • Moreso it seems like nonsense that's masked by an excellent facade of eloquence. Ironic given it's a a post ranting against LLMs.

    I stopped reading when he decided to go off on some tangent about how LLMs can't do native programming or games because they weren't trained on it. Ignoring the technical issues there, an even more overt one is that, amongst a zillion other projects, even the entire source code for Unreal Engine is available and within their training corpus. Even older models were quite competent at working with Unreal and outputting idiomatic code, which is saying something if anybody's ever worked with Unreal.

    I increasingly think people are writing dumb articles on purpose because it drives 'engagement' more than a straight forward and accurate post would, at least on average.

  • not much changed in the past 5 months if you have been doing agentic development. Claude Code actually is getting worse.
  • > this reads a lot like someone who decided how they feel about LLM-driven engineering ~5 months ago and doesn’t seem to reflect the current reality.

    I've been reading this for 2 years straight. "oh you have a criticism of AI? Well they fixed that in Aeternos v Y-point-Z, which after doing all of my work also gave my wife an orgasm for the first time this year, obviously OP is using the old model".

  • His experience is completely plausible. He’s in a niche that requires highly performant code and most complex, highly performant games do nit have source available for models to train on. It’s a very common observation that the farther you stray from mainstream, the less effective the LLM models become.
  • This is likely a completely honest and plausible experience of the author, while at the same time still feeling like someone trying to use a pottery wheel and then concluding that pottery wheels are not suitable for producing very good art due to the clay often not centering. It says more about the author than about the topic.
  • I read through a bit of it, and it seems like the author assumes training was done only on open source data, but I doubt that's actually the case. There are plenty of paid, proprietary source codes being sold out there, hacked code, that is.

    Aside from that, I don't agree with the author's view on agentic workflows. Modern AI native development runs like a massive state machine, starting from MCP, local file systems, and what's usually called a harness.

    I also noticed what might be a mistake in the author's domain, games. Putting aside the fact that inheritance based OOP is an outdated pattern, the suggestion to remove update() and put it into a manager class's List, then iterate with a for loop, is meant to eliminate overhead like P/Invoke costs in C#. But if Foo is still a class, a reference type, then List<Foo> is just an array of pointers scattered across heap memory. Pointer chasing can still happen. So I think that's actually bad advice.(Of course, the same issue exists in Mr. Claude's code as well.)

    If the author truly wanted Data Oriented Programming(or DOD), they would have specified struct arrays or NativeArray.

    This is a tricky area. The author's goal was likely to remove the per MonoBehaviour Update call cost in Unity, which is why they suggested using List<Foo>. But the instruction seems ambiguous, and I think that's part of the difficulty with AI development.

    The objective function is the same, but the implementation varies and subtly differs from what I actually want.

    From a design perspective, for team maintenance, the GameUpdateable abstraction might actually be better. But it's difficult. In terms of extensibility, an update manager that handles registration and expansion of multiple update targets might be over abstracting.

    Writing this down makes me realize how many things I actually consider when putting code into a program. Sometimes I model how my next teammate might read it, and sometimes my words might be interpreted differently. It's really difficult.

  • > It's interesting how AI is constantly providing false information and incorrect statements about my area of expertise. Fortunately, it's very useful and always right about topics I know very little about.— pikuma.com (@pikuma) June 19, 2026

    Also true for TV commentators, bloviating C-suiters, frequent posters on social media, politicians, etc.

  • 3,300 words but nothing new to say.
  • I'm not disappointed in the article, there are many of them out there. I'm disappointed that this is near the top of HN. I lazily outsource my information hunter and gathering to HN.
  • Dislikes AI so much and ironically wrote a whole article without doing any of their own thinking.
  • > While I have found LLMs useful for researching and planning code changes, my attempts at actually making them write code have been quite lackluster. I found them to be slow and expensive to generate, for a mediocre result.

    I think this observation is generally true for the kind of problems the author is working on.

    But I would not make the leap to avoid using LLMs for any kind of code writing. LLMs do fantastically well in the 95%+ of the code that engineers spend time on. And for those we should leverage the technology.

    It is upto us as engineers to figure out when to stop using LLMs. We are smarter than just dumping logs and half dozen specialized markdown files to a LLM and have it figure out solutions.

  • All this completely ignores the cataclysmic negative externalities, including environmental costs, knowledge atrophy and workforce erosion, accelerated burnout, slop-pollution of the open internet, shifting of power from engineers to management and SAAS corps, and empowerment/enrichment of some of the most morally vacuous people in tech history.
  • > “Agentic workflow” (or whatever they’re calling it at the time you’re reading this article)

    > Unlike the silver bullets of the past (like microservices or NoSQL)

    > Hallucinations are an inherent property of how LLMs work.

    > It’s all marketing and buzzwords

    Not a serious article or thinker. I can get this stuff on Reddit if I want to read thrice-regurgitated cliches about AI.

  • The author is a real C++ programmer. Not like the PyTorch guys who use std::shrared_ptr for cyclical graphs and then go on to overpromise on threaded Python only to find out that the slowdown is much larger and everything is brittle as expected years ago.

    The times that Meta people can browbeat honest engineers are over.

    Nice corporate take.

  • I'd like to hear actual rebuttals to those quotes.
  • It reads like something written by a time traveler from the past.
  • We are all time travelers from the past.
  • I liked the two original experiments in the article, which in a microcosm gels with my 1+ year of deep agentic development. But I would like a whole article about his experience, and with which model (Opus? Fable? erg, Sonnet?) and effort he used.

    I've progressed in using latest Claude-kins and the GPTs as usually competent teammate/buddies, and generally know to sort out the fluff confidence with the realz (shoot, that was how I was when I was but a wee little coder lad: overconfident because of an error-free compile and one non-segfault run.)

    You have to put in the time, the skill creation, the system prompt/personalization, the (sometimes adversarial) automation, the testing, verification, kicking down the loop castles (as usually caused by being cheeky with highest effort levels.)

  • I have been doing this (vibecoding) for as long as the term vibecoding was coined. The amount of people I have met that describe the process like you did and then proceed to show the most soulless vibecoded app is staggering.
  • Here's a guy who does more than make simple, bloated end-user apps. He tries to dig into the code and make novel performance optimizations etc. He sees that AI can't code everything.
  • > In a past life I had to argue every year to renew a license for a profiling tool that cost about 20 EUR a month. I’ve heard since that everyone at the company is now getting a Claude subscription, even non-programmers.

    Underrated quote. I also found this frustrating. At one company I was at (a very old company which was trying to pivot to software engineering), we had hellish bureaucratic fights with the IT department to get access to Pycharm, Obsidian, and even GitHub. But then the AI craze dropped and management just gave us all GitHub Copilot access without us even asking.

    Cory Doctorow's book The Reverse Centaur's Guide to Life After AI talks more about this. It's just a modern symptom of an age-old power struggle. The workers want more control over their craft, including quality standards and tools, but their bosses want more control over the workers.

    What's happening now is bosses are feeling pressure from investors to show productivity gains from using AI, so bosses panic-push AI within their companies. Which leads to misaligned incentives like tokenmaxxing.