Just did it, thanks again... quite new user here didn't know it's possible😅

good catch! it is indeed licensed under the MIT license. i made a mistake in the post title/description writing GPL-3.0, but the repo is correct. thanks for pointing it out!

Says MIT license on github. May want to fix that.

Contenuto

I wrote my first service worker, for a PWA application... Since then I could never write an app without. It's truly needed if you (as me) don't like useless store apps, e.g. for Android. But When you make a PWA for the Desktop taht truly makes sense !

The derived Elo is a great tool to isolate whether agent loops are actually "reasoning" or just brute-forcing the search space. It clearly proves that current agent scaling (via basic try-observe-reflect loops) quickly plateaus because it lacks the human capacity for abstract conceptual shifts and structural refactoring over long-horizon tasks. I believe the future of test-time compute in the agent era shouldn't just be about scaling trials or running more iterations; it should be about building architectures capable of hierarchical planning that can dynamically pivot their entire strategy when stuck.

Wow this is a resource! Got several older desktop and laptops to revive! Down with the programmed obsolescence!

This is the inevitable consequence of the 'cloud-telemetry-first' approach to AI developer tools. If your AI coding assistants or workflow agents are logging your terminal history, active files, or screen activity back to a centralized cloud database for 'orchestration' or 'training,' you have essentially installed corporate spyware. It doesn't matter if it's Meta, Microsoft, or a startup—a single misconfigured pipeline or data breach will expose trade secrets, API keys, and private credentials. AI agents must have hard local boundaries. Tool execution (reading files, executing shell commands, querying local databases) must happen entirely locally under a zero-knowledge architecture, and every single execution must require explicit user-consent dialogs. Sending execution telemetry back to the cloud is a massive security hazard that corporations are only beginning to realize.

The surveillance landscape has shifted dramatically since 2016. Today, we don't just have passive state surveillance tapping cables; we have massive, voluntary corporate surveillance through the centralization of AI. Millions of developers and businesses are willingly uploading their proprietary source code, database structures, and internal spreadsheets to cloud LLMs (OpenAI, Google, Microsoft). All this data is logged, parsed, and stored in central cloud databases. We are essentially building the ultimate corporate intelligence database of all private technical infrastructure, completely voluntarily. If you care about privacy today, the absolute priority should be moving towards local-first execution. If you must leverage cloud LLMs, the only safe way is to use architectures that enforce local data isolation, keeping your actual database rows and files local, and sending only empty abstract schemas to the model for reasoning

Exactly. The corporate API billing model (charging per input/output token) makes running recursive developer agent loops practically unsustainable for complex codebases.

The vendor lock-in on enterprise API tiers is going to be a massive budget black hole.

I’ve been experimenting with a different architectural approach: using a local proxy desktop client that hooks into the public web chat session for logic reasoning, while keeping the schema parsing, execution layer, and file operations entirely local on the hard drive. You can let the agent run in loops, debug files, and query local DBs for hours, and it doesn't cost a single cent in API tokens.

If we don't decouple the AI's reasoning layer from the API key token billing model, agentic coding is going to remain a luxury that only massive corporations can afford.

The problem isn't the tool; it's the lack of engineering foundations. Generalizing all AI-assisted development as 'vibe coding' is a massive oversimplification. There is a vast difference between a beginner blindly copy-pasting LLM output into a codebase they don’t understand, and a senior architect using LLMs as a high-powered assistant to speed up boilerplate, local schema generation, or parsing scripts. When you already know exactly how the underlying system operates, how memory is managed, and how to design clean software architectures, the LLM is just a productivity multiplier. You still design the data flow, audit the tool-use sandboxes, and review every single line of code. It doesn't replace thinking; it replaces tedious typing.

It’s frustrating how legislators still refuse to grasp the fundamental mathematics of cryptography. You cannot have a 'secure backdoor only for the good guys'. If a scanning pipeline is built into the client, the encryption is compromised by design. This isn't 'chat control' - it's the systematic dismantling of digital privacy under the guise of security.