Stevens 🤵🏼; Powxy 🧾; Ferron 🏮
If you do nothing else, today, (including reading the Drop) just Go Back To A Website.
TL;DR
(This is an LLM/GPT-generated summary of today’s Drop using Ollama + llama 3.2 and a custom prompt.)
- Malleable software researcher Geoffrey Litt creates a personal AI assistant called Stevens using minimal components, demonstrating an adaptable pattern for anyone to customize. (https://www.geoffreylitt.com/2025/04/12/how-i-made-a-useful-ai-assistant-with-one-sqlite-table-and-a-handful-of-cron-jobs)
- Powxy is a reverse proxy designed to protect upstream services from scrapers by requiring clients to solve a SHA-256 proof-of-work challenge, aiming to make scraping computationally expensive. (https://git.sr.ht/~runxiyu/powxy)
- Ferron is an open-source web server written in Rust that combines high performance with memory safety, featuring a modular design and secure defaults for easy deployment. (https://www.ferronweb.org/)
Stevens 🤵🏼
Geoffrey Litt is a researcher whose work centers on the concept of malleable software — computing environments designed so that anyone can adapt and mold their digital tools to fit their unique needs. This vision is rooted in the belief that software should not be rigid or one-size-fits-all, but instead empower folks to shape their own workflows and experiences. Litt currently leads the Malleable Software research track at Ink & Switch, an independent research lab, where he investigates how people can gain more agency over their digital environments.
Recently, Geoffrey created and wrote about “Stevens,” a practical personal AI assistant built with minimal components: one SQLite table and several scheduled tasks hosted on Drop fav Val.town. As we’ve noted before, this platform provides SQLite storage, HTTP handling, scheduled operations, and email functionality. This straightforward approach serves as an adaptable pattern anyone can customize.
Stevens functions as a digital helper for Litt’s family. It delivers a daily morning update via Telegram with calendar events, weather forecasts, mail/package notifications, and reminders. This update comes from querying the “notebook” — a simple SQLite table recording everything Stevens knows. Each entry can include a date for time-specific information or remain undated for persistent information. Data comes from various sources: Google Calendar API, weather services, scanned postal mail, and direct messages through Telegram or email. Weekly “fun facts” are also included to enhance the updates.
The system runs through scheduled tasks that regularly collect new information from external sources and add it to the notebook. Another scheduled task runs each morning to gather relevant entries (upcoming week’s dated items plus background information), process them through Claude’s API, and send the resulting summary to the family’s Telegram chat. The design is simple enough that adding new data sources requires only inserting or updating rows in the SQLite table. The system doesn’t need complex search capabilities or vector databases because the context volume remains manageable, and modern AI models effectively process and summarize text input.
Litt notes several important observations. Providing an assistant with broader context (calendar, weather, mail) elevates it from a basic chatbot to something truly helpful. Memory systems can begin simply—just text entries with optional dates—before more advanced retrieval becomes necessary. The assistant’s personality is easily customizable: Stevens communicates formally like a literary butler, and the administration interface is designed for enjoyment, not just utility. These elements, enabled by adjustable prompting and simple interface modifications, make the assistant more engaging and personalized.
Stevens serves as a concept demonstration rather than a finished product — a template for building your own assistant. It shows that with minimal technical components, you can create a functional, expandable, and pleasant AI assistant tailored to your specific needs.
Sounds like a fun weekend project!
Powxy 🧾
There have been reports over the past couple weeks of AI agents slamming various sites to the point of crippling their ability to serve legitimate requests. There are several solutions to this issue, one of which is Powxy — a reverse proxy designed to protect upstream services from scrapers by requiring clients to solve a SHA-256 proof-of-work challenge. Developed by Runxi Yu, it aims to make scraping computationally expensive, particularly for targets like Git forges where automated systems might frequently fetch large amounts of data. The proxy uses a cookie-based mechanism combined with cryptographic challenges to verify legitimate traffic.
When a client first connects, Powxy generates an identifier by hashing the client’s IP and user agent. If the client lacks a valid HMAC-signed cookie for this identifier, they’re presented with a challenge: find a nonce that, when appended to the identifier, produces a SHA-256 hash with a specified number of leading zero bits (default: 20). Clients with JavaScript-enabled browsers automatically solve this via embedded WebAssembly, while others must use provided C or Python scripts.
The project emphasizes simplicity in deployment, requiring no dependencies beyond a Go toolchain, Clang, and LLD for WebAssembly compilation. Configuration is handled through command-line flags, including upstream server URLs, timeouts, and difficulty settings. A notable feature is its compatibility with non-browser clients, though limitations exist—POST requests may lose data during redirection, and protocols like Git’s Smart HTTP aren’t fully supported yet.
Current challenges include potential cryptographic vulnerabilities (e.g., length-extension attacks in SHA-256) and platform-specific issues, such as Safari’s unpredictable IP handling.
It does what it says on the tin, but my various sites are handling the increased loads pretty well, and I tend to use hosting providers that have generous bandwidth tiers, so I won’t be using this as a daily driver yet. I’m definitely keeping it in the back pocket when (not “if”) I need to break glass in case of emergency.
Ferron 🏮
Ferron (GH), a new open-source web server written in Rust, has reached its 1.0.0 stable release. The project focuses on combining high performance with memory safety by using Rust’s ownership model to prevent common memory errors that affect web servers written in C or C++. Ferron features a modular design that lets developers customize and extend the server for specific requirements.
Performance testing shows Ferron outperforming several established web servers. For static file serving, it’s 12% faster than Caddy and 19% faster than Apache httpd (with prefork MPM). When functioning as a reverse proxy, Ferron performs 16% faster than Traefik, 26% faster than Apache httpd (with event MPM), and 51% faster than Caddy. These results come from standardized tests on modern hardware with all servers configured to log requests. The performance advantages stem from Rust’s asynchronous capabilities and optimizations for handling concurrent requests.
Security represents another key focus area. Ferron implements secure defaults to reduce manual configuration hardening. It includes integrated automatic TLS through Let’s Encrypt for seamless certificate management, making secure website deployment more straightforward. This approach makes Ferron accessible to beginners while remaining reliable for production environments.
The project emphasizes community involvement and transparency. Ferron uses the MIT license and maintains public development on GitHub where users can contribute code, report issues, or suggest new features. While still developing, the documentation aims to provide comprehensive guidance for installation, configuration, and usage.
The Ferron ecosystem includes several complementary tools. Ferron Forge helps streamline server building, while FerrBench provides realistic HTTP performance metrics. A WordPress plugin enables URL rewriting support, showing Ferron’s commitment to integration with popular web platforms.
Feedback has been positive, with many highlighting Ferron’s easy configuration, performance, and automatic TLS. The project has gained traction quickly, gathering over 500 GitHub stars from users who appreciate its straightforward approach and modern features.
Not sure I’m switching from Caddy just yet, but this is a very compelling alternative.
FIN
Remember, you can follow and interact with the full text of The Daily Drop’s free posts on:
- 🐘 Mastodon via
@dailydrop.hrbrmstr.dev@dailydrop.hrbrmstr.dev - 🦋 Bluesky via
https://bsky.app/profile/dailydrop.hrbrmstr.dev.web.brid.gy
☮️
hrbrmstr's Daily Drop 
Leave a comment