100x Developers | Hacker News Reader

100x Developers

jcarreras.es

49 pointskrenel80 comments

> 10x a salary of $70.000/year (~avg salary in USA) is 700k€/year. Imagine the lifestyle change. Lifting 10x my maximum PR on dead-lift goes from 160kg to 1.6T. A means of transportation 10x faster is arriving in 9 minute what it took 1.5h Avg. vertical jump for an male adult is 45cm. 4.5m if you 10x it.

The 10x income is the only comparison that makes sense. In Nassim Taleb’s words, this is the only Extremistan metric, obeying power laws, “Bill Gates walks into a bar”-style. The others are Mediocristan metrics - obeying Gaussians, exceedingly rare to get even slightly above the highest/lowest ever seen.

With that lens, being _effective_ (knowing the right thing to produce) can definitely 100x your value output with AI, no matter how _efficient_ (quantity per hour worked) you can become.

But is it?

Is it really 100x? Imagine that in 3 days you get the same amount of customers as you would in a almost a year so then in the next 3 days can you get the same and in the next 3 days again ... This is not even considering the idea that with AI you will get 100x of the previous 100x maybe which is really something pretty big.

If you have examples please share them.

I know good examples that are accelerating quite a lot with AI but not at the level of 100x.

That is in line with L6 comp at Netflix and similar companies pre-AI mania. So presumably companies do see 10x performance differences in staff and are willing to pay for it because they aren't charities. And I'd be using the heck out of LLMs if I was still working there, because they have proven their worth to me on open source FreeBSD work and I know the sentiment is shared by many other prolific src committers.

The main problem with LLM productivity improvement is most of us are basically treading water already as employees.. and we all tend to use new tools to keep up with the times. So everyone roughly leveling up over the same couple of years isn't going to net any pay increase, and the best you can do is job hop to somewhere that rewards you accordingly if you are able to demonstrate outstanding capabilities.

But most ironically, LLMs are also pretty terrible for current corporate structuring, because there were already massive turf wars and performative theatrics, and LLMs just make that easier/worse. So small teams and projects are really poised to benefit at the moment, because it will take a long time to figure out how to adapt organizations and management structures to this reality. I also have no idea how a large org would interview to find stand out personnel, a leetcode interview was always a bit of a performance and hazing ritual and seems completely absurd at this point when it can be solved in real time with a prompt.

Do they see such performance differences, or does the carrot need to be at least so big to tolerate the manufactured pressure and mismanagement at these companies? An engineer worth their salt doesn't have to work at a given company after all, and more often than not it's the golden handcuffs that are keeping them there as opposed to moseying on over to the company across the street. While underpayment is often seen as a sign of exploitation, large salaries can indicate such an environment too.

There's definitely a threshold of talent you need to cross to be eligible, but beyond that your differential impact is likely to be negligible at least at a company beyond a certain size.

At one point someone did, for instance the WhatsApp and Netflix OCA team being on order of 50 people while supporting xxx million users. As a company grows you are disincentivized from running a small operation like that if others aren't metered to the same rubric.

Maybe 100x is a massive stretch for people who are already developers but for non-coders like me the difference is almost infinite because I went from not being able to code at all to now having something that can work. 0 to infinity essentially.

Well, 0 to 1 - but that's still infinity times more than you could do before.

Well, 0 to 0.1 - that's also infinity times more, if you do the math

Either would be equivalent to a division by zero:

    0 * n = 1

Is the same as:

    n = 1 / 0

There's no n that multiplies with zero to make one (or any other non-zero value) so it's formally undefined, not infinite.

https://en.wikipedia.org/wiki/Division_by_zero

These "10x developer" discussions are sort of meaningless unless it's discussing a comparison to a hypothetical typical professional software developer.

I've had some coworkers who appeared to have negative value. You were infinitely more productive then them before you could code. Doing nothing was superior.

There must be an equivalent of Amdahl's law for AI-assisted development.

"You can get 100x speedup on the 90% of your development tasks, but remaining 90% of them take the same amount of time with or without AI"

Ozim law - you can speed up your development 100x or 1000x and it doesn’t matter because your users are not able to absorb and understand the changes at that rate.

I was already working on teams where we got push back on too many changes so we had to scale back to monthly releases.

Modyfying database structure so fast? Good luck having useful insights when you mutate data so quick.

Maybe I am not smart enough having not smart enough customers but to judge if something meaningful is an improvement you need at least 3 months of data for a lot of things.

Amdahl can be applied directly to sequential tasks in projects.

