Friday, February 27, 2026

New top story on Hacker News: Show HN: Unfudged – version every change between commits - local-first

Show HN: Unfudged – version every change between commits - local-first
13 by cyrusradfar | 11 comments on Hacker News.
I built unf after I pasted a prompt into the wrong agent terminal and it overwrote hours of hand-edits across a handful of files. Git couldn't help because I hadn't finished/committed my in progress work. I wanted something that recorded every save automatically so I could rewind to any point in time. I wanted to make it difficult for an agent to permanently screw anything up, even with an errant rm -rf unf is a background daemon that watches directories you choose (via CLI) and snapshots every text file on save. It stores file contents in an object store, tracks metadata in SQLite, and gives you a CLI to query and restore any version. The install includes a UI, as well to explore the history through time. The tool skips binaries and respects `.gitignore` if one exists. The interface borrows from git so it should feel familiar: unf log , unf diff , unf restore . I say "UN-EF" vs U.N.F, but that's for y'all to decide: I started by calling the project Unfucked and got unfucked.ai, which if you know me and the messes I get myself into, is a fitting purchase. The CLI command is `unf` and the Tauri desktop app is called "Unfudged". How it works: https://ift.tt/OA41Byp (summary below) The daemon uses FSEvents on macOS and inotify on Linux. When a file changes, `unf` hashes the content with BLAKE3 and checks whether that hash already exists in the object store — if it does, it just records a new metadata entry pointing to the existing blob. If not, it writes the blob and records the entry. Each snapshot is a row in SQLite. Restores read the blob back from the object store and overwrite the file, after taking a safety snapshot of the current state first (so restoring is itself reversible). There are two processes. The core daemon does the real work of managing FSEvents/inotify subscriptions across multiple watched directories and writing snapshots. A sentinel watchdog supervises it, kept alive and aligned by launchd on macOS and systemd on Linux. If the daemon crashes, the sentinel respawns it and reconciles any drift between what you asked to watch and what's actually being watched. It was hard to build the second daemon because it felt like conceding that the core wasn't solid enough, but I didn't want to ship a tool that demanded perfection to deliver on the product promise, so the sentinel is the safety net. Fingers crossed, I haven’t seen it crash in over a week of personal usage on my Mac. But, I don't want to trigger "works for me" trauma. The part I like most: On the UI, I enjoy viewing files through time. You can select a time section and filter your projects on a histogram of activity. That has been invaluable in seeing what the agent was doing. On the CLI, the commands are composable. Everything outputs to stdout so you can pipe it into whatever you want. I use these regularly and AI agents are better with the tool than I am: # What did my config look like before we broke it? unf cat nginx.conf --at 1h | nginx -t -c /dev/stdin # Grep through a deleted file unf cat old-routes.rs --at 2d | grep "pub fn" # Count how many lines changed in the last 10 minutes unf diff --at 10m | grep '^[+-]' | wc -l # Feed the last hour of changes to an AI for review unf diff --at 1h | pbcopy # Compare two points in time with your own diff tool diff <(unf cat app.tsx --at 1h) <(unf cat app.tsx --at 5m) # Restore just the .rs files that changed in the last 5 minutes unf diff --at 5m --json | jq -r '.changes[].file' | grep '\.rs$' | xargs -I{} unf restore {} --at 5m # Watch for changes in real time watch -n5 'unf diff --at 30s' What was new for me: I came to Rust in Nov. 2025 honestly because of HN enthusiasm and some FOMO. No regrets. I enjoy the language enough that I'm now working on custom clippy lints to enforce functional programming practices. This project was also my first Apple-notarized DMG, my first Homebrew tap, and my second Tauri app (first one I've shared). Install & Usage: > brew install cyrusradfar/unf/unfudged Then unf watch in a directory. unf help covers the details (or ask your agent to coach).

Thursday, February 26, 2026

New top story on Hacker News: Show HN: Mission Control – Open-source task management for AI agents

