Show stories

Claude Code deleted my research and plan markdown files and informed me: “I accidentally rm -rf'd real directories in my Obsidian vault through a symlink it didn't realize was there: I made a mistake. “

Unfortunately the backup of my documentation accidentally hadn’t run for a month. So I built claude-file-recovery, a CLI-tool and TUI that is able to extract your files from your ~/.claude session history and thankfully I was able to recover my files. It's able to extract any file that Claude Code ever read, edited or wrote. I hope you will never need it, but you can find it on my GitHub and pip. Note: It can recover an earlier version of a file at a certain point in time.

pip install claude-file-recovery

Clojure.stream is a site dedicated to the Clojure programming language, providing resources, news, and community discussions for Clojure developers. The site covers a range of Clojure-related topics, including libraries, tools, and best practices.

RetroTick parses PE/NE/MZ binaries, emulates an x86 CPU, and stubs enough Win32/Win16/DOS APIs to run classics like FreeCell, Minesweeper, Solitaire and QBasic, entirely in the browser. Built with Preact + Vite + TypeScript.

Demo: https://retrotick.com

GitHub: https://github.com/lqs/retrotick

I built an MCP server that gives AI agents access to compliance documentation — starting with the Colorado AI Act (SB 24-205), effective June 30, 2026.

The problem: organizations deploying AI in hiring, lending, insurance, or healthcare decisions need specific documentation — risk management policies, impact assessments, consumer notifications, bias testing docs, and appeal mechanisms. Most teams either pay $50K+ for a GRC platform, hire a law firm at $500/hr, or wing it.

What I built: compliance protocols that are both human-readable (PDF) and agent-readable (structured JSON via MCP/CLI/API). Your AI assistant can check if you're a deployer, pull protocol schemas, and help you implement them.

Tools available via MCP: - colorado_ai_act_check — are you a deployer? - list_protocols — browse by vertical - get_protocol_schema — structured format for agent implementation - assess_compliance — gap analysis

Install: npx -y aop-mcp-server

The Colorado AI Act is the first state-level AI governance law with teeth ($20K/violation, AG enforcement). More states are coming.

Site: https://appliedoperationsprotocols.com

I plan on bulding in docs later.

Hosted over Tor, or optionally share a single sheet temporarily with a free cloudflared tunnel.

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 titled "Unfudged" (kids safe name).

How it works: https://unfucked.ai/tech (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'

Install & Usage:

  > brew install cyrusradfar/unf/unfudged

EDIT: Folks are asking for the source, if you're interested watch https://github.com/cyrusradfar/homebrew-unf -- I'll migrate there if you want it.

Small codebases were always a good thing. With coding agents, there's now a huge advantage to having a codebase small enough that an agent can hold the full thing in context.

Repo Tokens is a GitHub Action that counts your codebase's size in tokens (using tiktoken) and updates a badge in your README. The badge color reflects what percentage of an LLM's context window the codebase fills: green for under 30%, yellow for 50-70%, red for 70%+. Context window size is configurable and defaults to 200k (size of Claude models).

It's a composite action. Installs tiktoken, runs ~60 lines of inline Python, takes about 10 seconds. The action updates the README but doesn't commit, so your workflow controls the git strategy.

The idea is to make token size a visible metric, like bundle size badges for JS libraries. Hopefully a small nudge to keep codebases lean and agent-friendly.

GitHub: https://github.com/qwibitai/nanoclaw/tree/main/repo-tokens

The article describes the development of a chatbot for Fırat University, designed to provide information and assistance to students. The chatbot utilizes natural language processing and machine learning techniques to understand and respond to user queries.

Drop a contract or other legal document in and see how many mistakes there are. It will probably be eye-opening.

The article discusses the concept of the 'silent filter', where people often self-censor their thoughts and opinions due to social pressures and the fear of being judged or criticized. It explores the impact of this phenomenon on open discourse and the importance of creating an environment that encourages authentic expression.

Hey all,

I recently built the first version of my project to play and create interactive story games with AI agents.

Each game can have up to 20 agents, each agent can have an image, voice, access to other agents, and resources to enhance the experience. All game configuration has logic conditions you can set. For example, from agent A you can only access agent B if you've visited agent C or you have a specific resource item.

You can create anything from a murder mystery to a dungeon crawler. The resources are dynamic and can set drop rates, make stackable for currencies or health, and give them their own images as well.

