I love the quote from Gregory Terzian, one of the servo maintainers:
> "So I agree this isn't just wiring up of dependencies, and neither is it copied from existing implementations: it's a uniquely bad design that could never support anything resembling a real-world web engine."
It hurts, that it wasn't framed as an "Experiment" or "Look, we wanted to see how far AI can go - kinda failed the bar." Like it is, it pours water on the mills of all CEOs out there, that have no clue about coding, but wonder why their people are so expensive when: "AI can do it! D'oh!"
I’m super impressed by how "zillions of lines of code" got re-branded as a reasonable metric by which to measure code, just because it sounds impressive to laypeople and incidentally happens to be the only thing LLMs are good at optimizing.
It really is insane. I really thought we had made progress stamping out the idea that more LOC == better software, and this just flies in the face of that.
I was in a meeting recently where a director lauded Claude for writing "tens of thousands of lines of code in a day", as if that metric in and of itself was worth something. And don't even get me started on "What percentage of your code is written by AI?"
As Dijkstra once opined in 1988: "My point today is that, if we wish to count lines of code, we should not regard them as "lines produced" but as "lines spent": the current conventional wisdom is so foolish as to book that count on the wrong side of the ledger."
In an adage: code is a liability, not an asset.
As a fun exercise, I tried to see how close I could get to Cursor's results without using any Rust crates, and by making the agent actually care about the code. End results: 20K LOC for a browser that more or less works the same, on three platforms, leveraging commonly available system libraries and no 3rd party Rust crates: https://emsh.cat/one-human-one-agent-one-browser/ (https://news.ycombinator.com/item?id=46779522)
I'm not entirely sure what the millions of lines of code is supposedly doing.
"What percentage of your code is written by AI?"
"I don't know, what percentage of your sweater is polyester?"
"I don't know, I think it's all cotton, why do you ask me such a random question?"
"Well surely you know that polyester can be made far cheaper in a plastics factory than cotton? Why do you use cotton?"
LOC per day metrics are bovine metrics: how many pounds of dung per day.
I'd argue porcine: how many pounds of slop per day.
KPIs are slowly destroying the American economy. The idea that everything can be easily measured meaningfully with simple metrics by laypeople is a myth propagated by overpaid business consultante. It's absurd and facetious. Every attempt to do so is degrading and counter-productive.
Other western economies too. In the UK its destroying the education system too.
The problem is that Western societies shifted into a "zero trust" mode - on all levels. It begins with something like being able to leave your house door unlocked after going for work to that not being reasonable due to thefts and vandalism, and it ends with insane amounts of "dumb capital" being flushed into public companies by ETFs and other investment vehicles.
And the latter is what's driving the push for KPIs the most - "active" ETFs already were bad enough because their managers would ask the companies they invested in to provide easily-to-grok KPIs (so that they could keep more of the yearly fee instead of having to pay analysts to dig down into a company's finances), and passive ETFs make that even worse because there is now barely any margin left to pay for more than a cursory review.
America's desire for stock-based pensions is frying the world's economy with its second and third order effects. Unfortunately, that rotten system will most probably only collapse when I'm already dead, so there is zero chance for most people alive today to ever see a world free of this BS.
I completely agree. The issue is that some misconceptions just never go away. People were talking about how bad lines of code is as a metric in the 1980s [1]. Its persistence as a measure of productivity only shows to me that people feel some deep-seated need to measure developer productivity. They would rather have a bad but readily-available metric than no measure of productivity.
Every line of code is technical debt. Some of the hardest projects I’ve ever worked on involved deleting as much code as I wrote.
Exactly. I once worked on a large project where the primary contractor was Accenture. They threw a party when we hit a million lines of C++. I sat in the back at a table with the other folks who knew enough to realize it should have been a wake.
It’s just the easiest metric to measure progress. Measuring real progress in terms of meeting user needs with high quality is a lot harder.
Oh yeah. At a previous job there was a guy who'd deleted more code than he'd written which I always found a little amusing.
Being in a similar position to him now though... if it can be deleted it gets deleted.
That's what got me. I've never written a browser from scratch but just telling me that it took millions of lines of code made me feel like something was wrong. Maybe somehow that's what it takes? But I've worked in massive monorepos that didn't have 3million lines of code and were able to facilitate an entire business's function.
To be fair, it easily takes 3 million lines of code to make a browser from scratch. Firefox and Chrome both have around ten times that(!) – presumably including tests etc. But if the browser is in large part third-party libraries glued together, that definitely shouldn't take 3 million lines.
Depending on how functional you want the browser to be. I can technically write a web browser in a few lines of perl but you wouldn't get any styling, let alone javascript. Plus 90% of the code is likely going to fixing compatibility issues with poorly designed sites.
FastRender isn't "in large part third-party libraries glued together". The only dependency that fits that bill in my opinion is Taffy for CSS grid and flexbox layout.
The rest is stuff like HarfBuzz for font rendering which is an entirely cromulent dependency for a project like this.
Yeah I would have thought 3 million lines for a fully functional browser is a little lean, though I imagine that Chrome and Firefox have probably reinvented some STL stuff over the years (for performance) which would bulk it out.
Lines of code is just phrenology for software development, but a lot of people are very incentivized to believe in phrenology.
These 'metrics' are deliberately meant to trick investors into throwing money into hyped up inflated companies for secondary share sales because it sounds like progress.
The reality was the AI made an uncompilable mess, adding 100+ dependencies including importing an entire renderer from another browser (servo) and it took a human software engineer to clean it all up.
Citing the ability to turn on an endless faucet of code as a benefit and not a liability should be disqualifying.
It's only impressive if you've ever only saw code as a means to an end and SLOC never really mattered.
If you write code in any capacity, you'll know that high LOC counts are usually a sign of a bad time, browsers and operating systems aside.
> According to Perplexity, my AI chatbot of choice, this week‑long autonomous browser experiment consumed in the order of 10-20 trillion tokens and would have cost several million dollars at then‑current list prices for frontier models.
Don't publish things like that. At the very least link to a transcript, but this is a very non-credible way of reporting those numbers.
That implies a throughput of around 16 million tokens per second. Since coding agent loops are inherently sequential—you have to wait for the inference to finish before the next step—that volume seems architecturally impossible. You're bound by latency, not just cost.
The original post claimed they were "running hundreds of concurrent agents":
It was 2,000 concurrent agents at peak.
I'd still be surprised if that added up to "trillions" of tokens. A trillion is a very big number.
16 million a second across 2000 agents would be 8000 tokens per second per agent. This doesn't seem right to me.
I mean, its right there in their blog - https://cursor.com/blog/scaling-agents
"We've deployed trillions of tokens across these agents toward a single goal. The system isn't perfectly efficient, but it's far more effective than we expected."
From an engineer working on this here on HN:
> ...while far off from feature parity with the most popular production browsers today...
What a way to phrase it!
You know, I found a bicycle in the trash. It doesn't work great yet, but I can walk it down a hill. While far off from the level of the most popular supercars today, I think we have made impressive progress going down the hill.
I think it's impressive for what it is: this level of complexity being reached by an ai-only workflow. Previously, anything of modest complexity required a lot of human guidance - and even with that had some serious shortcomings and crutches. If you extrapolate that the models themselves, the frameworks for inter-model workflows, the tooling available to the models and the hardware running them are all accelerating - it's not hard to envision where this will get to, and that this is a notable achievement particlarly when comparing with the amount of effort and resources put into what we currently see in a browser engine: many decades and countless millions of man-hours.
Fully agree that the original authors made some unsubstantiated and unqualified claims about what was done - which is sad, because it was still a huge accomplishment as i see it.
[dead]
If you want to learn more about the Cursor project directly from the source I conducted a 47 minute interview with Wilson Lin, the developer behind FastRender, last week.
We talked about dependencies, among a whole bunch of other things.
You can watch the full video on YouTube or read my extracted highlights here: https://simonwillison.net/2026/Jan/23/fastrender/
Just had my manager submit 3 PRs in a language he doesn’t understand (rust) and hasn’t ran or tested and is demanding quick reviews for hundreds of LoCs. These are tools but some people are clueless..
> These are tools
Just like your manager.
Tell him you need him at the code review to explain his coding decisions.
It's only fair you ask an LLM to review it for you.
I don't think the point was to say "look, AI can just take care of writing a browser now". I think it was to show just how far the tools have come. It's not meant to be production quality, it's meant to be an impressive demo of the state of AI coding. Showing how far it can be taken without completely falling over.
EDIT: I retract my claim. I didn't realize this had servo as a dependency.
This is entirely too charitable. Basically all this proves is that the agent could run in a loop for a week or so, did anyone doubt that?
They marketed as if we were really close to having agents that could build a browser on their own. They rightly deserve the blowback.
This is an issue that is very important because of how much money is being thrown at it, and that effects everyone, not just the "stakeholders". At some point if it does become true that you can ask an agent to build a browser and it actually does, that is very significant.
At this point in time I personally can't predict whether that will happen or not, but the consequences of it happening seem pretty drastic.
> This is entirely too charitable. Basically all this proves is that the agent could run in a loop for a week or so, did anyone doubt that?
yes, every AI skeptic publicly doubted that right up until they started doing it.
I find it hard to believe after running agents fully autonomously for a week you'd end up with something that actually compiles and at least somewhat functions.
And I'm an optimist, not one of the AI skeptics heavily present on HN.
From the post it sounds like the author would also doubt this when he talks about "glorified autocomplete and refactoring assistants".
You don't run coding agents for a week and THEN compile their code. The best available models would have no chance of that working - you're effectively asking them to one-shot a million lines of code with not a single mistake.
You have the agents compile the code every single step of the way, which is what this project did.
With the agent running autonomously for a long time, I'd have feared it would break my build/verification tasks in an attempt to fix something.
My confidence in running an agent unsupervised for a long time is low, but to be fair that's not something I tried. I worked mostly with the agent in the foreground, at most I had two agents running at once in Antigravity.
It did not compile [1], so your belief was correct.
Then you should have no difficulty providing evidence for your claim. Since you have been engaging in language lawyering in this thread, it is only fair your evidence be held up to the same standard and must be incontrovertible evidence for your claims with zero wiggle room.
Even though I have no burden of proof to debunk your claims as you have provided no evidence for your claims, I will point out that another commenter [1] indicates there were build errors. And the developer agrees there were build errors [2] that they resolved.
That is a good point. It is impressive. Llms from two years ago were impressive, llms a year ago were impressive, and from a month ago even more impressive.
Still, getting "something" to compile after a week of work is very different from getting the thing you wanted.
What is being sold, and invested in, is the promise that LLMs can accomplish "large things" unaided.
But they can't, as of yet, they cannot, unless something is happening in one of the SOTA labs that we don't know about.
They can however accomplish small things unaided. However there is an upper bound, at least functionally.
I just wish everyone was on the same page about their abilities and their limitations.
To me they understand conext well (e.g. the task, build a browser doesn't need some huge specification because specifications already exist).
They can write code competently (this is my experience anyway)
They can accomplish small tasks (my experience again, "small" is a really loose definition I know)
They cannot understand context that doesn't exist (they can't magically know what you mean, but they can bring to bear considerable knowledge of pre-existing work and conventions that helps them make good assumptions and the agentic loop prompts them to ask for clarification when needed)
They cannot accomplish large tasks (again my experience)
It seems to me there is something akin to the context window into which a task can fit. They have this compact feature which I suspect is where this limitation lies. Ie a person can't hold an entire browser codebase in their head, but they can create a general top level mapping of the whole thing so they can know where to reach, where areas of improvement are necessary, how things fit together and what has been and what hasn't been implemented. I suspect this compaction doesn't work super well for agents because it is a best effort tacked on feature.
I say all this speculatively, and I am genuinely interested in whether this next level of capability is possible. To me it could go either way.
Maybe so, but I don't think 3 million lines of code to ultimately call `servo.render()` is a great way to demonstrate how good AI coding is.
`servo.render()` does not appear to exist in the code base. Would you please point it out to us?
lmao okay, touché. I did not realize it had servo as a dependency.
Yeah, but starting with a codebase that is (at least approaching) production quality and then mangling it into something that's very far from production quality... isn't very impressive.
It didn't have Servo as a dependency.
Take a look in the Cargo.toml: https://github.com/wilsonzlin/fastrender/blob/19bf1036105d4e...
I haven't really looked at the fastrender project to say how much of a browser it implements itself, but it does depend on at least one servo crate: cssparser (https://github.com/servo/rust-cssparser).
Maybe there is a main servo crate as well out there, and fastrender doesn't depend on that crate, but at least in my mind fastrender depends on some servo browser functionality.
EDIT: fastrender also includes the servo HTML parser: html5ever (https://github.com/servo/html5ever).
Yes, it depends on cssparser and html5ever from Servo, and also uses Taffy which is a dependency shared with Servo.
I do not think that makes it a "Servo wrapper", because calling it that implies it has no rendering code of its own.
It has plenty of rendering code of its own, that's why the rendered pages are slow and have visual glitches you wouldn't get with Sero!
> I think it was to show just how far the tools have come.
In… terms of sheer volume of production of useless crap?
The frustrating part isn't that the project failed. It's that it was marketed as a success.
I use AI coding tools daily. They're genuinely useful for real work. But stunts like this make it harder to have honest conversations about what AI can and can't do. When executives see "AI built a browser in 3 million lines," they form expectations that set everyone up for disappointment.
The gap between AI demos and AI in production is wider than most people realize. We'd all be better off if people stopped optimizing for impressiveness and started optimizing for honesty.
Is there a way to measure the entropy of a piece of software?
Is entropy increasing or decreasing the longer agents work on a code base? If it's decreasing, no matter how slowly, theoretically you could just say "ok, start over and write version 2 using what you've learned on version 1." And eventually, $XX million dollars and YY months of churning later, you'd get something pretty slick. And then future models would just further reduce X and Y. Right?
Maybe they just need to keep iterating.
In thermodynamics, ultimately you need to input work to remove entropy from a system (e.g. by cooling surroundings). Humans do the same for software.
I am an avid user of LLMs but I have not seen them remove entropy, not even once. They only add. It’s all on the verge of tech debt and it takes substantial human effort to keep entropy increases in check. Anyone can add 100 lines, but it takes genuine skill to do it 10 (and I don’t mean code golf).
And to truly remove entropy (cut useless tests, cut useless features, DRY up, find genuine abstractions, talk to PM to avoid building more crap, …) you still need humans. LLM built systems eventually collapse under their own chaos.
I think your analogy is quite fitting!
You would think a CEO with a product that caters to developers would know that everyone was going to clone the repo and check his work. He just squandered a whole lot of credibility.
> He just squandered a whole lot of credibility.
I've yet to see anyone in this space be negatively impacted by their outlandish claims.
They release a new model or add extra sub agents and the slate is wiped clean.
His target reader is management, not developers.
Management already doesn't trust developers in any way. Why would they believe you, who are clearly just trying to save your job, over a big company who clearly is the future!
Or do you trust your management to make the right decision?
Fake until you make it
If I was to spend a trillion tokens on a barely working browser I would have started with the source code of Sciter [0] instead. I really like the premise of an electron alternative that compiles to a 5MB binary, with a custom data store based on DyBASE [1] built into the front end javascript so you can just persist any object you create. I was ready to build software on top of it but couldn't get the basic windows tutorial to work.
anyone remember finding the internet explorer control in windows forms, placing it down, adding some buttons, and telling people you made your own web browser? Maybe this exercise is eternal just in different forms
If we have been complaining about bloat before, the amount of bloat we are going to witness in the future is unfathomable. How can anyone be proud of a claim like "It's 3M+ lines of code across thousands of files." _especially_ when a lot of this code is relying on external dependencies? Less code is almost always better, not more!
I'm also getting really tired of claims like "we are X% more productive with AI now!" (that I'm hearing day in and out at work and LinkedIn of course). Didn't we, as an industry, agree that we _didn't_ know how to measure productivity? Why is everyone believing all of these sudden metrics that try to claim otherwise?
Look, I'm not against AI. I'm finding it quite valuable for certain scenarios -- but in a constrained environment and with very clear guidance. Letting it loose with coding is not one of them, and the hype is dangerous by how much it's being believed.
I mostly agree with you but I AM super productive with AI. I'm working on a side-project and have built in 2-3 months what my quite productive team of 3-4 people would take 4-6 months to build in 2016. And I'm not talking to generative slop but real production grade code that I have reviewed+approved or manually refactored before merging. Like you I'm not impressed by these toy projects but the productivity gain is very real. At least has been for me.
I don't disregard what you are saying and believe that being more productive with sufficient quality is _possible_.
But how do you measure it? All the metrics I see being chased (metrics that were never accepted as productivity measurements before) can be gamed with slop, and so slop is what we'll get.
> I'd just cloned a copy of Chromium myself, and for all that time and money, independent developers who cloned the repo reported that the codebase is very far from a functional browser. Recent commits do not compile cleanly, GitHub Actions runs on main are failing, and reviewers could not find a single recent commit that was built without errors.
Significant typo I assume?
When AI does `x`, check with people familiar with `x`.
Thats like the entire hype cycle: LLM builders see a bunch of hyper specific lanuage in fields they're not experts in and thing 'wow, AI is really smart!'
Every single high-profile story that shows up on the feeds about how LLMs are just about there and coders are doomed, if you actually read them and are a programmer, seems like a story about how LLMs are bad and generate trash code that rarely even looks superficially good and definitely doesn't work.
There was a story going around about LLMs making minesweeper clones, and they were all terrible in extremely dumb ways. The headline wasn't obvious, so I thought the take that people were getting from it is that AI is making the same dumb mistakes that it was making a year ago. Nope. It was people ranting about how coders are going to be out of a job next week. Meanwhile, none of them can do a minesweeper clone with like 50 working examples online, maybe 8 things you have to do right to be perfect, and 9000 articles about minesweeper and even mathematical papers about minesweeper to make everything about the game and its purpose perfectly clear. And then AI generates buttons that don't do anything and timers that don't stop.
Was that a while ago? Minesweeper's pretty easy.
Claude Opus 4.5: "Build minesweeper as an artifact, don't use react"
(Then "Fix it to work on mobile where right click isn’t a thing")
Play it here: https://tools.simonwillison.net/minesweeper
Transcript here: https://claude.ai/share/2d351b62-a829-4d81-b65d-8f3b987fba23
Do you do anything to make sure you are getting the genuine experience as the regular user of these tools?
Unfortunately management is the audience for AI fluff stories. Management then fires a huge percentage of their staff on the promise AI will write everything.
It doesn't matter to the people that were fired that the AI isn't as capable as promised. They're still job hunting in a shitty job market. When management does eventually figure out the AI underperforms they'll hire back staff at a fraction of the salary.
So executives and management look great no matter what and everyone else gets screwed.
How many millions of dollars did this even cost anyway?
Our modern economy is nearly entirely built on useless bullshit, this is just what it looks like when the ouroboros starts devouring its own tail. It doesn't matter that the product doesn't work; the hype is the product. In our collective nihilism, we have productized faith itself.
I mean, maybe they should have started simple and slowly iterated.
project 1: build a text based browser using ratatui and quickjs.
project 2: base it on project 1. convert to gui, pages should render pure html.
project 3: acid1 compliance. Use constraint based programming to output final render, no animation support.
People thinking this does not matter just because the code is awful, it used dependencies, or whatever, are missing the point.
6 months ago with previous models this was absolutely impossible. One of the biggest limitations of LLMs is their difficulty with long tasks. This has been steadily improving and this experiment was just another milestone. It will be interesting a year from now to test how much better new models fare at this task.
1% import open-source-incumbent 99% misdirection slop
grifters gonna grift
AI will never be able to create a browser, just as AI was never able to defeat a chess grandmaster.
Yeah that's one of the real takeaways from this. This will improve over time. People seem to get so put off by hype that they forget there can be things of real significance underneath it. You could make a long list of what's amazing and promising about this "implement a browser" task, despite all its shortcomings.
So grifting is okay, just because someday the grift might come true?
Meh. What do you think the grift is here exactly? No one’s trying to sell the newly minted source code to a web browser.
If this is the first time you’ve encountered a hype bubble, it’s a good opportunity to learn so that you can navigate the next one more easily.
Do those "higher-ups" or potential investors have any agency?
This reminds me of a US District Court judge's ruling about Tucker Carlson on Fox News: "Any reasonable viewer 'arrives with an appropriate amount of skepticism' about the statements".
Sure, if you're talking about rubes who just got off the bus in the big city, then perhaps there's a point buried somewhere deep in the pile you're pushing. But is that who you think the HN audience is? Admittedly, talking to you, I can't rule it out.
Amusingly, by (dictionary) definition you're wrong, because "grift" means "engage in petty or small-scale swindling" (Merriam-Webster), but you're alluding to a much larger-scale phenomenon.
But it's tinfoil-hattish to claim that projects like this and the PR about it is part of a "grift". You're squinting hard to be able to see what you want to see.
That's probably true but what is the point of misrepresenting it today? It's a sick society where that is a net benefit to a corp
FTA:
> tools like Cursor can be genuinely helpful as glorified autocomplete and refactoring assistants
That suggests a fairly strong anti-AI bias by the author. Anyone who thinks that this is all AI coding tools are today is not actually using them seriously.
That's not to say that this exercise wasn't overhyped, but a more useful, less biased article that's not trying to push an agenda would look at what went right, as well as what went wrong.
No, it suggests the sarcasm that is the Registers in house style. See the page tagline.... "Biting the hand that feeds IT"
That’s a dubious assumption. In the context of the rest of this article, it doesn’t seem like sarcasm.
In blacksmithing there's the concept of an "anvil shaped object". That is, something that looks like an anvil but is hollow or made of ceramic or something. It might stand up to tapping on for making jewelry or something but should never be worked like a real anvil for fear of hurting someone or wrecking the thing you're working on when it breaks.
I feel like a lot of the AI articles and experiments like this one are producing "app shaped objects" that look okay for making content (and indeed are fine for making earrings) but fall apart when pounded on by the real world.
Plus we can suspect a tremendous amount of astroturfing on this topic. When you’re spending billions on the tech, a few millions (if it even is that much) for “creative marketing” are really nothing.
That was from a conversation here on Hacker News the other day: https://news.ycombinator.com/item?id=46624541#46709191
I wish your recent interview had pushed much harder on this. It came across as politely not wanting to bring up how poorly this really went, even for what the engineer intended.
They were making claims without the level of rigor to back them up. There was an opportunity to learn some difficult lessons, but—and I don’t think this was your intention—it came across to me as kind of access journalism; not wanting to step on toes while they get their marketing in.
pushing would definitely stop the supply of interviews/freebies/speaking engagements
The person you're responding to isn't a journalist, they're a mouthpiece. Pushing means they don't get these interviews anymore.
The quality of whatever they put out as a result of it is yours to take into consideration.
Why would he push back? His whole schtick is to sell only AI hype. He’s not going to hurt his revenue.
If I sell only AI hype why do I keep telling people that many systems built on top of LLMs are inherently insecure? https://simonwillison.net/2025/Jun/16/the-lethal-trifecta/
On the contrary, we get to read hundreds of his comments explaining how the LLM in anecdote X didn't fail, it was the developer's fault and they should know better than to blame the LLM.
I only know this because on occasion I'll notice there was a comment from them (I only check the name of the user if it's a hot take) and I ctrl-F their username to see 20-70 matches on the same thread. Exactly 0 of those comments present the idea that LLMs are seriously flawed in programming environments regardless of who's in the driver seat. It always goes back to operator error and "just you watch, in the next 3 months or years...".
I dunno, I manage LLM implementation consulting teams and I will tell you to your face that LLMs are unequivocally shit for the majority of use cases. It's not hard to directly criticize the tech without hiding behind deflections or euphemisms.
I literally see their posts every (other) day, and its always glazing something that doesn't fully work (but is kind of cool at a glance) or is really just hyped beyond belief.
Comments usually point out the issues or more grounded reality.
BTW I'm bullish on AI, going through 100s of millions of tokens per month.
the bare minimum of criticism to allow independence to be claimed?
I actually don't think this is true, and certainly of people who cover LLMs Simon Willison is one of the more critical and measured people.
I just don't think that's the case.
The claims they made really weren't that extreme. In the blog post they said:
> To test this system, we pointed it at an ambitious goal: building a web browser from scratch. The agents ran for close to a week, writing over 1 million lines of code across 1,000 files. You can explore the source code on GitHub.
> Despite the codebase size, new agents can still understand it and make meaningful progress. Hundreds of workers run concurrently, pushing to the same branch with minimal conflicts.
That's all true.
On Twitter their CEO said:
> We built a browser with GPT-5.2 in Cursor. It ran uninterrupted for one week.
> It's 3M+ lines of code across thousands of files. The rendering engine is from-scratch in Rust with HTML parsing, CSS cascade, layout, text shaping, paint, and a custom JS VM.
> It kind of works! It still has issues and is of course very far from Webkit/Chromium parity, but we were astonished that simple websites render quickly and largely correctly.
That's mostly accurate too, especially the "it kind of works" bit. You can take exception to "from-scratch" claim if you like. It's a tweet, the lack of nuance isn't particularly surprising.
In the overall genre of CEO's over-hyping their company's achievements this is a pretty weak example.
I think the people making out that Cursor massively and dishonestly over-hyped this are arguing with a straw man version of what the company representatives actually said.
> That's mostly accurate too, especially the "it kind of works" bit. You can take exception to "from-scratch" claim if you like. It's a tweet, the lack of nuance isn't particularly surprising.
> In the overall genre of CEO's over-hyping their company's achievements this is a pretty weak example
I kind of agree, but kind of not. The tweet isn't too bad when read from an experienced engineer perspective, but if we're being real then the target audience was probably meant to be technically clueless investors who don't and can't understand the nuance.
Did you read the comment that started this thread? Let me repeat that, ICYMI:
> "So I agree this isn't just wiring up of dependencies, and neither is it copied from existing implementations: it's a uniquely bad design that could never support anything resembling a real-world web engine."
It didn't use Servo, and it wasn't just calling dependencies. It was terribly slow and stupid, but your comment is more of a mischaracterization than anything the Cursor people have said.
I agree that "from scratch" is a misrepresentation.
But it was accompanied by a link to the GitHub repo, so you can hardly claim that they were deliberately hiding the truth.
> I think the people making out that Cursor massively and dishonestly over-hyped this are arguing with a straw man version of what the company representatives actually said.
It's far more dishonest to search for contrived interpretations of their statements in an attempt to frame them as "mostly accurate" when their statements are clearly misleading (and in my opinion, intentionally so).
You're giving them infinite benefit of the doubt where they deserve none, as this industry is well known for intentionally misleading statements, you're brushing off serious factual misrepresentations as simple "lack of nuance" and finally trying to discredit people who have an issue with all of this.
With all due respect, that's not the behavior of a neutral reporter but someone who's heavily invested in maintaining a certain narrative.
That Tweet that was seen by 6 million people is here: https://x.com/mntruell/status/2011562190286045552
You only quoted the first line. The full tweet includes the crucial "it kind of works" line - that's not in the follow-up tweet, it's in the original.
Here's that first tweet in full:
> We built a browser with GPT-5.2 in Cursor. It ran uninterrupted for one week.
> It's 3M+ lines of code across thousands of files. The rendering engine is from-scratch in Rust with HTML parsing, CSS cascade, layout, text shaping, paint, and a custom JS VM.
> It kind of works! It still has issues and is of course very far from Webkit/Chromium parity, but we were astonished that simple websites render quickly and largely correctly.
The second tweet, with only 225,000 views, was just the following text and a link to the GitHub repository:
> Excited to continue stress testing the boundaries of coding agents and report back on what we learn.
> Code here: https://github.com/wilsonzlin/fastrender
Which part of their CEO saying "It kind of works" are you interpreting as "trying to get people to believe that it’s a working browser"?
The reason I won't let this one go is that I genuinely believe people are being unfair to the engineer who built this, because some people will jump on ANY opportunity to "debunk" stories about AI.
I won't stand for misleading rhetoric like "it's just a Servo wrapper" when that isn't true.