Show HN: Mission Control – Open-source task management for AI agents
9 by meisnerd | 1 comments on Hacker News.
I've been delegating work to Claude Code for the past few months, and it's been genuinely transformative—but managing multiple agents doing different things became chaos. No tool existed for this workflow, so I built one. The Problem When you're working with AI agents (Claude Code, Cursor, Windsurf), you end up in a weird situation: - You have tasks scattered across your head, Slack, email, and the CLI - Agents need clear work items, context, and role-specific instructions - You have no visibility into what agents are actually doing - Failed tasks just... disappear. No retry, no notification - Each agent context-switches constantly because you're hand-feeding them work I was manually shepherding agents, copying task descriptions, restarting failed sessions, and losing track of what needed done next. It felt like hiring expensive contractors but managing them like a disorganized chaos experiment. The Solution Mission Control is a task management app purpose-built for delegating work to AI agents. It's got the expected stuff (Eisenhower matrix, kanban board, goal hierarchy) but built from the assumption that your collaborators are Claude, not humans. The killer feature is the autonomous daemon . It runs in the background, polls your task queue, spawns Claude Code sessions automatically, handles retries, manages concurrency, and respects your cron-scheduled work. One click: your entire work queue activates. The Architecture - Local-first : Everything lives in JSON files. No database, no cloud dependency, no vendor lock-in. - Token-optimized API : The task/decision payloads are ~50 tokens vs ~5,400 unfiltered. Matters when you're spawning agents repeatedly. - Rock-solid concurrency : Zod validation + async-mutex locking prevents corruption under concurrent writes. - 193 automated tests : This thing has to be reliable. It's doing unattended work. The app is Next.js 15 with 5 built-in agent roles (researcher, developer, marketer, business-analyst, plus you). You define reusable skills as markdown that get injected into agent prompts. Agents report back through an inbox + decisions queue. Why Release This? A few people have asked for access, and I think it's genuinely useful for anyone delegating to AI. It's MIT licensed, open source, and actively maintained. What's Next - Human collaboration (sharing tasks with real team members) - Integrations with GitHub issues and email inboxes - Better observability dashboard for daemon execution - Custom agent templates (currently hardcoded roles) If you're doing something similar—delegating serious work to AI—check it out and let me know what's broken. GitHub: https://ift.tt/3KAcF6C

Monday, February 23, 2026

New top story on Hacker News: Show HN: Shibuya – A High-Performance WAF in Rust with eBPF and ML Engine

Show HN: Shibuya – A High-Performance WAF in Rust with eBPF and ML Engine
12 by germainluperto | 1 comments on Hacker News.
Hi HN, I’ve been working on Shibuya, a next-generation Web Application Firewall (WAF) built from the ground up in Rust. I wanted to build a WAF that didn't just rely on legacy regex signatures but could understand intent and perform at line-rate using modern kernel features. What makes Shibuya different: Multi-Layer Pipeline: It integrates a high-performance proxy (built on Pingora) with rate limiting, bot detection, and threat intelligence. eBPF Kernel Filtering: For volumetric attacks, Shibuya can drop malicious packets at the kernel level using XDP before they consume userspace resources. Dual ML Engine: It uses an ONNX-based engine for anomaly detection and a Random Forest classifier to identify specific attack classes like SQLi, XSS, and RCE. API & GraphQL Protection: Includes deep inspection for GraphQL (depth and complexity analysis) and OpenAPI schema validation. WASM Extensibility: You can write and hot-load custom security logic using WebAssembly plugins. Ashigaru Lab: The project includes a deliberately vulnerable lab environment with 6 different services and a "Red Team Bot" to test the WAF against 100+ simulated payloads. The Dashboard: The dashboard is built with SvelteKit and offers real-time monitoring (ECharts), a "Panic Mode" for instant hardening, and a visual editor for the YAML configuration. I'm looking for feedback on the architecture and the performance of the Rust-eBPF integration.

New top story on Hacker News: ASML unveils EUV light source advance that could yield 50% more chips by 2030

ASML unveils EUV light source advance that could yield 50% more chips by 2030
39 by pieterr | 3 comments on Hacker News.