I still wouldn't give to any claw access to my mail accounts, but it is a step in the good direction.

I love how NanoClaw is aggregating the effort of making personal assistants more secure.

Good job!

If I use a remote MCP or CLI that relies on network calls, and I give it in the hands of my coding assistant, wouldn't be too easy to inject prompts and exfiltrate data from my machine?

At least MCP don't have direct access to my machine, but CLIs do.

The CLI are executed by the coding assistants in the project directory, which means that they can get implicit information from there (e.g. git branch and commit)

With an MCP you would need a prepare step to gather that, making things slower.

I do that manually with my plants twice a week, they have flowers almost all year, but it's a chore to bring them out, flood them, make them drain and bring them back home.

Also my wife always yells at me because I always wet the floor in the process.

Just to clarify, I meant to share admiration toward a fellow engineer.

I do not think that age implies any hard assumption, usually brings cultural diversity which is good.

In my experience performance of LLMs can be surprisingly good on things that are not mainstream, like database engineering, and surprisingly bad at mainstream categories approached in an unconventional way.

That said, I'm amazed that you have 50 years of experience and still able to have the mental flexibility to adapt to new development paradigms.

As you imply, this stuff isn't simple to pick up, and is completely different on how we have done our job without AI.

If it's not something very common LLMs could end up generating random code.

Also if you work on something performance critical, you can get inspiration from LLMs, but they often don't write fast code.

If nailed this is going to be interesting.

All the other solutions I've been sumbling around are either very hard to customize or too limited.

Docker sandboxing is kinda nice, but not enough to trust an LLM even with my messaging accounts.

I wonder how much of the Rollup bundling magic has been ported to Rolldown.

One thing that always made this kind of switch to Rust has always been that Rollup has become so sophisticated that's hard to replace with something new.

It's true that the more you are afraid of expressing yourself, the worse your "performance" is going to be.

On general work level it's different.

There the trust needs to be balanced.

People should feel free to express themselves, but also that they need to meet some certain standards of quality at work.

Otherwise we may tend to relax too much and become sloppy in certain areas.

We build systems that can fail in unpredictable ways, and without knowing the system we built deeply is hard to understand what's going on.

Very well done Node team!

An interesting tool that matches the requirements mentioned in the article is Evolu[0]

It's a sync engine with e2e encryption based on SQLite.

The local-first landscape is quite wide now, and there is probably a solution ready for all kind of needs[1]

Building a sync engine can be a nice learning experience, but for production software it's better to pick something that has already faced and resolved all the weird edge cases you get when building a sync engine and persistent storage on the browser.

[0] https://www.evolu.dev/

[1] https://www.localfirst.fm/landscape

Quite simple to start, and a nice system to add some scripting and styles without the requirement of bringing in a framework.