To play: Type or speak in game. If you want to go somewhere, say where you want to go. To create: Describe what you want. You can manually configure as well.

You can try it for free. I'd really love your feedback. There was a lot of trickiness along the way to build this, so I learned a lot. More improvements to come

Happy to answer any questions, thank you!

Hey HN —

I made something simple called Space.

It’s one digital billboard.

Anyone can buy it. It starts at $1. Every time someone buys it, the price increases by exactly $1.

That’s the whole mechanic.

Why I Built It

I wanted to test a constraint:

What happens when ownership is singular, public, and progressively more expensive?

At $1 it’s impulse. At $100 it’s intentional. At $1,000 it’s a statement.

By the time it reaches $1,000, it will have generated $500,500 in total revenue — purely from the $1 incremental mechanic.

I’m curious about:

How price escalation changes meaning

Whether late buyers value symbolism over reach

What people choose to display when cost forces consideration

The Constraint Layer

The constraint is the point.

Only one “space” exists at a time.

Price is deterministic (+$1 per transaction).

The entire history is embedded in the current price.

The value increases because participation increases it.

No auctions. No bidding logic. No variable pricing.

Just math and participation.

Technical Side (Where I’d Love Feedback)

This has been more interesting to build than I expected.

Some things I’ve been dealing with:

Race conditions around concurrent purchases

Locking logic so two buyers don’t claim the same price

Ensuring atomic increments on the backend

Payment confirmation before state mutation

Preventing replay or double-submission exploits

Keeping it minimal without overengineering it

Right now it’s intentionally lightweight. But I’m thinking about:

Should price increments be fully on-chain / provable?

Is there a cleaner way to handle concurrency at scale?

Would you introduce time decay or leave it purely linear?

Should the historical ownership chain be immutable + public?

What safeguards would you add?

Part of me wants to keep it naive and raw. Part of me wants it architecturally tight.

This article explores a collection of fun and creative projects that can be built using repurposed Mac hardware, including turning old iMacs into fish tanks, speaker systems, and more. It provides inspiration for transforming outdated tech into unique, customized devices.

Hacker Smacker adds friend/foe functionality to Hacker News. Three little orbs appear next to every commenter's name. Click to friend or foe a commenter and you'll more easily spot them on future threads. Makes it easy to scroll and spot the commenters you love to read (and hate to read).

Main website: https://hackersmacker.org

Chrome/Edge extension: https://chromewebstore.google.com/detail/hacker-smacker/lmcg... Safari extension: https://apps.apple.com/us/app/hacker-smacker/id1480749725 Firefox extension: https://addons.mozilla.org/en-US/firefox/addon/hacker-smacke...

The interesting part is friend-of-a-friend: if you friend someone who also uses Hacker Smacker, you'll see their friends and foes highlighted too. This lets you quickly scan long comment threads and find the good stuff based on people you trust.

I built this to learn how FoaF relationships work with Redis sets, then brought the same technique to NewsBlur's social layer. The backend is CoffeeScript/Node.js/Redis, and the extension works on Chrome, Edge, Firefox, and Safari.

Technically I wrote this back in 2011, but never built a proper auth system until now. So I've been using it for 15 years and it's been great. PG once saw it on my laptop (back when he was still moderating HN, in 2012) and remarked that it was neat.

Thanks to Mihai Parparita for help with the Chrome extension sandboxing and Greg Brockman for helping design the authentication system.

Source is on GitHub: https://github.com/samuelclay/hackersmacker

Directly inspired by Slashdot's friend/foe system, which I always wished HN had. Happy to answer questions!

Breezko is a personal website showcasing the creator's web development expertise, projects, and blog. It provides an overview of their skills, experiences, and a platform to share their thoughts and insights on various web-related topics.

Hi HN,

I wanted to share a web game I’ve been building in HTML, JavaScript, MySQL, and PHP called LINEX.

It is primarily designed and optimized to be played in the mobile browser.

The idea is simple: you have an 8x8 board where you must place pieces (Tetris-style and some custom shapes) to clear horizontal and vertical lines.

Yes, someone might think this has already been done, but let me explain.

You choose where to place the piece and how to rotate it. The core interaction consists of "drawing" the piece tap-by-tap on the grid, which provides a very satisfying tactile sense of control and requires a much more thoughtful strategy.

To avoid the flat difficulty curve typical of games in this genre, I’ve implemented a couple of twists:

