Live data from Hacker News

Scaling long-running autonomous coding

cursor.com

61–70 of 203 posts

Re: Scaling long-running autonomous coding

#61

Can a browser expert please go through the code the agent wrote (skim it), and let us know how it is. Is it comparable to ladybird, or Servo, can it ever reach that capability soon?

I'm interested in this too. I was expecting just a chromium reskin, but it does seem to be at least something more than that. https://news.ycombinator.com/item?id=46625189 claims it uses Taffy for CSS layout but the docs also claim "Taffy for flex/grid, native for tables/block/inline"

Re: Scaling long-running autonomous coding

#62

The moment all code is interacted with through agents I cease to care about code quality. The only thing that matters is the quality of the product, cost of maintenance etc. exactly the thing we measure software development orgs against. It could be handy to have these projects deployed to demonstrate their utility and efficacy? Looking at PRs of agents feels a wrong headed, like who cares if agents code is hard to r…

You should at least read the tests, to make sure they express your intent. Personally, I'm not going to take responsibility for a piece of code unless I've read every line of it and thought hard about whether it does what I think it does.

AI coding agents are still a huge force-multiplier if you take this approach, though.

Re: Scaling long-running autonomous coding

#63
post #15

This looks like extremely brittle code to my eyes. Look at https://github.com/wilsonzlin/fastrender/blob/main/crates/fa... What is `FrameState::render_placeholder`? ``` pub fn render_placeholder(&self, frame_id: FrameId) -> Result { let (width, height) = self.viewport_css; let len = (width as usize) .checked_mul(height as usize) .and_then(|px| px.checked_mul(4)) .ok_or_else(|| "viewport size overflow".to_string())?;…

I suppose brittle code is fine if you have cursor to update and fix it. Ideal really, keeps you dependent.

To be fair, that was always the case when working with external contractors. And if agentic AI companies can capture that market, then that's still a pretty massive opportunity.

Re: Scaling long-running autonomous coding

#64
The planner worker architecture works well for me. About 3 layers is the sweet spot. From prompt -> plan -> task division -> workers.

Sometimes workers will task other workers and act as a planner if the task is more complex.

It’s a good setup but it’s nothing like Claude Code.

Re: Scaling long-running autonomous coding

#65
At the same time they were doing this, I also iterated on an AI-built web browser with around 2,000 lines of code. I was heavily in the loop for it, it didn't run autonomously. You can see the current version of the source code here:

https://taonexus.com/publicfiles/jan2026/172toy-browser.py.t... (turn the sound down, it's a bit loud if you interact with the built-in Tetris clone.)

You can run it after installing the packages, "pip install requests pillow urllib3 numpy simpleaudio"

I livestreamed the latest version here 2 weeks ago, it's a ten minute video:

https://www.youtube.com/watch?v=4xdIMmrLMLo&t=45s

I'm posting from that web browser. As an easter egg, mine has a cool Tetris clone (called Pentrix) based on pieces with 5 segments, the button for this is at the upper-right.

If you have any feature suggestions for what you want in a browser, please make them here:

https://pollunit.com/polls/ahysed74t8gaktvqno100g

Re: Scaling long-running autonomous coding

#66
post #15

This looks like extremely brittle code to my eyes. Look at https://github.com/wilsonzlin/fastrender/blob/main/crates/fa... What is `FrameState::render_placeholder`? ``` pub fn render_placeholder(&self, frame_id: FrameId) -> Result { let (width, height) = self.viewport_css; let len = (width as usize) .checked_mul(height as usize) .and_then(|px| px.checked_mul(4)) .ok_or_else(|| "viewport size overflow".to_string())?;…

I suppose brittle code is fine if you have cursor to update and fix it. Ideal really, keeps you dependent.

[deleted]

Re: Scaling long-running autonomous coding

#67

Earlier quoted context omitted.

This is how we wound up with non-technical "engineering managers." Looks good to me.

I think this misses the point, see the other comments. Fully scaled agentic coding replaces managers too :) cause for celebration all around

I don't believe that. If you go fully agentic and you don't understand the output, you become the manager. You're in no better position than the pointy-haired boss from Dilbert.

Re: Scaling long-running autonomous coding

#68

Did anyone manage to run the tests from the repository itself? The code seems filled with errors and warnings, as far as I can tell none of them because of the platform I'm on (Linux). I went and looked at the Action workflow history for some pages, and seems CI been failing for a while, PRs also all been failing CI but merged. How exactly was this verified to be something to be used as an successful example, or am I…

I found the codebase very hard to navigate. Hundreds (over a thousand?) tiny files with less than 200 lines of code, in deeply nested subdirectories. I wanted to find where the JavaScript engine was, and where the DOM implementation was located, and I couldn't easily find it, even using the GitHub search feature. I'm not exactly sure what this browser implements and how.

Even their README is kind of crappy. Ideally you want installation instructions right near the top, but it's broken into multiple files. The README link that says "running + architecture" (but the file is actually called browser_ui.md???) is hard to follow. There is no explicit list of dependencies, and again no explanation of how JavaScript execution works, or how rendering works, really.

It's impressive that they got such a big project to be built by agents and to compile, but this codebase... Feels like AI slop, and you couldn't pay me to maintain it. You could try to get AI agents to maintain it, but my prediction is that past some scale, they would have a hard time figuring out their own mess. You would just be left with permanent bugs you can't easily fix.

Re: Scaling long-running autonomous coding

#69
I was excited to try it out so I downloaded the repo and ran the build. However there were 100+ compilation errors. So I checked the commit history on github and saw that for at least several pages back all recent commits had failed in the CI. It was not clear which commit I should pick to get the semi-working version advertised.

I started looking in the Cargo.toml to at least get an idea how the project was constructed. I saw there that rather than being built from scratch as the post seemed to imply that almost every core component was simply pulled in from an open source library. quickjs engine, wgpu graphics, winit windowing & input, egui for ui, html parsing, the list goes on. On twitter their CEO explicitly stated that it uses a "custom js vm" which seemed particularly misleading / untrue to me.

Integrating all of these existing components is still super impressive for these models to do autonomously, so I'm just at a loss how to feel when it does something impressive but they then feel the need to misrepresent so much. I guess I just have a lot less respect and trust for the cursor leadership, but maybe a little relief knowing that soon I may just generate my own custom cursor!

Re: Scaling long-running autonomous coding

#70

> While it might seem like a simple screenshot, building a browser from scratch is extremely difficult. > Another experiment was doing an in-place migration of Solid to React in the Cursor codebase. It took over 3 weeks with +266K/-193K edits. As we've started to test the changes, we do believe it's possible to merge this change. In my view, this post does not go into sufficient detail or nuance to warrant any seriou…

The lowest bar in agentic coding is the ability to create something which compiles successfully. Then something which runs successfully in the happy path. Then something which handles all the obvious edge cases.

By far the most useful metric is to have a live system running for a year with widespread usage that produces a lower number of bugs than that of a codebase created by humans.

Until that happens, my skeptic hat will remain firmly on my head.

Post reply on HN