Cursor's latest “browser experiment” implied success without evidence

"Borrow" is an interesting choice of word, see for example this:

    /// The quirks mode of the document.
    #[inline]
    pub fn quirks_mode(&self) -> QuirksMode {
        self.quirks_mode
    }

https://github.com/wilsonzlin/fastrender/blob/3e5bc78b075645...

And then this:

    /// The quirks mode of the document.
    pub fn quirks_mode(&self) -> QuirksMode {
        self.stylist.quirks_mode()
    }

https://github.com/servo/stylo/blob/71737ad5c8b29c143a6c992a...

It seems ChatGPT is still copying segments of code almost verbatim, although sometimes it does weird things, compare these for example:

https://github.com/wilsonzlin/fastrender/blob/3e5bc78b075645...

https://github.com/servo/stylo/blob/71737ad5c8b29c143a6c992a...

Yeah there's more to a browser than a couple of out-of-tree servo components, otherwise https://github.com/servo/servo wouldn't have 300k+ lines of Rust code, 400k+ if you count comments and blanks (I cloned the repo, nuked the tests directory, then did a count).

Plus that linked comment doesn't even say it's "nothing more than a non-functional wrapper for Servo". It disputes the "from scratch" claim.

Most people aren't interested in a nuanced take though. Someone said something plausible sounding and was voted to top by other people? Good enough for me, have another vote. Then twist and exaggerate a little and post it to another comment section. Get more votes. Rinse and repeat.

In your hurry to defend this slop you didn't do your due diligence. You know that 1 million LoC JS VM? Yeah, it isn't actually running - https://imgur.com/fqGLjSA. And you can tell this is actually the case because it's been brought up a few times on this thread and that guy has ducked around it.

Just for context, this was the original claim by Cursor's CEO on Twitter:

> 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.

https://xcancel.com/mntruell/status/2011562190286045552#m

Could you somewhere make clear exactly how much of the code was "autonomously" built vs how much was steered by humans? Because at this point it's clear that it wasn't 100% autonomous as originally claimed, but right now it's not clear if this was just the work of an engineer running Cursor vs "autonomously organised a fleet of agents".

You're claiming that the JS VM was implemented. Is it actually running? Because this screenshot shows that the ACID3 benchmark is requesting that you enable JavaScript (https://imgur.com/fqGLjSA). Why don't you upload a video of you loading this page?

Your slop is worthless except to convince gullible investors to give you more money.

Does any of it actually work? Can you build that JS VM separately and run serious JS on it? That would be an accomplishment.

