alt Hacker NewsAsk HN: What are you working on? (September 2026)
What are you working on? What have you been curious about lately?
Comments
I'm building editor and flasher for BMW engines maps (n13, n20, n55, s55, b58, s58) and TCU maps (ZF8HP45 and ZF8HP50) as well as a remote access ENET IOS and Android app.
I am building OtaKit.app, a cheap, fast, and simple CDN-based over-the-air updating tool for Capacitor apps (and soon for React Native too)
A local AI-adoption consultancy business for SMBs where the differentiator is I physically show up at your office and actually talk to your team. With the slopification of cold outreach and social posting, I think the future of business development is going to be very personal.
Im working on my own coding agent soon to be released.
While you might think "yey another coding agent" i went down some very different paths than other open source coding agents do right now. Ill not bore you with a ton of detailed breakdowns and rather list the main points that are relevant to understand why/how i build it.
Premise:
-The agent is meant to run against selfhosted environments first like Ollama etc with a focus on non cloud sized models, it should work properly on something like a 27b model already
-The agent with full intention trades execution time vs reasoning and result quality
So what does it do different:
1. The agent, instead of trying to let the model solve a whole task in 3-5 inferences, rather breaks down the "thinking process" in smaller chunks, basically decomposing the task into smaller tasks. While this is not a completely new concept, the agent will break it down to really simple single step variants which even for a smaller model can properly be solved. This involves not just file editings but all points along the way from interpreting user message to planing a task to defining acceptance criteria etc.
2. The agent is build in a way that it, apart from some fixed steps such as detect user intent at the beginning and synthesize response at the end, it will by itself decide what is the next proper step to execute/do based on the context i provide. While doing so the agent also revalidates its current execution and if it spots that, given the information i collected since it planned and started running, the current plan is not detailed enough or is missing out due to something he didnt "know" when he was planing, the agent will dynamicly mutate the coming plan stats, as in restructure/decompose/etc in order to have a properly layed out route to fulfill the task.
3. The agent has a rather complex system of how his context is composed which is combined by things like the chat history, previous step results, a backlog of what "single steps" it has done (updated file x , read range from file y etc) and in that it is strongly reason driven, so it will for most of the things it does also provide a small reason explaination for why it did that. Than the agent also has a working memory that contains facts and decisions it made along execution. There is more but thats just some thingsd to mention. The whole memory system and context is rather complex (tho not complicated). When i release it ill properly break down how all this works in the docs.
4. The agent provides full observability in the ui. At every point of execution you can basically in detail see whats in memory, whats the current composed context, whats the plan and what plan steps depend on what previous steps, you can look at artefacts it build and also you have basically a complete audit log of all single "actions" it has executed and can look into their details.
5. The agent allows to while in an execution send steering messages, meaning the message will be, using relevant current contextual information about its execution, send as inference with a prompt askind the agent to interpret on if its relevant, and how does it impact the current execution/plan. It than can decide either just do alter what it currently does, or even do a plan mutation in order to accomodate the users steering information.
6. The agent within its capabilities has a lot of error correction/self reflection logic. From dynamicly fixing json including a fallback to let LLM fix a response json, upon to if executions fail to much it will itself do a hypothesis on why this is happening, formulate a critique and with that reevaluate if it wants to try the steps again with the additional information, or if it wants to mutate the plan to accomodate the just spotted problems.
Theres quite some more i could list but i guess thats enaugh for now. The big trade off as mentioned earlier is execution time. In comparsion to cloud native agents, which will do giant editings and reasonings in just a hand full of inferences, my agent uses a ton of inferences. The big difference is that this allows (a) the agent to more precisly focus on specific tasks rather than overloading it with to much at once and (b) alot better spot problems/mistakes itself and adjust its execution plan to accomodate those without the user having to reprompt the agent 10 times until something is actually correctly solved.
Apart from the pure coding capability, the very same actions that allow for higher quality reasoning and coding at the same time allow the agent also be a good analysis and discussion partner.
So : what is it than used for if inferences and executions can take very long? Well for me its in terms of coding capabilities a hands off agent. Its meant to be informed once at the beginning with relevant details, and than should be fully capable (as long its in the capabilities for sure) to fulfill the task without the user having to permanently keep an eye open. I want to free time for myself and not change my time from coding to prompting.
Ill wrap it up here and say : the Agents name is "Loa" and i probably will post it on hackernews as soon i got a relatively stable beta to release. Im close to being fine with a beta release but i want to test some more runs before i publish.
we are building https://www.d5s.tech, using our own software to automate our own company (the boring bits)! having a blast doing it and steadily automating more and more
and... whenever i have some spare gpt-6 astra left i am working on a R.U.S.E reimplementation alongside some other threejs experiments
I've been working on https://searchforjobs.app/ I'm trying to add the resume creator for using the right keywords for a job posting. I'm also trying to add more data visualizations are more job posting sources to scrape.
Build one of the best emoji sites there is.
- i dropped a neural net jane street puzzle (https://huggingface.co/spaces/jane-street/droppedaneuralnet) very good mindbreaker, learned a lot of new things on the way
I'm further along in my funemployment project:
https://github.com/mcdirmid/cleanroom
So far I have bazel macros up that can produce tested code with a ~30GB MoE model (Jundot/Qwen3.6-35B-A3B-oQ6-mtp, I can get ~90 toks/sec on a M3 Max!) using cleanroom separate implementation and test development (and then comparing them until both are correct). Over the last month, however, I found that my bottleneck is in the specifications: as I further divided my components into separate parts (since smaller components are easier to write and test), I started hitting problems with specifications becoming badly ungrounded (code depending on knowledge they cannot access, so something is just hallucinated).
So I redid the format, e.g.
https://github.com/mcdirmid/cleanroom/blob/main/update_with_...
The spec format is designed to be declarative and very modular, and ya, an LLM is primarily writing the specs as well, so I hope to create some sort of formal reasoning framework that the specification can be translated into (by an LLM) so that ungroundness feedback can help the LLM write better specs. Also, I found that it really is much more robust to change/refactor/add features via the spec first and then align changes down to test and code, then to make changes to the code directly (even without using the system, just asking a frontier model to look at the guides and do the alignment itself directly).
I think I'll be ready to do a release over this next month, which means:
- Supporting a build system other than Bazel to express DAGs. Honestly, this could be anything, I just chose Bazel for convenience (easy to express graphs in Starlark), but it assumes a monorepo world that I don't think many developers use.
- How do I even package this? The advance of using Starlark is that I can generate python code to call into the generated python code directly. If I move away from that, I need to figure out what this really looks like as a binary.
- More demos. Right now my only project is the code for the system itself (the classic "the first program of a language is the compiler for the language"). I just can't think of many interesting things to do in Python that aren't agent related (I can support other languages, like Java, Typescript, or even C++, but I'm hitting choice paralysis).
RSS Bot for Telegram: learns what you like, searchable, using free models (vibe-coded): https://github.com/amb007/rss-bot
I haven't been working on it as of late, mostly because i'm a bit deflated from software in general, but I started working on a programming language I called Grasp.
If lisp is a list processing language, grasp is a graph programming language.
The idea was that most other data structures can be represented with a graph ( adjacency matrices are matrices, a tree is a type of directed acyclic graph, a list is a graph where each node connects to at most two nodes, etc) and so if you designed a programming language where the language is itself a graph, much like how lisp is itself a list, you could get other esoteric programming languages like APL, forth, lisp, and so on as DSLs of Grasp. Also any program you write would be its own CFG.
I started it but honestly its mostly a hot mess of vibe-coded garbage. But I may get back on it and try to clean it up.
An Openclaw, Hermes Agent type system that is meant to be ran on a home server, built in Rails with a Tauri 2 front-end.
The 2026-27 soccer season just started.
If you love catching up on highlights, check https://thepelota.tv/
It’s like Netflix but for soccer highlights, with all the major leagues in one place as soon as they are available on YouTube, all free and no ads.
Don, a work companion.
Don helps you set goals.
Don reminds you to take breaks.
Don checks in how you fell.
Don judges you when you go off track.
Don celebrates you when you get stuff done.
I just released an open-source AI pipeline that turns GitHub issues into merged PR's. It uses your Claude Code CLI subscription.
Looking for feedback from people who already run Claude Code and are testing out new AI software factories or tools.
Try it here https://github.com/Team1-dev/Team1-Factory
Please only run this on a VPS or isolated environment and not on your personal machine as it runs with full permissions.
i am working on a really cool word game that has a TUI graphical style, it looks like a roguelike but has a bit more going on. i also seem to have figured out a way to do automated "fun factor" testing and get bugs/frs that sound like real player feedback, as a little bonus treat. doesn't seem like anybody is attempting that kind of thing with agents, might try to codify it. trying to spend a lot longer thinking about a game's systems/meta and developing slowly vs. hypersprinting which is fun but exhausting.
Optimem, a spaced repetition learning app that aims to be a user-friendly alternative to Anki. Or a more effective version of Duolingo.
I'm working on SpecPilot (https://specpilot.dev), a spec-driven development layer that sits in front of Claude Code, Cursor, Copilot and the rest. It deliberately doesn't generate code. It scaffolds a .specs/ folder and hands the actual writing off to whatever agent you already use, so the specs become the thing the agent is held to instead of a prompt you retype every session.
Open source, free, no login, nothing to sell. I'm not trying to build a business on this. I just want agents to write better code, and that only happens when they have something firmer than a chat prompt to work against. CLI is here: https://github.com/girishr/SpecPilot
It started as a TypeScript CLI in January. Enough people told me they either didn't want a CLI or didn't know how to use one that I rebuilt the front door as a guided chat: 27 questions, runs fully offline in the browser, outputs the .specs/ tree plus an onboarding prompt for your IDE.
Recently shipped an MCP server so the agent can run the questionnaire itself rather than the human doing it, published to the official MCP registry and Smithery. Next is brownfield: point it at an existing repo and backfill specs from the code. Honest state of things: the Product Hunt launch got 4 votes and around 100 visitors, and I had no event tracking wired up, so I couldn't even tell how many of those generated anything. Fixed since. Usage is small but real, and it's coming through MCP rather than the web app, which I did not expect.
The part I keep circling back to is that spec generation is easy to copy. Spec enforcement is where the value is: checking a diff against the spec and failing loudly. Feedback welcome, especially from anyone who tried SDD on an existing codebase and gave up.
Writing an article about compacting garbage collection for my website.
Lots of things really:
1. Aetheris: geometry CAD kernel, https://github.com/yuechen-li-dev/Aetheris/.
Full code CAD capability with big coverage already and some functionalities that even OpenCascade/Parasolid/ACIS doesn't have, full sheet metal module, programmable part assembly, analytical fillets/chamfers, mathematical knots, auto-route for piping, built-in finite element analysis, etc. Had Astra make an improved version of the V8 demo that was going around on LinkedIn, so it can do general hard surface modeling pretty well too, turn all the Astra demo prowess into reusable capabilities/templates. The DSL is human writable too, so give it a try if you want. https://aetheris-editable-v8.yuechenli.workers.dev/
2. Concept language: https://github.com/yuechen-li-dev/Concept
I've said before that Carbon isn't a real programming language, never mind a successor to C++, so I decided to put my money where my mouth is. The idea of it is to be more TypeScript to C++'s JavaScript and to generalize C++20 concepts from template constraints to what C++26 is doing with contracts, and bring the equivalent of Rust's borrow checker to be opt-in by default instead of opt-out, fast compile time, in a syntax that C++ users are already familiar with (`const auto` instead of `let` for example) as well as templates and comptime. Language is done-ish, not self hosted yet, still compiles to C11, kernel and allocator libraries are finished, currently working on the scheduler right now.
3. Copeland TS, https://github.com/yuechen-li-dev/copeland
TypeScript for .NET without all the weirdness of Javascript, with full Nuget and NPM inter-op, Rust style exhaustive `match`, templates, etc. It's actually weird how much cleaned up TypeScript ended up looking like cleaned up C++. Compiles to JS, C#, WASM via Blazor WebAssembly, and SPIR-V via HLSL/DXC, and runs on V8 for JS and RyuJIT/NativeAOT for C#. The conclusion is that RyuJIT ended up being ~2x faster than V8 JS in hot loops but the cold startup time is higher, so replacing JS for UI really isn't worth it. Comes with full UI layout system, Vulkan renderer, and game/app runtime, but those are still pretty rough.
On a mission to prove you don't need YC to be successful.
api for building apple and google wallets. launched it after ppl kept asking for one on the consumer app (launched on hn too) and gave it a shot. now it does enough mrr that i dont have to go back to work.
*walletwallet.dev
ssh sshfighter.com
Been optimising an ssh ansi rendering engine for six months, starting to look great. Homepage is slop please forgive
Trying to reduce my doomscrolling IG and FB usage
I created https://getnoloop.com to block the feed on iOS
I took this existing 3d printed animated Frankenstein head: https://www.printables.com/model/620191-frankenstein-head-wi...
... and used Claude to crank the software up to 11. Network management console, RESTful API, added hands hands to the pupils so it serves as a clock, NTP, added sleep mode at night, added different eyes, OTA firmware updates, and more: https://github.com/michael-gebis/creeper-eyes
It's ridiculous and I love it.
Reverse engineering the hardware and firmware of a Sony A7 IV camera.
Making rent as an open source developer.
Desperately trying to attract new monthly sponsors and people willing to buy me the occasional pizza with my terrible HTML skills. Is it working?
If any individuals, companies (or bitcoin millionaires) would like to help a long-time OpenBSD slacker, unslack, I'd really like to focus more of my time on open source development (and advocacy), rather than making rent. Feel free to contact me.
https://brynet.ca/wallofpizza.html
(Native SegWit): bc1qwe6zv0ezq4gzlea6tw45qhsn5kckheljn0krvt
Baking eggless applesauce oatmeal cookies and chocolate chip cookies.
porting librespot to C using Zephyr RTOS. Mostly vibecode, to see how far LLM can go.
working on building a way to make me me one of the best trader helper nexalione.com
finding simple bipartite expander graphs for better LDPC (expander) codes
lexera, a kanban board with full multimedia and document include support that saves to markdown, exports to marp to manage teaching materials. it also started out to be my editor of choice for agentic programming as each task is a card. hopefully i will manage to create a page and visible materials soon!
I am working on these open source projects:
https://github.com/office-42/word42
https://github.com/office-42/math42
I am learning math logic and two languages to use it: TLA+ and Lean.
I'm making a language. Its name is Pergyra Lang, and there's nothing particularly special about it.
I was curious if AI agents could go beyond just making SVGs and create entire skits with them.
So I built a platform to do that. Results were meh until Astra, so I finally open sourced it last weekend.
I'm working on an arcade joystick with full analog capability using a Hall effect sensor. It's along the lines of the Ultimarc Ultrastik, which I'm currently using, but it has so many shortcomings that I decided to build my own. I decided to go with a rp2350 microcontroller, and it will have inputs for 16 buttons, and outputs for RGB leds for every button. It should be a direct swap for any enclosure designed for a modern Sanwa stick, which it's based on.
I want to try again using AI to build an app, and also learn some Rails. I consult at a company that uses ServiceNow for change control and it's absolutely horrible, and they have busted processes atop it. I dream of a change control app that has templates, has better visual indicators of an RFC's stage in the workflow and exactly what needs done to push it along, and just something that doesn't suck as much as SNOW.
i don't know what to do in my 27 age
I'm working through: https://modernaicourse.org/.
I appreciate that it makes me revisit some math which i've forgotten like directional derivative and why gradient points to highest ascent.
Interesting but hard as well.
i don't know what to do in my 28
https://github.com/amir734jj/symmetric-crypto-chat-room
Share an encryption key with someone offline, then chat with them (text + voice + video + file) encrypted with that key. Your JavaScript browser only knows that key. Nothing is shared. True end-to-end encryption in your browser.
I've been doing a bunch of stuff with using a PUT[1] to simulate an IF (Integrate and Fire) neuron[2]. Right now I'm experimenting with variations of pulse-width and frequency of the input spike train, seeing how that affects when the "neuron" fires. In a future step I'll add a resistor to bleed off some of the charge from the timing capacitor, to make it more of a "Leaky Integrate and Fire" neuron.
And then ... well, we'll see. I'm also reading a lot of books and stuff on neuroscience, neuromorphic computing[3], analog computing, etc. I don't have some "grand unified theory" or anything, just playing around in this space.
There's a lot more I could say about this, but I'll save that for a blog post or something. That said, if anybody wants to see some pictures and read some write-ups of some of this stuff, add me on LinkedIn[4] and you'll see some of that stuff in my activity there.
EDIT:
What the heck, here's a picture for anybody who's interested.
https://fogbeam.com/images/scope_20260913_202613.png
The magenta trace is the "spike train" which is output from a Rigol DG4162 Function Generator. The yellow trace is the voltage at the anode of the PUT, which simulates the "action potential" of the neuron membrane. And the cyan trace is the cathode of the PUT, which simulates the output of the neuron. What we see here are several input pulses hitting, with each bumping the action potential up a little, until it finally hits a threshold and then "fires" and resets. Lather rinse repeat.
[1]: https://en.wikipedia.org/wiki/Programmable_unijunction_trans...
[2]: https://neuronaldynamics.epfl.ch/online/Ch1.S3.html
LumifyHub.io
I’m working on a 52-part series about retention.
Each week I research one part of retention, teach it, and apply it to two real-world products I built.
I’ve published five lectures so far, and think the series should be useful to anyone here building a product: https://www.youtube.com/playlist?list=PLFp5nmjrQeug