In project management the overall gains can be even smaller than that. If the task is not on the critical path (ref a GANTT chart), then speeding it up does nothing to overall completion time.

Of course the particular resource can still be freed earlier. Which might make it possible to do other things with it. But nothing on overall completion time.

If one underestimates the swtiching costs of changing the task a resource has, one can end up with negative effects on the original project.

> I think 10x is crazy, altho in some cases it might be attainable. 100x is just a figure of speech. It’s just not possible.

Pretty fair - I think anyone who has developed the sensation of becoming their own bottleneck understands this. And yes, if you can simply be twice as productive as you were prior to LLMs, then that is an improvement. What I worry about is that that multiplier will become a criteria for staying employed. I.e. if you were a 1x developer, and now you're a 2x, why would a company keep you in position knowing they could instead hire someone who's 5x, 10x, 100x, etc. They might feel like they are losing out. This is all relative.

I agree that now what's good or bat will be a comparison with your peers.

2x might be awesome if your peers are 1x. It might be bad if they are 4x. We'll be optimising local maxima. Per company.

The multiplier won't be such a precise number, but rather more of a feeling of "X person seems to be producing double what I'm producing". It will definitively be used as criteria for employment for a while.

Then the industry will converge into a "new normal". Best practices will propagate fast thru the industry, and all developers will have a similar baseline. Dev that were great before and doing 2x, will continue to do so. Same for underperformers. The industry as a whole will produce a whole lot.

IMHO, this will only raise the bar. It will define what's the new normal.

The original definition was difference between the best and the worst performers in a organization. Not the best and the average. It was also in the context of specific tasks.

One thing I never understood about the "Nx Engineer" trope is if it's supposed to mean "one team member who achieves as much as N average team members", "one solo dev who achieves as much as an average N-person team", or "one solo dev who achieves as much as N average solo devs". Those seem like wildly different scales, and it seems like everyone who talks about it means something different.

Every place has had some experience with some problem that entire different teams, with dozens or even small hundreds of people failed to solve for years and years, and then some individual came and did it.

And almost everybody has seen or heard some similar story.

The thing is, those stories don't have a lot of similarity to each other, and there isn't much you can conclude for anybody's competence without looking at all the details. But they happen all the time, and not only in software development (just not on the same frequency, for obvious reasons).

"One solo dev who achieves as much as a N-person team" or alternatively, "N developers who achieve as much as a 10*N person team" is the one most easily supported with evidence. Prior to their acquisition, WhatsApp had 55 employees of which 32 were engineers. Facebook Messenger had a team that was most likely 100x larger than that and could not displace them in the target markets. In 1995 when Microsoft effectively defeated IBM as the premier software company, Microsoft had just 17,000 employees to IBMs 225,000 employees. The entire reason why a startup can even succeed is because a smaller, skilled team can overcome a much larger team with much more resources.

Microsoft headcount vs. IBM is not a valid comparison. IBM is also a hardware company. IBM is also a service company. And IBM (at least at that time) did far more custom development than Microsoft. You'd have to compare the headcount of Microsoft's OS business to IBM's OS business (or OS development organization, if it wasn't a separate business).

I don't think listed options are "different scales" - they seem similarly "out of reach for normal people" just in different directions

Nowadays a single solo dev can outright achieve as much as entire _organizations_ could in the early 2010s. I know multiple people whos raw code output easily exceeds say everything Amazon/Google/Facebook (likely combined) could do in a single year in the 2010s.

Imagine a gaussian distribution of all engineers. It's a figure of speech to say someone's productivity falls in the right-side tail of that distribution.

The multiplier isn't meant literally. It's shorthand to say someone is exceptionally good in a way that is rare to find.

You're right. That's precisely the problem. The "Nx Engineer" is catchy and we all know "what it means" when we first hear it. We most likely relate it with an early experience when we were juniors and a senior developer pair programmed with us. For me it was mind-blowing. So we can relate to it.

But the issue is the ambiguity. The multiplier is there, but not the unit/metric being measured. So it's just a shorthand for "someone exceptionally good" as said by a sibling comment.

> Super small or specific task.

> Tasks so small that AI can do them in 10 minutes, were you would take almost 3 hours

I think human in the loop is the only way to achieve this. I've never seen the robot reduce the complexity of a problem space.

Multiagent might seem like the obvious path to 100x but I think the exact inverse is true.

Those are some dizzying numbers but with every passing day, our new AI world makes it more realistic. It reminds me about the prediction of a Single person billion dollar business powered by AI. Indeed, we are living in interesting times!