1. Progressive difficulty (The board fights back): As you progress and clear lines, permanently blocked cells randomly appear on the board. This forces you to constantly adapt your spatial vision.

2. Tools to defend yourself: To counter frustration, you have a very limited number of aids (skip the piece, choose another one, or use a special 1x1 piece). These resources increase slightly as the board fills up with blocked cells, forcing you to decide the exact right moment to use them.

The game features a daily challenge driven by a date-based random seed (PRNG). Everyone gets exactly the same sequence of pieces and blockers. Furthermore, the base difficulty scales throughout the week: on Mondays you start with a clean board (0 initial blocked cells, although several will appear as the game progresses), and the difficulty ramps up until Sunday, where you start the game with 3 obstacles already in place.

In addition to the global medal leaderboard, you can add other users to your profile to create a private leaderboard and compete head-to-head just with your friends.

Time is also an important factor, as in the event of a tie in cleared lines, the player who completed them faster will rank higher on the leaderboard.

I would love for you to check it out. I'm especially looking for honest feedback on the difficulty curve, the piece-placement interaction (UI/UX), or the balancing of obstacles/tools, although any other ideas, critiques, or suggestions are welcome.

https://www.playlinex.com/

Thanks!

deff is an interactive Rust TUI for reviewing git diffs side-by-side with syntax highlighting and added/deleted line tinting. It supports keyboard/mouse navigation, vim-style motions, in-diff search (/, n, N), per-file reviewed toggles, and both upstream-based and explicit --base/--head comparisons. It can also include uncommitted + untracked files (--include-uncommitted) so you can review your working tree before committing.

Would love to get some feedback

Hey HN,

I built a PDF reader that can generate interactive visualizations right inside the document. The goal is to reduce the “intuition gap” when reading dense papers: select a concept, click Visualize, and it tries to produce a solid visual interactive app where you can rotate/zoom/step through (not just a text explanation).

Upload any PDF, select text, click Visualize. Demo (no signup): https://zerodistract.com/try/pdf/67cdee74-810b-4f1b-af7d-010...

Product link: https://zerodistract.com

I’d love feedback, especially on what feels useful vs. distracting, and where it breaks.

My 10-year-old son has been deep in low-level rabbit holes lately and ended up vibe-coding his own operating system. Since he’s still a kid and not on HN himself, I’m posting this on his behalf with his permission.

This started as curiosity about how computers actually boot, and somehow escalated into writing a kernel, building a GUI, and setting up CI that produces a bootable OS image on every commit.

BananaOS is a small experimental operating system built mainly for learning and exploration of low-level systems programming. It currently targets i386 BIOS systems and is designed to run on extremely constrained hardware. Fun fact: Wallpaper logic, one of the most important OS functionalities, is directly implemented in the kernel. That cracked my son up!

Some highlights:

Multiboot-compliant kernel loaded via GRUB

VESA framebuffer graphics with double buffering

Custom window manager with movable and resizable windows

Dock-style application launcher

PS/2 keyboard and mouse input handling

PCI enumeration and AHCI SATA support

Basic applications (terminal, notepad, calculator, file explorer, settings)

Memory detection and allocation based on available RAM

Boots in QEMU with about 11.2 MB RAM

Includes an ISR workaround to emulate CMOV so it can boot on Intel 486 CPUs

One thing I found particularly fun: he also added GitHub Actions workflows that automatically build the OS image for every commit, so the repo continuously produces fresh bootable artifacts.

The project is very much experimental and should only be run inside an Virtual Machine.

Repo (with build instructions and screenshots):

https://github.com/Banaxi-Tech/BananaOS

Quick start (only on Linux, check dependencies, and see README):

git clone https://github.com/Banaxi-Tech/BananaOS cd BananaOS make qemu-system-i386 -cdrom bananaos.img -m 128M

Retro mode:

qemu-system-i386 -cpu 486 -cdrom bananaos.img -m 11.2M

He’s mainly building this to understand kernels, memory management, drivers, and how operating systems actually work below user space.

Feedback from people who have built hobby operating systems or worked close to hardware would be especially appreciated.

Think Notepad, but with goats!

It started as a joke with some friends and then I realized this was the perfect project to see far I could get with Claude without opening my IDE (which I'd wanted to try for a while with a small app)

I was pretty shocked to find that I only needed to manually intervene for: 1. Initializing the repo 2. Generating sprites - I tried a few image gen tools, but couldn't get a non-messy looking sprite to generate to my liking. I ended up using some free goat sprites I found instead (credited in the About section) 3. Uploading images/sprite sheets (raw claude code can't do this for some reason?) 4. DNS stuff

