alt Hacker News2x, not 10x: coding with LLMs in 2026
Comments
While I agree with the premise, I think this angle only applies on work one was going to do no matter what. The real power of these tools is that there are so many ideas people would like to try, but never have the time or motivation to pursue.
So the comparison is not only "built with and without LLM" but "would you even build this if you didn't have the LLM?". The gap in productivity in this case is much more wide.
This reminds me of themes I recently saw in [Harness Engineering is not Enough: Why Software Factories Fail](https://www.youtube.com/watch?v=Ib5GBkD555M) (Warning: the last 3 slides seem like an advertisement). One thing I liked is how Dex has a little graphic he glossed over showing software development is
- 25% planning & aligning with other teams
- 25% coding
- 25% testing/verifying
- 25% code review/rework
One argument was that agentic coding speeds up that coding part a bunch. So maybe there's 2x speedup in coding. But that's only a small speedup in the totality of everything software engineers do.
The way I see it you should calibrate the way you work with LLMs based on how confident you are on that specific area, and if it's your responsibility to own/understand it. Here's how it feels for me:
* Learning stage: 0.5x - 1x. I change my system prompt to teacher mode, taking the productivity hit for actually learning the system/tool pays off dividends later. I change my system prompt to "teacher mode" and slowly loosen it as I get more confident.
* Working-knowledge: 2x - 3x. Once I am ramped up enough I feel like I can get a decent productivity boost. Most of the time is spent at the planning stage. This is my mode for areas I don't really own or care about, just need to get work done.
* Mastered: 10x+ I have been doing web front end for 12+ years, I can quickly review plan/implementations and for my initial prompt I already know most of what I want built.
1x == my speed before AI
I recently removed about 50% of code in a feature submitted by a colleague, because it's a pile of over-engineered mess that either never gets used or caused trouble for us. We probably would not have added the code in the first place if we actually discussed the design. With the code removed, the feature is now much simpler and more maintenable.
And that's the second time this happened over the past few months.
yeah i can't say if it's 2x or 10x or 100x i don't know. i just know i barely open vim anymore. I still find my rate of development is limited by how much my single mind can hold at any given time. I am however accomplishing with a much higher rate of confidence many many more daily tasks usually by 10am... the limit is usually my willingness to imagine and think critically about an idea with enough clarity to result in something that make sense. It's a different energy then normal development but similar enough.
I agree with the general premise with respect to current SOTA, but for making nice plots that I would've never otherwise made or learned how to make (to the same standard), easily 100x.
My measurements are Claude is 6x - 10x on prototyping and MVC then it starts to be 2x at most. You can also witness 0.5x (asking simple tasks might require more time than performing them by oneself)
Here’s another one claiming 10% https://news.ycombinator.com/item?id=49113774
I'm not sure about the x, but the first thing that arises from that is, I feel like in my case it's way higher than 2.
The 2nd thing is, how do I measure that.
---
In my case, the details of my work (Kinda DevOps, kinda Senior Dev) makes it that having an LLM to do the heavy lifting allows me to do things not only faster, but better, and across domains I do not hold expertise on.
An example of the effect of LLMs in my daily work is that I'm in the middle of a PHP upgrade for a rather large legacy application, and the "heavy lifting" is really out of the scale, letting me concentrate on what really matters, while at the same time if I do keep "the harness" tight I'm certain the results are the correct ones. Also correcting course is just as cheap.
Not having to worry on the tooling on exchange has the incredible desirable result of my velocity being incomparable to what it was before.
Then we have the side effect of how easy to do transfer knowledge: Rather than telling the QA guy how to do the work specific for this task, I defined a set of files (.md documents, skills, an off-the-shelf customised MCP server) that assist QA into doing the work in a way that helps me do my job better and faster.
There's also a clear possibility that what I'm doing will expand to the rest of the team I am in, completely altering the way in which we approach development.
If we take 'x' as 'mileage', yours might vary. Mine has, and I'm baffled at the positive net results I AM getting.
Also, this what I do (coding?) is extremely fun again.
Being able to work close to the speed of thought is the best high.
I won't argue this title isn't the author's experience, but it's misleading to rest a quantitative claim on a qualitative argument, while also refusing to fully exploit the technology.
From a firm that has fully embraced agentic engineering, they offered topline stats on their measurements of a 4x boost from November to February, and 8x on top from February to May. That's 32x since November 2025, coding with LLMs.
And like whatever, this is second hand and I'm not going to disclose the source. Actual hard, published, and peer-reviewed research is needed here to backup quantitative claims. 2x, 10x, 32x, whatever.
When I approach a new area or task I first explore it, by hand, and implement, by hand, the task. This way, I get a deeper understanding and it gives me some momentum to llm the rest of the related tasks. Till I loose enough grip to "re-dive in" that area and to again, do stuff my hand. Some tasks, I only do by hand, and some tasks, I only use llm for.
Really depends on the task, my the project and on, and honesty, my instrest and availability at the moment.
Does the number × depend on how big your thinking is? If you are only 2× then you need to think bigger, aim higher, etc. I think the limit on the 2× is not the ai? Where is the limit now? I think it's unknown.
> Never write READMEs, docstrings, or comments. I will write those myself later. And yes, I really mean this.
The precise and rigorous practice of “engineering” in 2026.
You still have to know what you’re doing. That came from years of doing it by hand. Where is that necessary experience going to come from for the current and future generations of juniors?
I think LLMS have reached to a point where now its just about money. you have to decide whether you really want to spend your tokens to do X or you can just do it yourself and use the tokens for something else.
I mean the "x amount" is relative to your existing skill level, right?
It's worth asking ourselves "why does the x amount matter?" I get the desire to define KPIs to estimate productivity gains. But this all seems to be—rather rapidly—leading to an increasingly dehumanized reality (both figuratively and literally) so we can...produce more software? I love building software, and I enjoy using LLMs to help me do it, but there's just this weird vibe I can't quite shake about how we're trying to quantify all of this.
0.25x because I scope bigger now and then I may get a few "free" React components but largely doing all that work of putting it together.
Wouldn't trade it though. Feel like I can overall do more with less time and energy.
At the end of the day, AI is making me work more (good thing). If you count that as productivity, then sure.
Even this is overstating it IMO.
I already convert from multipliers to percentage of increase, so when someone claims 10x they very likely mean +100% productivity, and here 2x means +20% productivity, which seems about right. Nobody that was normally productive before LLMs has suddenly 10x'ed their output now.
The problem is that 20% productivity when it comes to generating code, really doesn't translate in 20% productivity increase overall, when you take into account the fact that the code quality is worse, the fact that writing code is actually not the majority of your time spent, and that people get burnt out from the usage.
> As for documentation, I've found this simple instruction to vastly improve LLMs' output:
> Never write READMEs, docstrings, or comments. I will write those myself later. And yes, I really mean this.
This is quite validating as I came to the exact same conclusion myself. We’re required to use an LLM for every task at work that touches code†, and I was really struggling to get Claude to stop with the long waffly comments that reiterate the next few lines of code in 3x as many characters, making contextless references to subtasks in whatever harness du jour we’re using this week.
No amount of examples or explanation of what I wanted would make it stop. And then I realised of course, I’m asking something which has no concept of meaning (or, indeed, anything) to only add meaningful comments. More fool me I guess.
Of course, it’s ultimately pointless given all of my colleagues are regularly opening PRs with more comments than code anyway. 80% of my code review responses these days are just increasingly exasperated “pointless comment, please remove”.
† This is just as infantilising as it sounds, by the way
200x coding with LLM
> As such, I use LLMs mainly to produce a rough draft of the code which I then iterate on heavily, at least until I like the general structure.
Weird… I would have said this was how it was about 2 years ago, but no way in 2026.
> Never write READMEs, docstrings, or comments.
I found that latest codes don't write comments in code by default. And when they do, they write stupid shit like "This was code that did X, it was now removed".
You have to explcitly prompt them to write comments in code. They are still useful for you, the user. But are arguably useful for the model, too, given how many of them (especially Claude) only reads small chunks of files. So I'd rather have code comments than it reproducing a picture from incomplete data.
All these hot takes that LLMs are -10x, 100x, 2x are kind of silly. It really depends on:
What you are using it for? What language, what framework, how many LOC, what domain, how much docs can the LLM read, etc etc.
What are you optimizing for? Cost? Human knowing how your code works? Getting something out the door?
How Good You Are at Prompting the LLM for THAT specific set of parameters?
I find AI can save me like 5x time on something, and in other cases it's wasted 5x time. Overtime I'm hopefully learning how to use it better.
I spent 30min with Opus 5 generating some CSS and components for my Phoenix LiveView template project (which I use for starting new projects). Then I spent around 5 hours parsing and cleaning up the output. I could of course not have done that, but since it's my spare time project I can care about the code and quality.
I did get wins for sure (and I did save time), and I'm sure most people wouldn't even spend five minutes cleaning up, but this is definitely one place where people talk about different things regarding whatever x speedup they get.
... the official return of pair programming! The best part: LLM's save you from having to argue with a human. Added bonus: now you get to master two tools instead of one.
I've found a variant of the Gell-Mann Amnesia effect with regards to LLM coding. They're really magical if you're not familiar with the language, domain, or frameworks you are trying to use. But if you're familiar with those things then you'll often catch them lying to your face and producing a lot of plausible nonsense.
>As such, I use LLMs mainly to produce a rough draft of the code which I then iterate on heavily, at least until I like the general structure
Tell me you just started with agentic programming without telling me you just started using agentic programming.
Look, don't get me wrong: new folks learning tech should absolutely write articles about it! But their claims might very well change once they learn more .. and I strongly suspect that will be the case here.
This is a dated take to me. I think the next stage in unlocking productivity is so called "loop engineering"; figuring out how to effectively not read all the code while ensuring quality. To me that means implementing statistical quality control and formal methods.
Before I get there I have to figure out how to reliably audit plan adherence. The problem is that when the specs are in natural language, as they are, you need a fallible LLM to verify it.
Personally i'm only using local LLMs that i can run on my 7 year old PC (that also has a GPU with 24GB VRAM because reasons :-P) so i'm not sure how much that experience matches what others are doing (though roughly speaking what i see people complain about Claude doing doesn't feel that different from what i see the local stuff doing, so i guess the drawbacks aren't scaled down as model sizes increase).
I'm not sure about 1x, 2x or 10x increase as these metrics are about code written but that isn't a productivity metric (something pretty much every half-decent programmer would agree with before LLMs - remember stories about Bill Gates saying that more LoCs being good for software is like more weight is good for airplanes or Bill Atkinson's story about adding -2000 LoCs to improve QuickDraw?).
But they can certainly help "get you going" faster in that if you're stuck on something (for whatever reason - including "that feels too much drudgery") or have issues starting something, you can have an LLM take a stab at it and it'll produce "something". Sometimes it is enough by itself, but more often than not it'll need tweaks (either directly or having the LLM do it). I got to make a bunch of things i couldn't convince myself to do - e.g. an image viewer that doesn't suck (based on my arbitrary judgement), a game database, a script to convert a git repository into static html pages that kinda look like GitHub, etc.
They can also help find (and sometimes fix) bugs or other "code smell" issues. They're not that great for exact results (without tool calling -and knowledge on how to use them effectively- at least) but when it comes to fuzzy / vague stuff like "check out this code <code dump here> can you spot any issues?" they always tend to find some stuff (even if it is hallucinations :-P but sometimes they find actual issues too or whatever hallucination they come up with reveals some actual issues with the code that you didn't spot by yourself). I've been dabbling with Rust recently and asked Qwen 3.6 35B-A3B to judge my code and it wrote "6.5/10, will compile but looks like C in Rust" :-P.
The article says:
> Never write READMEs, docstrings, or comments. I will write those myself later. And yes, I really mean this.
And sure, LLMs aren't that great about those (i do let them leave whatever comments they want though and remove them later myself - i think those comments help during the generation/prediction - basically how they "think", kinda like the reasoning phase), but they can be very good at things like "here is the code, here is the documentation for it, spot discrepancies" (i had Devstral Small 2 do this and it hallucinated a few discrepancies but also found real stuff i missed in the docs).
I've tried to use Devstral Small 2 for some API docs but found it'd sometimes make assumptions about what function do or how. One approach that might work, but i haven't tried yet, is to write the "guide" myself, then have the LLM write the function docs using both the guide and the code as reference. The reason i think this will work is because it got things 95% correct just having access to the function code alone (and without the rest of the codebase), so the "guide" would help it reach 99%. I do not expect it to get to 100% so a manual edit pass will need to be done anyway (and i have an idea for a tool to assist in the manual edit pass for that - a tool that i'll probably get an LLM to write - BTW good luck coming up if all that stuff would increase or decrease productivity for an actual product and not some random stuff i'm toying with :-P).
One other thing i've also found LLMs useful recently is to have them use the stuff you make and see how they try to use it. I have an old project, a GUI toolkit i've been hacking on every now and then since 2011 or so, though it was never a priority. Yesterday i decided to dump all the header files to Qwen 35B-A3B (i use 4bit quantization that gives me a 256k context - it isn't particularly smart but it is neat to not have to micromanage context size like i have to do with Devstral Small 2 or Qwen 27B where both of them aren't very usable speedwise at anything above 32k context sizes).
Then i asked it to just make a few small programs and it did[0] (the shot shows a paint app, a calendar, a todo list and a unit converter). Pretty much every program found bugs in the library :-P and gave me ideas on how to improve things.
In general i get the impression that LLMs aren't great at architecting things but if you do the architecture yourself and write them a framework to use, they should do a fine job at it.
[0] http://runtimeterror.com/pages/iv/images/d50c436990db203a07f...
My observation is that AI tools generally make people /less/ productive. They are more productive in that they produce more stuff, but they are less productive in that the stuff they are producing has lower inherent value delivery. The primary place where I see this in software teams as a Product person is in document creation. If you are using an AI tool to produce internal documents, this is likely a net-negative value activity that actually reduces the overall productivity of the team. Why? Because writing is thinking. By handing off document creation to an LLM for a document that's supposed to communicate important details between teams (e.g. technical design docs, requirements docs, strategy docs) you are actually handing off thinking, or rather handing off not-thinking as AI tools cannot "think". The outcome of is poorly "thought out" slop that generates more work for everyone involved to resolve /or/ everyone simply ignores the document and the previous processes stop being useful.
If anything, I'd say AI tools in /most/ enterprises as people are trying to use them now are at least a -30% of productivity. If used correctly for taking a human-written/thought requirements doc, converting it into an interactive prototype that can be critiqued and ultimately included as part of the solution alignment within the requirements doc, and then is handed to an engineering team that is effective at using humans and AI to produce code, then it's probably a benefit. But most businesses lack the internal rigor, quality culture, and data governance to support properly applying AI tools in a high context manner internal to their business.
[dead]
[dead]
Does a 60x speedup count? Are you still copying and pasting from chatgpt, because if so your definitely doing it wrong.
I'm probably a weird outlier. Coming from academia, it's ranging from 1x to infinity-x (as in, certain tasks wouldn't even be touched if not for AI).
For stuff that I'm used to (R) I can write nice and compact spaghetti (long %>% pipes). I'm not comfortable when a working script doesn't fit the screen (plus a few scrolls max). My style is probably easy only to me. When I teach, I don't teach it in particular.
AI gives me thousands of lines of codes for those. 10k once. It's cool if it suffices to source it all, but working with that is not pleasant.
But if I can reproduce a paper in a one-shot (it used to be an hour, but recently it got so much better), that's a task that would not have been even attempted years ago. And I'm talking about a methods paper with no available Github (or, as often happens, when the existing Github is useless)