Before AI 10x was this mythical thing people talked about… except that it wasn’t rare. There were 10x beginners. There were experienced 10xers who lied about it because they didn’t want to get stuck doing other people’s work.

In the corporate world how do you become a 10x developer without AI? Simple, don’t repeat the same stupid shit everyone else does and write your own tools. That’s it. It’s simple because software only serves one purpose: automation. If people aren’t thinking in terms of labor elimination it’s so easy to be 10x whatever it is they do.

But, in all fairness most developers in the corporate world, at least on the web side, are barely capable of programming. They rely on open source packages and large frameworks to do almost everything. If you want to be 10x that then just don’t do that. Being a good programmer is helpful but not required. More important than competence or skill is not being cowardly about writing original code.

> most developers ... are barely capable of programming

[big sigh]

As much as I keep trying to believe that this can't possibly be true, I keep seeing that it is. And I really don't think that AI is going to help matters.

Imagine trying to make a programming language compiler in 1960s or 1970s. This was months if not years of work. With lex and yacc this turns into a weekend project. Imagine trying to make a CRM like application in the 1990s. This probably would have taken weeks if not months. In the 2000s to 2010s, this was a weekend project with frameworks. Imagine trying to make a game in the 1990s. Depending on the complexity, this could have been months or years of work. With frameworks from the 2000s to 2010s, for people who are adept at it, this is a weekend project.

Each of those examples is a 10x increase in productivity, before the advent of LLMs.

For anyone who's used these modern agents to do programming, it's obvious there's a 100x increase for certain programming tasks. Anecdotally I've seen the 100x increase for projects myself.

Tao talked about a 10x slowdown when trying to convert a proof to Lean (from how long it took to do a 'paper proof'). Modern agents can do a conversion to Lean, for a variety of topics, 10x faster than a human, at least.

Humans do not have a good intuitive understanding of exponential growth. The reason the OP is so skeptical is because they're comparing it to everyday experience (lifting thing, driving time, etc.). It's easy to discuss these points in context (lifting things can be done with cranes which do provide 10x human lift power, commercial airlines allow us to traverse the globe 10x faster than walking, sailing or driving) but I think this is missing the point. Computation has limits but we're nowhere near them.

> In 3 days, at 100x and you achieve the work of 300 working days. There are 260 working days in a year.

This has literally happened to me. A project that would have taken me a year was done in 3 days, and this was for a domain that I was well versed in. A project that would have taken me 10 years (because I wasn't well versed in it), took me 7 days.

> That sounds unrealistic.

It may sound that way but it absolutely isn't.

OP here! I'm honestly curious about those projects where you saw 100x improvement. Can you share what they were about?

I'll list two. These projects are hyper-niche and were developed to satisfy my own needs. They have a user base of 1 (me).

Print gallery transform: https://github.com/abetusk/CursedLogic/tree/main/sandbox/slo...

This is a web application that you can upload a picture to and do an Escher like print gallery transform to. Two examples from using the application:

https://github.com/abetusk/CursedLogic/blob/main/sandbox/slo...

Dragon rider (aka "Dragon ring"): https://github.com/abetusk/scratch/tree/release/experiments/...

Hooked up an AVR atmega32u to my exercise bike to poll the hall effect sensor to sense when the crank has turned and send that to a web application as a MIDI message to indicate when the dragon should 'beat' it's wings.

The web application is a relatively simple game where a dragon flies through rings for 15, 30, 45 or 60 mins. The idea being, a simple, relatively boring game is much more interesting when you tie it to another relatively boring task of cranking on the exercise bike.

Print gallery was a few rounds of Claude (Opus 5.5). I would guess that would've taken me 20-40 hours. So maybe an hour of wall clock time to save me 20-40 hours? 20x-40x? That's conservative, because a lot of that was iterating on the application, using it, etc.

Dragon rider I have a better sense for because I've made a game of similar complexity, and that took me 40-60 hours. Dragon rider took a few iterations, maybe 15 rounds or so with Claude, but I would guess that's a couple hours. Considering all the effects I experimented with (and mostly abandoned) the refactors, extensions and feature, I would easily guess that an equivalent of my time is in the 100+ hour range. So again 20x-100x with the same caveats as before.

When 10x is so effortless, it seems like 100x is easily within reach. Wait a few model generations and the factor easily compounds.

Unfortunately, the tech industry never rewarded 10x developers and denied they existed because it flew in the face of their now decades long wage suppression onslaught.

In fact if you are that good, you are more likely to face resentment and intimidation than receive praise.

At the current AI moment you may get some points for tokenmaxxing but it wont last long. I wouldnt worry about 100X, corporate shops cant even keep up with 10x devs, 100x will be just you building shelfware that will never see the light of day and wont get you a raise anyway.

I see a lot of peers worried when there are claims about how _other_ people are performing in other companies/projects, and how we "need to catch up". In the article I try to convey that 10x (let alone 100x) were just figures of speech. They have been adopted by the industry. The original meaning is lost. And some now believe are _real_ multipliers.

This post is a reminder of that, to be able to chill a little bit :)