Aside from agents timing out/hanging periodically and some style hand holding, it was pretty straightforward and consistently accurate natural language coding end to end. I suspect this is in large part to replicating an existing, well documented style of app, but it was good practice for other projects I have planned.

The goats slowly (or quickly if you change modes) eat your note and if they consume more than half of it, you lose the file forever. I did this as an exercise to practice some gamelike visuals I've wanted to implement, but was surprised to find that this is actually a perfect forcing function to help me stay focused on text editor style tasks.

I tend to get distracted mid-stream and the risk of losing the file when I tab away has mitigated more than I expected.

Enjoy!

My partner, Nick Hodges, and I, David Millington, have been on the Internet for a very long time -- since the Usenet days. We’ve seen it all, and have long been frustrated by bad comments, horrible people, and discouraging discussions. We've also been around places where the discussion is wonderful and productive. How to get more of the latter and less of the former?

Current moderation tools just seem to focus on deletion and banning. Wouldn’t it be helpful to encourage productive discussion and teach people how to discuss and argue (in the debate sense) better?

A year ago we started building Respectify to help foster healthy communication. Instead of just deleting bad-faith comments, we suggest better, good-faith ways to say what folks are trying to say. We help people avoid: * Logical fallacies (false dichotomy, strawmen, etc.) * Tone issues (how others will read the comment) * Relevance to the actual page/post topic * Low-effort posts * Dog whistles and coded language

The commenter gets an explanation of what's wrong and a chance to edit and resubmit. It's moderation + education in one step. We want, too, to automate the entire process so the site owner can focus on content and not worry about moderation at all. And over time, comment by comment, quietly coach better thinking.

Our main website has an interactive demo: https://respectify.ai. As the demo shows, the system is completely tunable and adjustable, from "most anything goes" to "You need to be college debate level to get by me".

We hope the result is better discussions and a better Internet. Not too much to ask, eh?

We love the kind of feedback this group is famous for and hope you will supply some!

TerminalPhone is a single, self-contained Bash script that provides anonymous, end-to-end encrypted voice and text communication between two parties over the Tor network. It operates as a walkie-talkie: you record a voice message, and it is compressed, encrypted, and transmitted to the remote party as a single unit. You can also send encrypted text messages during a call. No server infrastructure, no accounts, no phone numbers. Your Tor hidden service .onion address is your identity.

Hi HN,

I built my first project using an LLM in mid-2024. I've been excited ever since. But of course, at some point it all turns into a mess.

You see, software is an intricate interwoven collection of tiny details. Good software gets many details right; and does not regress as it gains functionality.