Looking at the comments and claims (I've not got the time to review a large code base just to check this claim) I get an impression _something_ was created, but none of it actually builds and no one knows what is the actual plan.

Did your process not involve recursive planning stages (these ALWAYS have big architectural error and gotchas in my experience, unless you're doing a small toy project or something the AI has seen thousands of already).

I find agents doing pretty well once you have a human correct their bad assumptions and architectural errors. But this assumes the human has absolute understanding of what is being done down to the tiniest component. There will be errors agents left to their own will discover at the very end after spending dozens of millions of tokens, then they will try the next idea they hallucinated, spend another few dozen million tokens and so on. Perhaps after 10 iterations like this they may arrive at something fine or more likely they will descent into hallucinations hell.

This is what happens when one of :the complexity, the size, or it being novel enough (often a mix of all 3) of the task exceed the capability of the agents.

The true way to success is the way of a human-ai hybrid, but you absolutely need a human that knows their stuff.

Let me give you a small example from systems field. The other day I wanted to design an AI observability system with the following spec: - use existing OS components, none or as little code as possible - ideally runs on stateless pods on an air gapped k3s cluster (preferably uses one of existing DBs, but clickhouse acceptable) - able to proxy openai, anthropic(both api and clause max), google(vercel+gemini), deepinfra, openrouter including client auth (so it is completely transparent to the client) - reconstruct streaming responses, recognises tool calls, reasoning content, nice to have ability to define own session/conversation recognition rules

I used gemini 3 and opus 4.5 for the initial planning/comparison of os projects that could be useful. Both converged on helicone as being supposedly the best. Until towards the very end of implementation it was found helicone has pretty much zero docs for properly setting up self hosted platform, it tries redirecting to their Web page for auth and agents immediately went into rewriting parts of the source attempting to write their own auth/fixing imaginary bugs that were really miscondiguration.

Then another product was recommended (I forgot which), there upon very detailed questioning, requesting re-confirmations of actual configs for multiple features that were supposedly supported it turned out it didn't pass through auth for clause max.

Eventually I chose litellm+langfuse (that was turned down initially in favour of helicone) and I needed to make few small code changes so Claude max auth could be read, additional headers could be passed through and within a single endpoint it could send Claude telemetry as pure pass through and real llm api through it's "models" engine (so it recognised tool calls and so on).

I cannot make these two statements true at the same time in my head:

> Briefly, the project implemented substantial components, including a JS VM

and from the linked reply:

> vendor/ecma-rs as part of the browser, which is a copy of my personal JS parser project vendored to make it easier to commit to.

If it's using a copy of your personal JS parser that you decided it should use, then it didn't implement it "autonomously". The references you're linking don't summarize to the brief you've provided.

What the fuck is going on?

Did you actually review these implementations and compare them to Servo (and WebKit)? Can you point to a specific part or component that was fully created by the LLM but doesn't clearly resemble anything in existing browser engines?

I think it's fair enough to consider porting a subset of rewriting, in which case there are several successful experiments out there:

- JustHTML [1], which in practice [2] is a port of html5ever [3] to Python.

- justjshtml, which is a port of JustHTML to JavaScript :D [4].

- MiniJinja [5] was recently ported to Go [6].

All three projects have one thing in common: comprehensive test suites which were used to guardrail and guide AI.

References:

1. https://github.com/EmilStenstrom/justhtml

2. https://friendlybit.com/python/writing-justhtml-with-coding-...

3. https://github.com/servo/html5ever

4. https://simonwillison.net/2025/Dec/15/porting-justhtml/

5. https://github.com/mitsuhiko/minijinja

6. https://lucumr.pocoo.org/2026/1/14/minijinja-go-port/

Not me personally, but a GitHub user wrote a replacement for Go's regexp library that was "up to 3-3000x+ faster than stdlib": https://github.com/coregx/coregex ... at first I was impressed, so started testing it and reporting bugs, but as soon as I ran my own benchmarks, it all fell apart (https://github.com/coregx/coregex/issues/29). After some mostly-bot updates, that issue was closed. But someone else opened a very similar one recently (https://github.com/coregx/coregex/issues/79) -- same deal, "actually, it's slower than the stdlib in my tests". Basically AI slop with poor tests, poor benchmarks, and way oversold. How he's positioning these projects is the problematic bit, I reckon, not the use of AI.

Same user did a similar thing by creating an AWK interpreter written in Go using LLMs: https://github.com/kolkov/uawk -- as the creator of (I think?) the only AWK interpreter written in Go (https://github.com/benhoyt/goawk), I was curious. It turns out that if there's only one item in the training data (GoAWK), AI likes to copy and paste freely from the original. But again, it's poorly tested and poorly benchmarked.

I just don't see how one can get quality like this, without being realistic about code review, testing, and benchmarking.

I used one of the assistants to reverse and rewrite a browser-hosted JS game-like app to desktop Rust. It required a lot of steering but it was pretty useful.

https://x.com/CanadaHonk/status/2011612084719796272 as well.

I went through the motions. There are various points in the repo history where compilation is possible, but it's obscure. They got it to compile and operate prior to the article, but several of the PRs since that point broke everything, and this guy went through the effort of fixing it. I'm pretty sure you can just identify the last working commit and pull the version from there, but working out when looks like a big pain in the butt for a proof of concept.

A lie like this seems like it should be considered fraud

Haha. True, CI success was not part of PR accept criteria at any point.

If you view the PRs, they bundle multiple fixes together, at least according to the commit messages. The next hurdle will be to guardrail agents so that they only implement one task and don't cheat by modifying the CI piepeline

We use claude code a lot for updating systems to a newer minor/major version. We have our own 'base' framework for clients which is a, by now, very large codebase that does 'everything you can possibly need'; so not only auth, but payments, billing, support tickets, email workflows, email wysiwyg editing, landing page editor, blogging, cms, AI /agent workflows etc etc (across our client base, we collect features that are 'generic' enough and create those in the base). It has many updates for the product lead working on it (a senior using Claude code) but we cannot just update our clients (whose versions are sometimes extremely customised/diverging) at the same pace; some do not want updates outside security, some want them once a year etc. In this case AI has been really a productivity booster; our framework always was quite fast moving before AI too when we had 3.5 FTE (client teams are generally much larger, especially the first years) on it but then merging, that to mean; including the new features and improvements in the client version that are in the new framework version without breaking/removing changes on the client side, was a very painful process taking a lot of time and at at least 2 people for an extended period of time; one from the client team, one from the framework team. With CC it is much less painful: it will merge them (it is not allowed, by hooks, to touch the tests), it will run the client tests and the new framework tests and report the difference. That difference is evaluated usually by someone from the client team who will then merge and fix the tests (mostly manually) to reflect the new reality and test the system manually. Claude misses things (especially if functionalities are very similar but not exactly the same, it cannot really pick which to take so it does nothing usually) but the biggest bulk/work is done quickly and usually without causing issues.

that’s not guaranteed to work. Other parts of the CodeBase that didn’t conflict could depend on the discarded code.

So, AI agent battle royale

Somebody managed to get it to compile https://x.com/CanadaHonk/status/2011612084719796272

But apparently "some pages take a literal minute to load"

Maybe they just asked an AI to create an image of a rendered webpage?

> Can you help me understand what's "conservative" about that?

It's the gaslighting.

> Yeah, seems latest commit does let `cargo check` successfully run. I'm gonna write an update blog post once they've made their statement, because I'm guessing they're about to say something.

> Sometime fishy is happening in their `git log`, it doesn't seem like it was the agents who "autonomously" actually made things compile in the end. Notice the git username and email addresses switching around, even a commit made inside a EC2 instance managed to get in there: https://gist.github.com/embedding-shapes/d09225180ea3236f180...

Gonna need to look closer into it when I have time, but seems they manually patched it up in the end, so the original claim still doesn't stand :/

Basically, fraud. Low-level fraud, but still fraud.

“Lying is just the reality of the world” is a cop-out

Don’t give them, or anyone, a free pass for bad behavior.

Fraud, lies, and corruption are so often the reality of the world right now because people keep getting away with it. The moment they're commonly and meaningfully held accountable for lying to the public we'll start seeing it happen less often. This isn't something that can't be improved, it just takes enough people willing to work together to do something about it.

Upon deeper inspection? Someone checked the Cargo file and proclaimed it was just Servo and QuickJS glued together without actually bothering to look if these dependencies are even being used.

In reality while project does indeed have Servo in its dependencies it only uses it for HTML tokenization, CSS selector matching and some low level structures. Javascript parsing and execution, DOM implementation & Layout engine was written from scratch with only one exception - Flexbox and Grid layouts are implemented using Taffy - a Rust layout library.

So while “from scratch” is debatable it is still immensely impressive to be that AI was able to produce something that even just “kinda works” at this scale.

Thanks for the feedback. I agree that for some parts that use dependencies, the agent could have implemented them itself. I've begun the process of removing many of these and developing them within the project alongside the browser. A reasonable goal for "from scratch" may be "if other major browsers use a dependency, it's fine to do so too". For example: OpenSSL, libpng, HarfBuzz, Skia.

I'd push back on the idea that all the agents did was glue dependencies together — the JS VM, DOM, CSS cascade, inline/block/table layouts, paint systems, text pipeline, chrome, and more are all being developed by agents as part of this project. There are real complex systems being engineered towards the goal of a browser engine, even if not fully there yet.

The point is to learn how to make very large codebases that don't compile? Why do you need tests and specs if it's not going to even run, much less run correctly?

...but it didn't develop ways of doing that did it?

Any idiot can have cursor run for 2 weeks and produce a pile of crap that doesn't compile.

You know the brilliant insight they came out with?

> A surprising amount of the system's behavior comes down to how we prompt the agents. Getting them to coordinate well, avoid pathological behaviors, and maintain focus over long periods required extensive experimentation. The harness and models matter, but the prompts matter more.

i.e. It's kind of hard and we didn't really come up with a better solution than 'make sure you write good prompts'.

Wellll, geeeeeeeee! Thanks for that insight guys!

Come on. This was complete BS. Planners and workers. Cool. Details? Any details? Annnnnnnyyyyy way to replicate it? What sort of prompts did you use? How did you solve the pathalogical behaviours?

Nope. The vagueness in this post... it's not an experiment. It's just fund raising hype.

If it loads pages, then it clearly works. Nobody claims it's a practical, competitive browser.

Noticed that as well - I think it was “manual”

Literally happened at work. Breathless thread of people saying how insane it was and then we got to link this and it immediately 180-ed and everyone was like “holy shit that’s messed up”

It's a great post, I will use it for the same. Thank you.

> They can't be as dumb as thinking no one would've noticed?!

With over 20 years of experience as an adult, and more years of noticing dumb mistakes of adults when I was a teen, I can absolutely assure you that even before LLMs were blowing smoke up their user's backsides and flattering their user's intelligence, plenty of people are dumb enough to make mistakes like this without noticing anything was wrong.

For example, I'm currently dealing with customer support people that can't seem to handle two simultaneous requests or read the documents they send me, even after being ordered to pay compensation by an Ombudsman. This kind of person can, of course, already be replaced by an LLM.

I mean... Cursor is the CEO's first non-internship job. And it was a VSCode Extension that caught fire atop the largest technological groundswell in a few decades.

The default assumption should be that this is a moderately bright, very inexperienced person who has been put way out over his skis.

> Why would they think it's a great idea to claim they implemented CSS and JS from scratch when the first thing any programmer would do is to look at the code and immediately find out that they're just using libraries for all of that?!

Programmers were not the target audience for this announcement. I don’t 100% know who was, but you can kind of guess that it was a mix of: VC types for funding, other CEOs for clout, AI influencers to hype Cursor.

Over-hyping a broken demo for funding is a tale as old as time.

That there’s a bit of a fuck-you to us pleb programmers is probably a bonus.

I don't think he intentionally lied. He just didn't know how to check that and AI wrote

   - [tick mark emoji] implemented CSS and JS rendering from scratch - **no dependencies**.

I'm actually impressed by their ignorance. I could never sleep at night knowing my product is built on such brazen lies.

Bullshitting and fleecing investors is a skill that needs to be nurtured and perfected over the years.

I wonder how long this can go on.

Who is the dumb money here? Are VCs fleecing "stupid" pension funds until they go under?

Or is it symptom of a larger grifting economy in the US where even the president sells vaporware, and people are just emulating him trying to get a piece of the cake?

> They can't be as dumb as thinking no one would've noticed?!

Maybe they're just hoping that there's an investor out there who is exactly that dumb.

> I do want to briefly note that the JS VM is custom and not QuickJS

It's hard to verify because your project didn't actually compile. But now that you've fixed the compilation manually, can you demonstrate the javascript actually executing? Some of the people who got the slop compiling claimed credibly that it isn't executing any JavaScript.

You merely have to compile your code, run the binary and open this page - http://acid3.acidtests.org. Feel free to post a video of yourself doing this. Try to avoid the embellishment that has characterised this effort so far.

That is because I've noticed the AI just edits the version management files (package.json, cargo.toml, etc) directly instead of using the build tool (npm add, cargo add), so it always hallucinates a random old version that's found in its training set. I explicitly have to tell the AI to use the build tool whenever I use AI.

I thought they'd plagiarise, not import. Importing servo's code would make it obvious because it's so easy to look at their dependencies file. And yet ... they did. I really think they thought no one would check?

You know, a good test would be to tell it to write a browser using a custom programming language, or at least some language for which there are no web browsers written.

It's using layout code from my library (Taffy) for Flexbox and CSS Grid. Servo uses Taffy for CSS Grid, and another open source engine that I work on (Blitz) uses it for Flexbox, CSS Grid, Block and float layout.

The older block/inline layout modes seem to be custom code that looks to me similar but not exactly the same as Servo code. But I haven't compared this closely.

I would note that the AI does not seem to have matched either Servo or Blitz in terms of layout: both can layout Google.com better than the posted screenshot.

It seemingly did but after I saw it define a VerticalAlign twice in different files[1][2][3] I concluded that it's probably not coherent enough to waste time on checking the correctness.

Would be interesting if someone who has managed to run it tries it on some actually complicated text layout edge cases (like RTL breaking that splits a ligature necessitating re-shaping, also add some right-padding in there to spice things up).

[1] https://github.com/wilsonzlin/fastrender/blob/main/src/layou...

[2] https://github.com/wilsonzlin/fastrender/blob/main/src/layou...

[3] Neither being the right place for defining a struct that should go into computed style imo.

Cursor didn't write anything, they used ChatGPT 5.2.

It looks like there are two JS backends: quickjs and vm-js (vendor/ecma-rs/vm-js), based on a brief skim of the code. There is some logic to select between the two. I have no idea if either or both of them work.

The whole point of Servo is its not impossible to use like Chromium.

We use mcp at work. Due to some typo the model ran absolutely random queries on our database most of the cases. We had initially kept ot open ended but after that, we wrote custom tools that took an input, gave an output and that was strictly mentioned in the prompt. Only then did it work fine.

Eight hours to review! Girlie how big are these PRs?

I can’t imagine saying, “ah, only six hours of heads down time to review this. That’s reasonable.”

A combination of peer reviewed architecture documentation and incremental PRs should prevent anything taking nearly 8 hours of review.

I've watched them today work in the new repo - https://github.com/wilson-anysphere/fastrender/tree/main , adding another 50k lines trying to optimize scroll/rendering performance (spoiler: not really)

At this point, its 1.5mlocs without the vendored crates (so basically excluding the js engine etc). If you compare that to Servo/Ladybird which are 300k locs each and actually happen to work, agents do love slinging slop.

"definitively capable tools when used in certain ways". This sounds like "if it doesn't work for you is because you don't use in the right way" imo.

Reminds me of SAAP/Salesforce.

> Codex and Claude Code are definitively capable tools when used in certain ways.

They definitely can make some things better and you can do somethings faster, but all the efficiency is gonna get sucked up by companies trying to drop more slop.

$200/month tool (real cost could be $1000/month), but you have to babysit it.

> generate a bunch of code that seems mostly correct and then gradually tweak it until it's closer and closer to compiling/working

The diffusion model of software engineering

Obviously, it has to eventually build and run if there’s to be any point to it, but is it necessary that every, or even any, step along the way builds and runs? I imagine some sort of iterative set-up where one component generates code, more or less "intelligently", and others check it against the C, HTML, JavaScript, CSS and what-have-you specs, and the whole thing iterates until all the checking components are happy. The components can’t be completely separate, of course, they’d have to be more or less intermingled or convergence would be very slow (like when lcamtuf had his fuzzer generate a JPEG out of an empty file), but isn’t that basically what (large) neural networks are; tangled messes of interconnected functions that do things in ways too complicated for anyone to bother figuring out?

Hilarious thing to say when we've just had some of the biggest leaps ever with Gemini 3 and Opus 4.5.

The greatest grift of all time.

I don’t mean the tech itself—-which is kind of useful. I mean the 99% of the value inflation of a kind of useful tool (if you know what you’re doing).

Just one more new model bro the next one is AGI bro just give me a trillion dollars and I’ll build the datacenters and everything will be perfect bro I promise bro please

The masters of mankind are yearning to replace expensive tech workers with this. With agentic versions of LLMs we are at a point now where they can (and should) certainly try and create a more hilarious world

It's absolutely absurd.

Probably, but this is one of the few cases where instead of being told how amazing some AI tool is we are shown just what it can do.

> but I'm also a developer with decades of experience, so I'm not gonna claim it'll help non-programmers to build software, or whatever. They're tools, not solutions in themselves.

Also with decades experience, I'd say that it depends how big the non-programmer is dreaming:

To agree with you: A well-meaning friend sent an entrepreneur my direction, whose idea was "Uber for aircraft". I tried to figure out exactly what they meant, ending the conversation when I realised all answers were rephrasing of that vague three words pitch, that they didn't really know what they wanted to do in any specific enumerable sense.

LLMs can't solve the problem when even the person asking doesn't know what they want.

But on the other end the scale, I've been asked to give an estimate for an app which, in its entirety, would've been one day's work even with the QA and acceptance testing and going through the Apple App Store upload process. Like, I kept asking if there was any other hidden complexity, and nope, the entire pitch was what you'd give as a pre-interview code-challenge.

An LLM would've spat out the solution to that in less time than I spent with the people who'd asked me to estimate it.

Take a look at this thread regarding the original claim: https://news.ycombinator.com/item?id=46624541

The top comment is indeed baseless hype without a hint of skepticism.

You do realize that AI can already today write fairly complex software autonomously, don't you? It's not as if I haven't tested that. It works quite well for certain tasks and with certain programming languages.

Anyone who knows history knows that people initially tend to underestimate the impact of technologies, yet few people learn something from that lesson.

I think for the point of the article, it appeared to, at some point, render homepages for select well known sites. I certainly did not expect this to be a serious browser, with any reliability or legs. I don’t think that is dishonest.

Quality absolutely matters, but it's hyper context dependent.

Not everything needs to, or should have the same quality standards applied to them. For the purposes of the Cursor post, it doesn't bother me that most of the commits produced failed builds. I assume, from their post, that at some points, it was capable of building, and rendering the pages shown in the video on the post. That alone, is the thing that I think is interesting.

Would I use this browser? Absolutely not. Do I trust the code? Not a chance in hell. Is that the point? No.

> oblivious to the shore in front of them rapidly being gobbled up by the sea

Am I misunderstanding this metaphor? Tsunamis pull the sea back before making landfall.