My company has a huge problem where a junior engineer will complete tasks very quickly and appear to be extremely productive, but they're just hiding tech debt that has to be cleaned up later. That clean-up doesn't get factored into any assessment of the original developer's productivity. Fixing the system once it's been working and has live data takes a lot longer than it would have taken to build it right the first time.

For example: storing an API key in a plain text JSON preferences object that many different parts of the system read and return to users. Determining if there was a breach, figuring out who to talk to at the third-party company to get the key rotated, etc takes time. The person doing that work doesn't look very productive because they aren't shipping a lot of code that impacts customers. The developer who put the API in plain text looks like a 10x engineer because they shipped a customer-facing feature really quickly.

> My company has a huge problem where a junior engineer will complete tasks very quickly and appear to be extremely productive, but they're just hiding tech debt that has to be cleaned up later.

You're so right. Measuring wrong the impact, without taking into account incidents, tech debt, and so on. A classic.

Okay we are not fucking starting this shit again. Have we learned nothing?

We have very short attention spans and even shorter working memory. Also, the big numbers trigger our fomo very easily.

I just wrote a program that writes code at ~200mb/s and so will create a codebase the size of the mainline Ubuntu in minutes.

Never mind that it's just sedding "print "Hello, World!"" to the penultimate line.

I may not be too bright, but Lines of Code? I've got those.

The 10x developer is a myth. There are no 10x developers, and there never were. What happened is big tech (Google, Facebook, Apple) mixed up cause and effect. They would see small teams or solo developers suddenly ship projects in 1/10th the time they expected, and they wanted to study this. Rather than face the realities the corporate bureaucracy, which was actually turning everyone else into 0.1x developers, they concluded that these mythical "10x developers" exist. This was reinforced by how 10x developers were deployed. Company A poaches 10x engineer from company B, and puts them in charge of a 10x project, and clears away the bureaucracy. Amazingly? They still manage to be 10x. When a company, however, fails to clear away the bureaucracy, that 10x developer suddenly becomes another 1x (or really 0.1x) developer, and they call it a bad hire, and try over and over until the project is cancelled.

People who graduate from college and immediately go to work in the bureaucracies find it hard to adjust when they shift over to a startup environment, where 0.1x work isn't acceptable. Getting them up to 1x is a slow process, you basically have to put them through internship like training.

Of course, there are some standout engineers who reach 2x theough wit and experience.

AI is the first time we're really seen this multiplied, so those 2x engineers might be really reaching 10x or 100x now, simply because general knowledge is now the single factor, not coding speed or memoring java class names.

Go look, you'll find hobby projects doing amazing things with AI, easily one person doing what would take 50-200 developers at a big tech company. And that makes you wonder, what good were all the "stakeholders" anyway? Doesn't rapid iteration, the soul of agile, trump everything now?

> 10x a salary of $70.000/year (~avg salary in USA) is 700k€/year. Imagine the lifestyle change.

No matter how much I earn my lifestyle stays the same. Rejecting lifestyle inflation has been the single best thing I've done in my life.

Speaking of salary though, I bet if I become this mythical 100x AI powered developer I won't see even a 2x salary increase.

Productivity never translates to wages.

Point taken! The example tries to exemplify the massive difference. Lifestyle inflation is a thing you're right. Why not to think in the reverse, then?

> 10x LESS salary for $70.000/year (~avg salary in USA) is 7k€/year. Imagine the lifestyle change

> I bet they are measuring lines of code, MRs or deployments.

My previous employ was at one point being courted by an AI coding agent company to push their agent on us, internally; after a trial period, they sent us pretty graphs show us the "increase in productivity", which as TFA correctly guesses, was MRs.