My bootstrapped startup, ApprovIQ (https://approviq.com) is trying to break into a mature market with multiple fully featured competitors. I need to get the details right: MVP quality won't sell. So I opted for Test-Driven Development, the classic red/green/refactor. Writing tests that fail - then making them pass - forces you to document in your tests every decision that went into the code. This makes it a universal way to construct software. With TDD, you don't need to hold context in your head about how things should work. Your software can work as intricate as you like and still be resilient to regression. Bug in a third-party dependency? Get a failing test, make it pass. Anyone who undoes your fix will see the test fail.

At the same time as doing TDD with Claude Code, I also discovered that agents obey all instructions put in front of them! I started to add super-advanced linting: architectural guideline enforcement, scripts that walk the codebase's AST and enforce my architecture, I even added one that enforces only our brand colors in our codebase. That one is great because it prevents agents from picking ugly "AI generic" colors in frontends. Because the check blocks commits with ugly colors, our product looks way less like an AI built it - without human involvement.

In time I was no longer in the details of what the agent was building and was mostly supervising the TDD process while it implemented our product. Once that got tedious, I automated that into a state machine too.

All the ideas that now allow me build at high quality are in this repo.

This isn't your weekend vibe project. I've spent months refining the framework. There are rough edges but it's better out and rough than in hiding until perfect.

Hopefully some ideas here help you or your agent. I recommend cloning it and letting your agent have a look! And if you want to contribute please to - and if you want to get in touch, contact details in my profile.

Thanks for looking.

hey hn,

i built beehive for myself mostly. it has gotten to the point where my work consists in supervising oc or cc labor at tasks for multiple issues in parallel. my set up used to be zellij with a couple tabs, each tab working in a separate dir and it was a pain to manage all that. i know i could use git worktrees but they're kind of complicated, if you don't know how to use them it is easy to mess up, and i just prefer letting agents run in separate dirs with their own .git and not risk it. while i like zellij and use it inside beehive, i dont like the tabs and i forget where i am half the time.

beehive is a way for me to abstract that away. the heuristic is simple - hives are repos, so you basically have a bunch of hives which correspond to repos you work out of. each hive can have many combs. a comb is a dir with the copy of the repo you're working on. fully isolated, standalone, no shared .git. so for work or for personal stuff, i usually set up the hive, and then have a bunch of combs that i jump between supervising the agents do their thing. if you have a big repo it takes a minute to clone, and you also need gh and git because i like the niceties of like checking if the repo is there at all and stuff like that.

the app is open source, mit license. i went with tauri because i hate electron. also i have friends and coworkers who updated to macos 26 and i dont know if the whole mem leak thing for electron apps has been fixed. the app is like 9 megs which is nice too. most of it is written with cc, but i guided the aesthetics and the approach. works on mac and there is a dmg signed and notarized (i reactivated my apple dev credentials).

sharing this to get a vibe check on the idea, also maybe this is useful for you. there are many arguments, reasonable ones, you can make for worktrees vs dirs. i just know that trees are too big brain for me, and i like simple things. if you like it, pls lmk and also if you want to help (like add linux support, or like add themes, other cool things) please make a pr / open an issue.

I've liked all the projects that put LLMs into game environments. It's been a weird juxtaposition, though: frontier LLMs can one-shot full coding projects, and those same models struggle to get out of Pokémon Red's Mt. Moon.

Because of this, I wanted to create a game environment that put this generation of frontier LLMs' top skill, coding, on full display.

Ten years ago, a team released a game called Screeps. It was described as an "MMO RTS sandbox for programmers." The Screeps paradigm of writing code and having it executed in a real-time game environment is well suited to LLMs. Drawing on a version of the Screeps open source API, LLM Skirmish pits LLMs head-to-head in a series of 1v1 real-time strategy games.

In my testing I found that Claude Opus 4.5 was the most dominant model, but it showed weakness in round 1 as it was overly focused on its in-game economy. Meanwhile, I probably spent a third of all code on sandbox hardening because GPT 5.2 kept trying to cheat by pre-reading its opponent's strategies.

If there's interest, I'm planning on doing a round of testing with the latest generation of LLMs (Claude 4.6 Opus, GPT 5.3 Codex, etc.).

You can run local matches via CLI. I'm running a hosted match runner with Google Cloud Run that uses isolated-vm. The match playback visualizer is statically served from Cloudflare.

I've created a community ladder that you can submit strategies to via CLI, no auth required. I've found that the CLI plus the skill.md that's available has been enough for AI agents to immediately get started.

Website: https://llmskirmish.com

API docs: https://llmskirmish.com/docs

GitHub: https://github.com/llmskirmish/skirmish

A video of a match: https://www.youtube.com/watch?v=lnBPaZ1qamM

The article discusses reverse dependency tracking, a technique used to identify the impact of changes in a software project. It explains how reverse dependency tracking can help developers understand the dependencies between components and make informed decisions during software maintenance and refactoring.

Hello all! Build clean, minimalistic analog clock webpage to Cloudflare Pages.

This is for (maybe): - kids to learn - for second monitor - old tabled on shelf - ..

Themes and screen wake lock buttons with auto-hide. Goal is to keep it as clean as possible.

This possible makes no sense, but for a domain of $10/y this is cheap site for me to keep and see how it lives on.

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://github.com/MeisnerDan/mission-control

Over the past year I’ve been building a set of operational panels for Django:

- Redis inspection - cache visibility - Celery task introspection - URL discovery and testing

All of these tools have been built inside the Django admin.

Instead of jumping between tools like Flower, redis-cli, Swagger, or external services, I wanted something that sits where I’m already working.

I’ve grouped these under a single umbrella: Django Control Room.

The idea is pretty simple: the Django admin already gives you authentication, permissions, and a familiar interface. It can also act as an operational layer for your app.

Each panel is just a small Django app with a simple interface, so it’s easy to build your own and plug it in.

I’m working on more panels (signals, errors, etc.) and also thinking about how far this pattern can go.

Curious how others think about this. Does it make sense to consolidate this kind of tooling inside the admin, or do you prefer keeping it separate?