alt Hacker NewsAsk HN: What Are You Working On? (December 2025)
What are you working on? Any new ideas that you're thinking about?
Comments
Working on a little project to make Spotify recommendations better.
You get to choose the genres you're interested in, and it creates playlists from the music in your library. They get updated every day - think a better version of the Daily Mixes. You can add some advanced filters as well, if you really want to customise what music you'll get.
I've been spending weekends thinking about authorization for AI agents, specifically delegation.
The failure mode I keep hitting: once you give an agent tools, it gets ambient authority over all of them. There's no clean way to say "for this task, read-only on the reports table" or "spin up no more than 3 VMs." When the agent spawns sub-agents mid-execution, they inherit full access by default.
IAM doesn't help much. Authority stays tied to the agent's identity even as intent shifts during execution.
I'm exploring a capability-based model instead: authority is explicit, task-scoped, and attenuating. Closest to Macaroons/Biscuit, but adapted for workflows where delegation happens dynamically mid-task.
Early prototype (Rust core, Python SDK, LangChain integration), still thinking it through. Notes here: https://niyikiza.com/posts/capability-delegation/
I’ve been building a crypto market visualization and simulation tool because I kept running into the same problem: TradingView is great for charts, but it’s hard to answer simple “what-if” questions like would rotating into another coin actually have helped or did trimming and buying back improve outcomes, or just feel good in hindsight. So I started building tools that simulate these scenarios directly on historical data. For example: - flipping from coin A into coin B and back again over a chosen period - selling part of a position and buying back later after a drawdown
I’m still early and adding ideas as I go, but it’s already helped me questions I had.
Examples: - Coin flip simulation: https://www.blockviz.xyz/simulation/coin-flip - Sell & buy-back simulation: https://www.blockviz.xyz/simulation/sell-buy-back
Curious if others here run into similar “this felt right, but did it actually help?” questions.
We’re working on an AI-first interview platform for developers: Valuate.dev The usual approach to coding tasks doesn’t work anymore - companies are looking for AI engineers, yet it’s still unclear how to assess AI proficiency.
Our goal is to design challenges that combine prompting + coding, allowing us to score both how well a candidate prompts and how good the resulting code is. The aim is to bring measurement to AI prompting skills - how well-aligned prompts are and how candidates handle LLM-generated code.
At the same time, we want to keep a strong human balance in the process: hiring is a two-way street, and screening shouldn’t be fully offloaded to AI. We’re human-first.
Several tasks are already live - you can try them here: https://valuate.dev
I am working (mostly vibecoded) a Git history explorer in Go+modernc.org/Tk9.0: https://github.com/thiagokokada/gitk-go. It is heavily inspired in gitk, this is why the name and usage of Tk for the interface.
The reason for it was because after testing multiple Git history explorers, I still think nothing beats the gitk. Sublime Merge is probably the only alternative that I would seriously consider but I don't really like the UI and the fact that it is proprietary (I am not against proprietary software but I prefer an opensource solution when available). Other alternatives have some bugs or the interface few too slow. gitk itself is mostly fine, but sadly it tries to load the whole repository in memory and this is causing issues every time I try to navigate through nixpkgs (I can see the memory consumption going through the roof while the UI slow down to a crawl).
gitk-go loads a batch of commits (1000 by default) and once you get at the end of the list it loads more. I also add a few features that I miss from gitk, for example if you do any change in the repository (change branches, add files to stash, etc) it will automatically reflect in the UI.
Again, the code is mostly vibecoded since this is the first time I decided to try this from scratch. The code works well for my use cases and it is enough to replace gitk for me, but I can't guarantee there is no bugs and the amount of tests are small. But still, it was fun to see something that I wanted to create for a while (I had this idea for a long time since the issues with gitk that I was having) finally taking form. Probably the program is not useful for anyone but me, but if anything this is a feature, not a bug.
A security-focused "check engine light" for your shell prompt: https://github.com/erichs/dashlights
There's a gap in most security tooling: it's not IN the terminal with you. It doesn't have enough context: your environment, your repo state, your current directory, etc. to catch the small hygiene mistakes that accumulate over the many tiny decisions you make every day to ship code and learn new tools. Those "cut corners" add up, and can lead to costly blunders.
Dashlights attempts to bring awareness and visibility to your immediate shell context.
A WhatsApp store link.
Instead of sending products details one by one, you send your store link, your customers browse through your products, add to cart and the cart is sent directly to you.
Also works for those who have hit the 500 product limit on WhatsApp.
I'm working on a charitable donation tracker for taxpayers. My wife and I used Intuit's ItsDeductible for years until it shut down in October. With a little encouragement, I built Charity Record.
The stack is Django 5.2 (I know, I know, I'm looking at 6 now), Postgres, and HTMX + Alpine.js for interactivity. I'm using Polar for subscriptions. It's running on the $12/mo DigitalOcean droplet.
Trickiest parts so far: TXF export (we can trace TXF back to the 1990s...) and PDF generation. At one point when working on PDFs, WeasyPrint was deadlocking a single-worker setup because it fetched the logo via HTTP. (Base64-embedding the logo got me past that, ha.)
Happy to answer questions about the app or running Django lean - I've got a few longer running Django projects.
LLM-driven narrative game. Main technical issue is how go do compaction. I’ve devised a memory hierarchy that compacts the story to a constant amount of tokens per layer. Arc -> Scene -> Moment -> Line. Not sure if that’s the right dimensions to decompose into. Also tinkering how to get the right amount of “divergence” for story progression option generation. A lot of unanswered questions…
I’m finishing up a language identification model that runs on cpu, 70k texts/s single thread, 13mb model artifact and 148 supported languages (though only ~100 have good accuracy).
This is a model trained as static embeddings from the gemma 3 token embeddings.
Trying to rebuild my website (php mvc built a decade ago) using Django. I want to be able to update any page content, upload and display images, have multiple blog instances. I do a lot of django-cms by day, but it's too much for a small personal website, so I started to create a (tiny, foss) CMS based on Django, django-prose-editor for the content, and some new apps (for now, Page & Blog).
The site isn't even online, but for now I'm starting to think about the next steps (seo-related things to implement, generalize app functions to handle not only blog but other (hypothetical) apps as well, improve code quality and repo readability, separate apps from the website so anyone can add them to their django website if they want to). It's a lot of work for something no one will ever use, but I must at least try to make it clean and discoverable :)
A prompt engineering tool that takes vague prompts and transforms them into context-rich JSON/XML structured prompts. Fully customizable and tracks prompting history safely in tab session, automatically injecting context and learns style.
Makes outputs of any AI so much better due to restructuring and breaking down requests into instructions AI can easily execute upon and mitigating risk of hallucinations. Perfect for complex tasks like coding and content creation.
Exists as a free chrome extension right now. Would love if you tried it and have any feedback!
Email me at [email protected]
I wrote a Telegram bot for video/image translation, and also Firefox/Chrome addons to help translate web content with smart content extraction and non-breaking layouts.
Check it out at: https://addons.subly.xyz & https://subly.xyz
The Firefox addon/Chrome extension is free, but you need your own OpenRouter/Gemini API key. The cost of web translation is really low, you can translate an article for ~$0.01 with really good quality. (You can try at https://addons.mozilla.org/en-US/firefox/addon/subly-xyz/)
I built it because I use Firefox the most and it seemed like no translate addon was good or simple enough. Chrome translate kinda works, but the quality is so low; it usually doesn't understand the article context.
Yesterday I released https://npmdigest.com, a micro-SaaS to work around the frustrating experience of getting spammed by npm emails "Successfully published X" whenever I release new versions of my packages.
And I completed a pretty long technical article on my personal blog that goes pretty deep into SSE + Postgres + v8 + some linux kernel stuff: https://sam.elborai.me/articles/how-sse-actually-works-deno-...
Some other projects I'm currently motivated by
- pls, my take on what my ideal release automation tool would be (currently deno only): https://github.com/dgellow/pls
- steady, an OpenAPI spec validator and mock server: https://github.com/dgellow/steady
I’ve been working on offline payments.
Imagine direct p2p payments that can be performed without reception.
I got thinking about what the equivalent of digital cash would be in 2021 and have worked on it on-and-off ever since. It has an optional NFC component.
Technically what I have is good enough to ship, but I’ve been unsure of the legal footing of such a project so it’s been on ice for a while now.
I've been a long time Windows user (20+ years) who heavily uses WSL 2 as my dev environment with tmux / Neovim but I'm switching to native Linux before the end of this year.
I tried once 7 years ago but ran into major audio issues that were a deal breaker but I'm hoping the Linux kernel has improved. I have the same hardware as before.
My dotfiles have been public for many years and can 1 shot a new or existing system in a few minutes with a bunch of command line tools on Debian, Ubuntu, Arch (with or without WSL 2) and macOS. It has an install script and theme switching for a long time which I've used to set up a a few systems (personal desktop, laptop and work laptop).
I've been casually tweaking a laptop running Arch with niri. I'm preparing a bunch of things in my https://github.com/nickjj/dotfiles to prepare for that push which will work on Arch Linux and be opt-in to install and configure a GUI and assorted tools.
I’m working on a small browser extension called Instant Preview.
https://chromewebstore.google.com/detail/majhgbekihmliceijip...
It lets you open links in a side panel, so you can quickly look at a page without leaving what you’re reading. I built it because I tend to open too many tabs when reading docs or search results.
It supports a few simple triggers. My favorite one is long-click: you click and hold a link, and the preview opens in the side panel.
Chrome recently added Split View that you open from the context menu. It works, but for quick checks it feels a bit heavy. You have to right-click, move the mouse, and pick an option.
With long-click there’s no menu. For me it feels faster, more intentional, and better when scanning lots of links.
Most of the work lately is about polishing these interactions and dealing with browser edge cases.
Basically personalized meal planning and grocery integration. Since the Show HN I posted a couple months back I've been incorporating user feedback to add things like meal prepping, better ingredient reuse across meals, and cooking style preferences.
One of the biggest points of feedback has been adding more grocery stores but I'm really limited by who has APIs to actually integrate with, which is basically just Kroger and Instacart. Walmart has an API but ignored my API access request. Would love to hear if anyone has ideas on how to approach this.
I'm working on brand new type of collaborative whiteboard that allows anyone (or team) to drag-n-drop items from their devices onto the board.
The problem I'm solving: On a team, people and their files are scattered everywhere.
Solution: A canvas that attempts to open (and edit) as many file types as possible (images, xlsx, pdf, docx, cad). This means you can have people and files on the same page.
It's the only whiteboard that can natively render docx and pdf so far; these can also be edited directly on the board without having to use dedicated software.
It has a built-in Drive where you can store/backup files that syncs across your devices.
There's a few widgets such as Kanban, sticky notes, cards.
And of course, there's agentic LLM (Gemini 3 Pro) that can take actions such as viewing the board, reading documents on the board, and editing items on the board. For example, you can tell it to read a pdf, then write a spec sheet (in docx), or create tickets on a kanban.
I'm launching a private beta next month if anyone is interested in testing it out and giving feedback.
I’m working on Reflect [0], it’s a privacy-focused app for self-tracking and self-discovery. You can track metrics, run self-experiments, set goals, view correlations, visualize your data, etc.
[0] https://apps.apple.com/us/app/reflect-track-anything/id64638...
I'm working on ffl (https://github.com/nuwainfo/ffl), an Actually Portable Executable (APE) that turns any file or folder into a secure P2P HTTPS link via WebRTC.
Like llamafile, it's built on Cosmopolitan Libc. Getting the full Python stack + WebRTC to run as a single APE binary was incredibly tricky to pull off, but the result is super convenient. I mainly built it to solve the pain of moving large files (logs, DB dumps) in and out of containers—now it's just one command.
The repo has a demo showing a round-trip transfer between Windows (x64) and Android (arm64) using the same binary. I hope you give it a try!
I'm working on Bloomberry, an alternative to Builtwith for finding companies that use a specific tech vendor/product/technology. Unlike Builtwith, it focuses a lot more on technologies that can't be detected solely from the front-end (ie devops tools, security products, CRMs, and ERPs)
https://github.com/smj-edison/zicl
Porting/reimplementing a Tcl interpreter from C to Zig, based on the design of Jimtcl. This is one of those sub-projects that started due to another project (folk.computer in this case). The biggest difference is thread-safe value sharing, and (soon to be) lexical variable capture.
But why? Right now folk.computer has about a 20% overhead of serializing and deserializing values as they get sent between threads, and it's also meant we can't sent large amounts of data around. I previously attempted to make the Jimtcl interpreter thread-safe, but it ended up being slower than the status quo. So, I started hacking on a new interpreter.
Commands evaluate, basic object operations are in place, but there's still a ton of work to do in order to implement core commands. It may even be good enough to swap in some day!
I am working on a casual/strategy game that will be released in the App Store very soon (followed by Play Store and others as I have time). https://tetranea.net/ It is a deck-builder, tile-placer aimed at an audience who wants a relaxing game with some challenge.
I built a universal live speech translating app.
I’ve been playing around with the Whisper models for a few years now. Last year I had an idea about how to run Whisper Large v3 in real time. That idea became ScribeAI.
Because the quality of transcripts was so high, much higher than I could get with Parakeet, I started to think about how it would serve as a good input for live translation. I played around with this and was surprised by how good the results is, I’ve used it to follow along political speech’s from foreign leaders and other content I’d have just never been able to consume before. You can translate by bringing your own LLM service API key or using the inbuilt Apple Translate models (for a completely offline experience).
https://apps.apple.com/gb/app/scribeai-transcribe-speech/id6...
https://saveam.app & https://planam.app (all WIP)
Basically building a read-it-later app and a work todo-list app to my personal taste.
I was screwing around with gemini-cli and vibe-coded (or vibe-engineered?) a git extension to turn commit history into a pandas dataframe.
Curious if anyone would find this useful: https://github.com/rbagchi/git-dataframe-tools
I’m working on a deterministic execution layer for AI systems.
The idea is to treat LLMs as constrained components inside explicitly defined workflows: strict input/output schemas, validated DAGs, clear failure modes, and replayable execution. Most “AI unreliability” I’ve seen isn’t model-related — it comes from ambiguous structure and hidden assumptions around the model.
We’re exploring this through a project called FACET, focused on making AI behavior testable, debuggable, and reproducible in the same way we expect from other parts of a system.
Still early, but the goal is simple: less magic, more contracts.
I'm working on a tool in golang to handle requesting access to private and sensitive databases in Postgres. The goal is to help orgs reduce handing out long-lived postgres creds with broad permissions.
The flow is you declare the databases and tables you want to access and the specific permissions you want, an operator reviews it, if accepted it generates a temporary postgres user with those permissions you need. Also, all the connections to the database are proxied through the app, so the domain name and port are random and short-lived, so you don't expose internal database hosts. As an extra, all SQL statements during the user sessions are logged if you want to see that.
It's available at https://github.com/yungwarlock/pam_postgres
My primary goal of this is to drill myself as a product engineer working on a technical product.
Building https://lenzy.ai - helping products built around chat with AI (think Lovable or Cursor) reduce churn and prioritize product improvements by analyzing their user's chats.
I started about 2 months ago, found 2 early adopters and focusing on making them really happy.
Codorex (https://codorex.com) - Kids describe games in plain English, AI generates playable HTML5/Canvas code in seconds.
Built it for my 10yo. Solo dev, .NET + Claude Haiku. Free to try, no signup.
I added Nvidia PhysX to GameMaker. https://youtu.be/CNy4D0Kfu34 I have a public alpha launching in two weeks, so this video is unlisted at the moment. Nervous but I'm pretty happy with the current API.
I'm working on a collection of stackable interactive slides for teaching numerical methods and operational research.
https://okaleniuk.codeberg.page/blackboard/
The idea here is, one can pick the slides they want and arrange them into a sequence right in the URL. This way, there is no registration, no user data collection, no persistent state even. You just pick the slides, teach your material, and move on.
It's very raw, I still want to add a convenient sequence constructor, a "blank" slide so you could display your own content in it, and a similar quiz page. But I already used some of the slides for teaching, students seem to like them.
Hopefully, I'll have the rest done by the beginning of the spring semester.
Working on a browser extension that let's you take notes right on youtube.
Chrome: https://chromewebstore.google.com/detail/video-notes/phgnkid...
Firefox: https://addons.mozilla.org/en-US/firefox/addon/video-notes-f...
I recently open-sourced my first ever tool! and I'm super excited about it guys
It's an HTTP request replay and comparison tool in Go. You can replay real traffic, compare multiple environments, detect broken endpoints, generate HTML/JSON reports, and analyze latency
It’s currently at v0.4, so I’d love any feedback, suggestions, or ideas for improvements. (Be gentle, I haven’t used Go professionally, however it’s my main language for personal projects )
https://github.com/kx0101/replayer
Here's the landing page too: https://www.replayer.online/
Working on Tenderlane: https://tenderlane.app/
Freight forwarders spend days or sometimes even weeks understanding and answering tenders without even knowing if they'll win the bid!
With Tenderlane, they can now upload the entire tender spec and get an overview of what the customer wants in minutes instead.
One key learning for this project is that I'm using Excel as the "frontend" as this is what our users are most familiar with, so lots of processes involved filling, uploading and downloading an Excel file.
Building this with Elixir/Phoenix LiveView.
On a dedicated language analysis model. For starters, it will detect a text language in microseconds. For comparison, a popular LLM takes 100 ms (10 tokens per second) on a full GPU to analyze one token; this new project processes a token in ~100 ns on only one CPU core!
Working on increasing the knowledge about the watch industry. I just posted an article about how Swiss Super-LumiNova® is made. https://www.thenakedwatchmaker.com/making-swiss-super-lumino...
Trying to figure out how this platform works as well. :))
Volatility Regime Prediction via Causal Discovery in Option Markets - https://github.com/philippdubach/vol-regime-prediction/blob/...
Volatility regime models (Markov-switching GARCH, regime-switching stochastic volatility) are ubiquitous in finance. However, they share a fundamental limitation: regimes are identified ex post from return dynamics, providing no predictive power for regime transitions. The standard approach fits a Hidden Markov Model to returns, labels high and low volatility states, and estimates state transition probabilities that are essentially unconditional averages. This matters because the economic value of volatility timing depends entirely on predicting regime changes before they occur. A model that identifies regimes only after observing the returns is useless for trading volatility.
Existing research documents regime-dependent behavior but does not identify causal drivers of regime transitions. The papers on volatility forecasting factors, variance risk premium dynamics, and market instability from option flows dance around this question without directly addressing it. The recent work on causal ML in finance (double machine learning, causal forests) has focused primarily on equity return prediction rather than volatility states. The connection between options market variables and subsequent volatility regime transitions has not been rigorously established through causal methods.
We develop a causal framework for volatility regime prediction using option-implied variables as potential causes of regime transitions. The key insight is that options markets are forward-looking, so information embedded in the implied volatility surface, put-call ratios, option order flow, and term structure slopes may causally influence future realized volatility regimes rather than merely correlate with them.
Currently building a robust dataset.
I am building a luxury villa park from scratch in Kuta Lombok Indonesia:)
I wanted to try my hand at something else than software.
A web app platform written in Rust with the primary focus on zero-dependency apps and using Pingora as a forward and reverse proxy. Targeting Hetzner for hosting and Cloudflare for DNS. I love Rust but don’t like the long compile times which led me down this rabbit hole (zero dependencies make for fast compiles).
I keep on grinding on my Kubernetes IDE that allowed me to quit my day job over 3 years ago: https://aptakube.com/
I’ve also been playing with Bun and I have a business idea that would be a good fit, and huge potential but I just don’t have enough time to start something new anymore.
At least in principle, I'm still working on PAPER (https://github.com/zahlman/paper). (Or I should say "resumed"; I was having a rough time of it mentally in the summer through October or so and didn't really get any actual coding done.)
This has most recently involved a side diversion into a little tree-processing library (where file hierarchies are a special case) — Show HN within the next day or two, fingers crossed — and setting up a fork of https://github.com/pypa/packaging to support EOL Python (back to 3.6) and make some general simplifications (because even this is a fairly large wheel compared to the target project size).
Hoping I can kick myself back into the blogging habit again soon, too.
An Obsidian plugin that makes life tracking easier: https://www.dsebastien.net/announcing-life-tracker-a-new-obs...
Still working on Librario, a simple book metadata aggregation API written in Go. It fetches information about books from multiple sources, merges everything intelligently, and then saves it all to a PostgreSQL database for future lookups.
You can think of it as a data source, or a knowledgeable companion that can provide comprehensive book information for online booksellers, libraries, book-related startups, bookworms, and more.
I got a pre-alpha build running for those that want to test it out and the code is out on SourceHut[1].
Been really tough to find time to work on it because I have a baby that only sleeps in my lap, but I’m making progress very slowly.
I recently hired someone to rewrite the entire database layer, as that was written with the help of an LLM for the prototype, which should improve things too.
Feedback is very welcome :)
I'm working on a beginner-friendly online programming language for teenagers who want to learn to code. I think there is not a clear enough winner for what teenagers should do after they learn Scratch so I am trying to make it.
I am working on Correctify's Design Studio, a feature that turns plain restaurant menu text into menu designs based on your choosen size, style and branding.
What makes it different from alternatives is that it’s content-first. Instead of dragging boxes around or fighting templates that don’t fit your menu, Design Studio designs around your text. For restaurant owners, that means significantly lower waiting times and costs.
Design Studio is still in private beta, but excited about where it’s going
https://correctify.com.cy/blog/posts/meet-design-studio-the-...
I’m working on Lunara AI: https://lunaraai.app
It’s a meditation app where an LLM guides you without the usual back-and-forth chat. You set your preferences up front (style, duration, focus), then it delivers a structured session end-to-end.
I have a long list of ideas and features to try, but right now I’m focused on feedback. The app is live on the App Store, and I’d love input on: • What would make you try an AI-guided meditation app (or avoid it)? • What settings matter most to you (duration, tone, technique, background audio, etc.)? • What would make the guidance feel trustworthy and not “chatty” or generic?
If you’re willing to test it, I’m especially interested in first-session impressions and what you’d change to make it something you’d actually keep using.
https://www.youtube.com/@dodo-oss/videos (no homepage yet)
I've building PaaS focused on development environments. I think there are so many things to be improved all throughout the development process:
1. starting from creating new ones
2. forking existing one (like one would do with the git repo) to experiment with new ideas or debug the issue in an isolated environment
3. being config defined and reproducible
4. hybrid by default - run as much or as little one desires on their personal machine while keeping rest of the env (db, storage, ...) in the cloud
5. easy to share: expose services (HTTP/TCP/UDP) on public or private networks
6. have any number of AI agents with specific goals be part of the dev env
Several years ago I wrote an internal tool named Fogbeam Universal Competitive Inteligence Tool (eg FUCIT). It was up and running and doing it's job for a while, then a lot of stuff happened and it kinda fell into disrepair. It's a Grails app and the original Grails version was something like 2.2.3 and I think it was running on Java 1.6 or something along those lines.
Anyway, for a lot of reasons that don't matter now, the time has come to rebuilt | reinvent | reinvigorate this thing. So for the last week, I've just been working on updating dependencies, fixing the resultant breakages, and also fixing miscellaneous bugs that had never been fixed (or possibly even noticed) before.
As of today I have most of the base functionality up and working again. I just got all the Quartz scheduling stuff set back up and now I'm testing the scheduled job that fetches data from RSS feeds and creates associated records based on the contents of those items.
Up next: test|fix some functionality around defining "semantic assertions" about entities in the system (using Apache Jena) and then I'll at least be back where I was.
After that, I have some UI improvements to make (the UI now is basic GSP pages with Bootstrap and jQuery), and then some GenAI integration stuff. Beyond that: who knows?
Besides that...
Ref this thread: https://news.ycombinator.com/item?id=46252283
I did pick up Volume 1 of "The Handbook of Artificial Intelligence" earlier this afternoon and read about 25 pages. I've also been working my way through "Parallel Distributed Processing - Volume 2" and "Principles of Semantic Networks" for the past few weeks, so continuing to grind on both of those as well.