I double checked the numbers, and … the books were cooked. This was pointed out and "oh it was some bug in the script we use that's all fixed now" but of course, … the graphs weren't regenerated or corrected. (And also, of course, the correction would not have been in their favor.) So of course the (now known to be bad) data continued to be an input into decision making. (Which TBF to AI, making decisions on suddenly conjured data before or even after it has been verified has been a thing long before AI.)

Even before ai I've seen 0.1x programmers. If 10x programmers exists and we normalize 0.1x programmers to 1x, then 10x became 100x.

A 0.1x developer becomes 0.01x with AI, not 1x.

> Are you feeling down because AI is everywhere around you and you’re supposed to be working at 10x, 50x or 100x? Is this causing you anxiety? Please relax and take it easy. If you’re doing 2x as a team, it’s great already!

Actually, the most depressing part is that programming languages don't matter as before, the fun on open source projects is gone, and 2x as a team, means management now can do the same with 1/2 of the previous team sizes, most think they always land on the lucky half.

Sure. The benefits will be for the company, no the engineer.

One way to make our job better is to remind ourselves that not data-backed claims of productivity might not be real at all.

I've written about it as well: https://jcarreras.es/posts/let-engineers-enjoy-the-benefits-...

> Actually, the most depressing part is that programming languages don't matter as before, the fun on open source projects is gone, and 2x as a team, means management now can do the same with 1/2 of the previous team sizes, most think they always land on the lucky half

I see it very differently:

* AI automated most tedious parts of coding leaving us creative parts (design, research)

* while individual productivity increased, but also complexity of products, systems, problems increased too, I am not sure corps who downsize task-force will benefit from it in long run

> 10x a salary of $70.000/year (~avg salary in USA) is 700k€/year. Imagine the lifestyle change

No, no it isn't.

"only" ~€631,113.70

Also, an average SWE salary in the US must be way higher than $70k.

In a word, yes.

BLS doesn't make sharing links easy so here's a screenshot: https://files.catbox.moe/irwwwb.png

That's an empty file.

OP here. I literally asked Brave Search for "avg salary for a developer in the USA" and AI returned that number.

How ironic. I'm a 0.8x blog writer now, thanks to AI :joy:

100x employees are real, they look like a 20x employee in a market where comp is 20% of a major US city

A 20x employee is not making 80% less than a median 20x employee anywhere else. At that echelon the pay differences based on location, if they exist at all, are insignificant compared to base.

> Tasks so small that AI can do them in 10 minutes, were you would take almost 3 hours.

Re: 100x productivity that's still not technically correct (the best form of correct), is it? 3 hours is 180 minutes. Agent would have to get it done in 1.8 minutes.

Yes, good catch. Math was not mathing.

we measure productivity compared to 1960s-era punch card programming, obviously. I'm a 10000000x developer

E.T. (the worst game in history) was done in 5 weeks. Experienced game developer can make similar game in hour. AI in minutes.

AI can outright make Skyrim/earlier Call of Duties or Battlefields in minutes. Literally. From scratch. Keep in mind that Bethesda sank, what, hundreds of millions into Skyrim?

If "AI" can make Skyrim in minutes, why is all of the slop...slop?

Do you have any citation for any AI actually making (not recompiling or creating an emulator for) a game of that size and polish in any timeframe? Let alone minutes?

AI can only make Skyrim in minutes when it is given Skyrim to copy. If you wanted to make it from scratch it would take a 1000 page design document that would probably take you years to write, and the result would be slop anyway.

My sources say programmers at the time could punch 100-200 lines of holes or 6-24,000 individual holes per hour.

The back of my napkin suggests that punching 60 to 240 billion holes per hour (~16.7M-66.7M per second)results in incineration of the media leading to a net 0X in production of useable code.

I prefer to think in terms of 0.1x coders, and 0.01x coders, and in fact, in a lot of those cases, the right management can turn a 1x coder into a 0.01x coder.

Does the 100x refer to the boredom of these developers?

What is this curious scaling obstacle that is preventing them from going to 1000x+?

Reading speed, working memory. Agents are good coders, they are not good middle managers.

For me personally? Local processing power. The reason I rolled my own harness environment is because my 16 core CPU was literally MAXED OUT with parallel compilation units and edit streams. A custom harness barely helped. Just allows me to run a few more sessions in parallel

Should not spending more money on local processing power be a non-brainer then? You will make it all back and then some?

Not 100% related, but I have a draft on a thought experiment: how would change if AI responses were immediate?

Like sub-second latency for _any_ change you ask it. Let it be 100 files changed, MR review and fix of each point, design document, anythikng.

