Hey HN, Electrobun creator here. Thanks for posting this.

We just hit v1 - stable which means I've locked down the architecture. If you run into any bugs or need specific apis that you miss from Electron or Tauri please open Github issues and I'll prioritize them. I shipped 50,000 lines of code changes stabilizing and polishing electrobun for v1 over the last month.

Here's a video demo of Colab (also open source) (a hybrid web browser + code editor + PTY terminal) that is built with Electrobun https://www.youtube.com/watch?v=WWTCqGmE86w

Electrobun uses the system webview by default, but a lot of the hello worlds feature the bundleCEF option. Because Electrobun is architected to be webview agnostic when servo and ladybird are ready they should be drop-in alternatives.

Electrobun apps also auto generate a zstd self-extraction wrapper and patch files with every release, so your initial download will be much smaller than if you'd used zip and your updates will be as small as 14KB so you can ship as often as you like without you or your users paying the bandwidth tax.

thank you for building electrobun!!

Electrobun is now v1 stable. Ship full cross platform desktop apps in a few MB, ship often with diff updates as small as 14KB.

Fun marketing experiment, but you basically implemented ralph wiggum in the cloud.

Claude code locally in a vm and/or with work trees will 1 shot far better without burning cloud infra cash.

I’d bet this ends up wasting more money and time than it’s worth in practice.

Are you kidding me? I heard there’s a whole entire planet of Mercury and it’s right next to the biggest fusion reactor in our solar system.

We just have to figure out how to nudge Mercury into the Sun… cheaply.

You make some very good points but I would argue that many if not all the people you observe “without introspection” have enough to know they’re getting dummer but they don’t care because they never liked the art of writing code itself or problem solving they just liked getting a paycheck and are relieved that they can still have output their managers don’t fire them over with far less effort.

They see the same thing as you but are overjoyed to power down their brain and spend more time thinking about their personal hobbies and sports and 90 day fiance instead of real problem solving or code.

I installed claude code (an agentic ai that runs on your machine and can browse and edit code, run the build, and use unix commands)

This has largely taken me out of the loop. I give it detailed task like I would a junior engineer, and we discuss approaches and align on direction, priorities, and goals, and it then goes off for literally hours iterating on the code.

I have done about 3 months worth of extremely complex engineering work in about a week since I started doing this.

It is a step change from trying to use the chat interface and copy/pasting snippets.

Once it’s going it writes code like a staff engineer.

There are some obscure bugs it can run into that it needs my 20 years of experience to unblock or unwind when it goes down a rabbit hole.

But it has accelerated my development 500x and while it’s iterating I’m not filling my mind with code and syntax and so on, I’m more like a tech lead or manager now. I’m in another room playing with my dog.

This.

I have started testing Copilot for fun, my wife needs a web-based project that is not maintained for a while now and written in PHP.

I asked Copilot (Agent mode) to translate it to rust just for the fun of it, seeing how far it would come - I expected nothing out of it. I broke down the tasks into manageable chunks, directed it in design choices, and asked it to use some specific frameworks.

So far it wrote 40k lines of rust on its own, and keeps track of what functionality is missing compared to the original project. It was impressive seeing it iterate alone for 30m+ at a time.

I'm no programmer, more systems/cloud engineer, so a rewrite like this would have likely costed me >2 years of work and still ending up useless for all intents and purposes. I'm pretty sure that the end result won't work at first try, and I'll need to fix stuff manually or direct Copilot to fix it, but after two weeks of 1-2h iterating at night, I have 90% of something that would have required someone full time for at least a couple years.

The two things I found most valuable (also in other things, like shorter bash and python scripts):

1. Syntax boilerplate: if your task is specific enough, it normally gets it right 99.99% of the time, and my brain can look at the actual logic rather than the commas, brackets and (in python's case) spaces

2. Documentation: I spend 95% less time looking at documentation for something, I don't need to comb the entire language/package/class for the specific things, it normally gets it right, and worst case I can ask it to do a refactor with the most modern standards for specific library version X

Are you exaggerating about "literally hours"? If true, that implies you're making better use of CC than I am. For me the record is maybe 10 mins. Do you write extensive functional/technical instructions? E.g. how large is your prompt (incl. task descriptions in files the prompt refers to). Curious to know.

I have been giving it about the same amount of context as a large github/jira/whatever issue.

But i’m giving it a goal with a fairly distant milestone where it needs to hit 5-10 smaller milestones and even for advanced ai mixing the system languages I’m mixing in this large project there are build errors it powers through on its own (fixing the building, linking, or syntax, or using the apis for the versions of all the things i’m using) and there are some combinations of tech (windowing, webviews, etc.) and some architectures of things that require it to try multiple approaches to succeed.

Sometimes it will ask like “how am i doing so far should i continue”, or can you run this visual thing and report back. But there can be 30-60 mins between it doing that.

It also has to scan a lot of files and find the things it needs to find to fill its own context. Like “let me examine how you implemented that on mac and windows and come up with a solution for linux”

Other times while it’s reasoning if i notice it’s going down a rabbit hole I’ll point it out and set it in the right direction without interrupting it and when it moves onto the next thought it’ll incorporate my suggestion but it didn’t really stop or need another big prompt or goal.

There are plenty of times where I do need to step in and baby it with small goals through something tricky or obscure. But even in those cases I don’t have to write any code directly i just ask it to do xyz small change and hand it back for me to test

Maybe that’s because the AI pushers are compensating for already not being as good.

What happens when other yous start using ai. I suspect they will obv outperform you just in sheer typing speed.

I don’t agree. There’s a “muscle” you train every time you think about problems and solve them, and I say muscle because it also atrophies.

But is the muscle the part where we copy and paste from stack overflow, and now ChatGPT, or is the muscle when there's a problem and things aren't working and you have to read the code and have a deep think? Mashing together random bits of code isn't a useful muscle, debugging problems is. If it's the LLM which mashes a pile of code together for me and I only jump in when there's a problem, isn't that an argument for LLM usage, not against?

I’m building Electrobun (https://github.com/blackboardsh/electrobun)

It’s an alternative to Electron/Tauri that uses Bun.

It has a bsdiff based update mechanism that lets you ship updates as small as 4KB, a custom zstd self extractor that makes your app bundle as small as 12MB, and more.

I’m currently working on adding Windows and Linux support.

Excited for this!

sounds awesome!

I don’t want to be _that_ guy but I want this for zig instead of rust.

I’m using bun for the main process. Bun runs a zig binary which can call objc/c methods. So the “main native application thread” is technically the zig process.

Then there’s all kinds of fancy rpc between bun and zig and between bun and browser contexts.

Ah, cool, that’s essentially what I’m doing too. Rust binary does the system interactions. I’m just using a pretty simple json RPC over stdio though.