Tool execution (eg: running tests) would be the next tech bottleneck. And human-on-the-loop the obvious one.

Maybe that's where 1000x productivity hides, who knows :)

In case some contrarian climbs out of the woodwork to yell "umm aktually it's just a metaphor! nobody would actually think that", let me introduce you to Garry Tan and his 100x AI dev [0].

  | Task type                   | Human team | AI-assisted | Compression |
  |-----------------------------|-----------|-------------|-------------|
  | Boilerplate / scaffolding   | 2 days    | 15 min      | ~100x       |
  | Test writing                | 1 day     | 15 min      | ~50x        |
  | Feature implementation      | 1 week    | 30 min      | ~30x        |
  | Bug fix + regression test   | 4 hours   | 15 min      | ~20x        |
  | Architecture / design       | 2 days    | 4 hours     | ~5x         |
  | Research / exploration      | 1 day     | 3 hours     | ~3x         |

[0] https://github.com/garrytan/gstack/blob/main/ETHOS.md

Do you dispute that an AI can be 100x better at boilerplate and scaffolding? I readily believe that. And if someone's mental model of their job is that they select the right AbstractBeanFactoryFactory pattern and then write a bunch of boilerplate then sadly they are completely outcompeted by AI. In the future nobody will pay you to write boilerplate.

But 100x on scaffolding or 50x for tests obviously doesn't translate into 100x or 50x overall throughput. The doc states, "The compression ratio between human-team time and AI-assisted time ranges from 3x (research) to 100x (boilerplate)". So Tan's position is not that you have 100x gains, but that you have 100x gains on tedium.

From personal experience depending on the type of software these numbers sound reasonable. Some software is more difficult than others. But for plain old web dev, yes you can absolutely crush it with AI now.

Maybe I just hadn't yet worked in a real company, but if your codebase is enough Fizzbuzz Enterprise it takes you two solid days of uninterrupted coding to work through "boilerplate" without actually implementing the feature, you're having much bigger problems than this....

It's impact that scales, not "productiveness"

A programming language, for example, keeps scaling in impact after the code has been written.

Yeah, when AI bros talk about 10x or 100x developers, they're always talking about the input metrics (how many CRs, how many tickets, etc.), but never about the output metrics (revenue or profit growth, customer acquisition, cost savings, etc.).

I don't think there's a single claim of increased productivity thanks to AI that I've seen that held under scrutiny. It's all smoke and mirrors.

On a side note, this sentence is extremely funny to me: "Super small or specific task. Tasks so small that AI can do them in 10 minutes, were you would take almost 3 hours". Even when the author tries to make the case for AI, he's only able to reach a 18x multiplier, far from the 100x boasted by people.

So someone who went from producing ~30k loc/year to 30 million hasn't increased their productivity?

No? What are those 30M lines of code doing? For all we know they might have massively decreased their and their team's productivity.

I've seen ai rewrite a 25,000 line project as a 70,000 line project with no change in functionality, so theres that.

This is a point that I think folks miss a lot in these discussions.

I've seen my own raw code output increase by more that 100%, and that's after human review to make sure it's not just slop, before sending it to the rest of the team for review. And we're all doing that. We're all shipping way more code than ever before.

But I don't think our number of users is changing dramatically at all. "Engagement" (or however else you want to measure usage) isn't something that's gone up by the same factor.

\<half baked thought>

I think the simple explanation is this: there is finite "attention". Digital products cost nothing[^1] to copy and ship. They can scale to your maximum amount of users with the same cost to write. And now that cost to write is →0.

But attention hasn't increased by the same factor. People still spend exactly the same amount of time in front of their PCs. Orders of magnitudes of additional features aren't going to actually result in orders of magnitudes more usage.

Maybe there's some hypothetical product that could gain such an advantage in the market that it would fully displace all other entrenched players. Maybe a new application category might come to exist (agentic engineering applications come to mind).

But us being 10x faster at building out features doesn't mean there's suddenly 10x more supply. That's the smoke and mirrors of it all. What does being 10x faster actually get you?

The logical outcome would be to spend 90% less on the cost center (engineering), to retain the same productivity, right? That's a accounting view of the world, one that can't account for the institutional capital that's built from human collaboration, and redundancy from having more maintainers of a project. But that seems like the only way this ends up working. Trading 10 engineering payrolls for 1 engineer and (<9 engineering payrolls) worth of tokens.

[^1]: perfectly spherical vacuum approximation, of course

Reply on news.ycombinator.com