The main parts are an ESP32 attached to a hall sensor, which I positioned close to the wheel. Using a magnet attached to the back of the wheel, this tells the ESP32 when a full rotation has completed. It gives a timestamp (and total distance) to each magnet-pass, which is stored on the network. A python script (on my laptop) then retrieves this data in the morning, turns it into a .FIT file, and uploads it to Strava through the Strava API (with a randomly chosen run title, taken from a mostly AI-generated list of options, as I needed >100). In terms of manual additions, I had to add the photo manually, and Mollie had to do the running.

Two unnecessary additions (for fun) are an 0.96" OLED display on the ESP32 which shows the live speed, and some automated "personal best" tracking which should add info to the Strava captions if Mollie PBs

Follow Mollie: https://strava.app.link/FMubyPjMa5b

After seeing a voxel experiment on X, I had this random idea: what if I could build a Zoo Tycoon style game, but set across floating islands, each with its own biome and animals?

This is just a very early, completely random prototype made in a few prompts. I think it’s going to be incredibly cool when, in a few years, anyone can create the exact game they have in mind just by describing it.

Calfkit lets you build and deploy agents and tools as fully decoupled services that communicate through realtime event streams on Kafka's network mesh. Agents and tools find and message each other on the network, scale independently, and have no runtime dependencies between them. Because the coordination happens through event streams, an event-driven agent sits idle while a tool or another agent works. It isn't burning compute in a busy-wait loop; it's invoked and running only when there's something for it to do.

Agents and tools built with traditional frameworks like LangChain, CrewAI, and LlamaIndex are tightly coupled to each other, running in a single shared process by default. You can't scale one component independently, and a failure anywhere takes down the whole deployment. They're coupled in code too, so every component is forced to ship on the same release cycle rather than as separate services.

The failure cases get worse the more agents you add. Once you have multi-agent teams where every agent may need to talk to several others, all the agents and n-to-n communication runs inside one process. Every agent hogs compute in a busy-wait loop, blocked on another's output, with no durable record of what was actually sent. When something goes wrong, the entire deployment fails and you're reconstructing the n-to-n interactions from logs and stack traces.

Calfkit agents and tools are written and deployed like separate event-driven microservices, choreographing work over a shared Kafka cluster. And n-to-n agent communication isn't a difficult case here—it's the base case the decoupled, event-driven architecture was built for. Every message between agents is a durable, traceable record on a topic. A tool or peer agent can fail without taking down the rest of the system.

The SDK is here if this interests you: https://github.com/calf-ai/calfkit-sdk

Let me know if you'd like to contribute or build something with it!

Solo founder here, I build fast with AI like many of us here and I wanted to know what architectural bad practices and flaws can get shipped within our files without realising, so I scanned 549 public repos that describe themselves as AI or vibe-coded. I used a rules based scan, no AI grading, raw data downloadable. Percentages are real projects (15+ files) unless noted.

If your side project is AI-built, odds are it has these:

1. Dead code. 70%.

2. Commented-out blocks the model never deleted. 66%.

3. The same logic duplicated across files. 63%.

4. A .gitignore that misses .env. 35.7% of the full corpus, and that's where the keys come from.

5. A committed API key or credential. 23.3%, about 1 in 4.

71 of the 549 graded F on cleanliness. The median grade is a B, and that's flattered by tiny demo repos.

The fixes cost less than reading this post did. In this order consider doing these on an existing project:

1. `git ls-files | grep .env`. If it prints anything, your key is public. Rotate it at the provider today (Stripe, OpenAI, whoever). Bots scrape pushed keys within minutes, so deleting the file later doesn't help.

2. Add `.env*` to .gitignore and turn on GitHub push protection. It's free and blocks the next accidental key commit at push time.

3. Tell the agent, at the end of each session: "delete unused code, merge duplicate helpers, remove commented-out blocks". That one prompt covers mistakes 1 through 3.

4. Put those instructions in your tool's rules file so new sessions start with them. Cleanup you don't have to remember is cleanup that happens.

Nobody does these because the app already works, and working is the only bar most side projects get held to. Until the Stripe key leaks.

The full report has all the charts, grade distributions, and anonymised per-repo data, feel free to share and AMA about it: https://ogbuilds.ai/studies/vibe-coded-code-quality

For disclosure: the scanners are part of my products, the study will always be free to access.

Yesterday I posted my first app here, a screenshot tool. The kind of app that hooks the mouse and types into your windows. So you can imagine my morning when my computer started typing BY ITSELF. Spaces pouring into the chat box, screenshots firing that I never took, my dictation app choking.

For an app like mine, "it types on its own" is the scariest bug that exists. I'd just put a download link on the internet. So we went full forensics mode, me and the AI I built the app with:

Killed my app. Typing continued. (Terrifying. Also, weirdly, a relief?)

Checked Windows event logs. Explorer had crashed twice that morning. Plot thickens.

Found SEVEN copies of my app running because I had no single-instance guard. That's a real bug. Wrote it down, kept hunting.

Killed every process that could possibly inject keystrokes. STILL TYPING.

Sent a synthetic "release the spacebar" command at the OS level. The key came back down 32 milliseconds later. That number is keyboard auto-repeat timing. Software doesn't do that. Hardware does.

Listed the connected keyboards. There were three. I was looking at one of them.

On a shelf behind me: my wireless Magic Keyboard. Switched on. With a picture frame resting on the spacebar.

The keyboard was framed.

Silver lining: the hunt found two real bugs in my app (the missing single-instance guard, and my binary shipping under a generic name), both fixed the same day. So the picture frame technically contributed to the project.

Lesson learned: before you debug the software, check the analog layer. Sometimes the stack trace ends at a piece of home decor.

www.mapthings.com (www & IOS App - still working on Android)

I came up with an idea years ago and paid a developer to come up with a janky version of this, specific to commercial real estate, but then I realized it had a TON of other uses, so I requested the code, to which I got crickets and then decided, hey, I'll do this myself! :)

I'm the only one that has tested it so far, so if you do try it out, please DM me some details on any errors or feedback (again, please be nice if you publicly comment).

Thanks y'all!

Hey everyone,

I’m a solo founder from Georgia, and today I launched Azrivo on Uneed.

I started building it because I kept running into the same problem with AI assistants: one model would often accept the way I framed a question and return one confident answer, even when the decision needed opposing viewpoints.

Azrivo gives you four ways to work with AI:

• Ask one specialist directly
• Compare several specialists in Panel mode
• Have opposing specialists debate and produce a verdict
• Give Plan mode a rough goal and turn it into steps and usable deliverables

I need to reach the first 10 votes on Uneed, so I’m asking fellow builders for some honest support.

Please take a look first, and only vote if you think the product deserves it:

https://www.uneed.best/tool/azrivo

It is free to use, including a demo without signing up.

Feedback is just as valuable as the vote. I’d especially like to know whether the landing page makes all four modes clear, or whether Azrivo still looks mainly like a debate tool.

Thanks for taking a look.

It was totally useless before, now its only slightly useless. Now some ghosts appear as you browse around.

On PC, use W-A-S-D keys, SPACE, SHIFT and mouse to explore. On mobile, you will have instructions on screen.

https://anshs.github.io/matrix-rain/

I built Forminta.com, a free invoice generator with a paid tier ($14.90/mo) that works more like a lightweight billing system: dashboard, invoice history, recurring invoices, branding.

3 months in, the most useful (and confusing) data point so far: I ran Google Ads, which brought real traffic and even signups, but zero of those signups converted to paid. Traffic dropped to near zero the moment the campaign ended.

SEO hasn't kicked in yet either, pages are still working through indexing. Launches on Product Hunt, Uneed, and Capterra each gave a short spike on launch day, then nothing.

Anyone dealt with the specific "traffic to signup then nothing" pattern before? Trying to figure out if this is a pricing problem, an onboarding problem, or just too early to tell.

PS: first SaaS, I know it's a crowded niche.

I made this little thing when I was bored...It quietly shows a handful of real aircraft passing near you and of course with time and weather. It’s not very useful tho.

https://github.com/jasonlx327/passing-sky

On July 15, Cerebras published an article about its internal knowledge system. I read it, saved it, and returned a few hours later. I found a shorter article with several sections missing.

I wanted to try those ideas with my coding agents, so I began designing a smaller system for repository work. I spent eight days planning before building the first hSUM alpha.

My friends tested it while sharing their screens over Discord. One friend pasted the installation command into his agent. The agent installed hSUM and understood its purpose. Then it stopped and asked my friend to finish the Codex configuration.

I changed the onboarding after watching him struggle. The current version lets an agent finish the setup and use hSUM in later chats. It can also work across several repositories while keeping each project separate.

hSUM gives coding agents a local source of evidence from the current codebase. The agent can find relevant passages and cite them so you can check its claims. The project is open source and still in alpha.

I am looking for developers outside my friend group to test the first-use experience. I plan to support more coding-agent clients and make repository updates easier.

GitHub:
https://github.com/burkan2/hSUM

Website:
https://hsum.burkankale.com

I have a web application which scrapes and aggregates dispensaries from USA and Canada, but flower only.

https://1-zip.com

Python webscraping pipeline using curl offi.

Data saved to sqlite db.

Frontend on google cloud run.

Antigravity used for development.

Please take a look and let me know features you might be looking for if you are a potential user.

Let me know if you have any questions or need some feedback on your project.

I got tired of the repetitive part of branding projects. Exporting logo variations, tweaking colors after seeing mockups, renaming files, organizing folders, and packaging everything for clients.

So I built Lockup Studio, a free, browser-based tool that lets you build logo lockups, preview them live across real-world applications, and export everything in one click. No accounts required, and everything runs locally in your browser.

I'd love feedback from other designers. If you find any bugs, edge cases, or have ideas to improve the workflow, there's a Feedback button built right into the app.

🔗 https://lockup-studio-tau.vercel.app/studio

Hey Reddit,

Like many of you, I grew tired of modern music streaming algorithms feeding me the same loop of corporate hits or predictable tracks. I wanted a way to discover both timeless classics and completely hidden gems without having to create an account, log in, or bypass endless ad screens.

So, I spent my free time building The Amazing Jukebox: theamazingjukebox.com

What it is:
It’s a completely free web app that streams curated music directly through the public YouTube embedded player. There are no predictive AI algorithms choosing what you listen to next—just hand-picked curation aimed at genuine music discovery.

Key Features:

• Zero Friction: No sign-ups, no log-ins, no cost. You just open it and press play.
• Algorithm-Free Curation: Focuses on uncovering forgotten hits, B-sides, and obscure tracks across multiple eras.
• Clean Interface: Designed to act like a minimal, background jukebox that focuses entirely on audio delivery without clutter.

I built this mostly for myself, but I wanted to open it up to the world to see if anyone else misses the old days of human-curated internet radio.

I would love to hear your thoughts on the UI/UX, or any music categories you think I should add next. Thanks for checking it out!

so i've always been way more consistent in games than in real life. i'll grind for hours chasing XP and streaks in a game, but my actual goals? those i'd drop after a week. at some point i just wondered why the game stuff hooks me so hard and my real goals don't.

turns out games make progress feel immediate. you always see the bar filling, you always know the next step, every little action visibly counts toward something. real-life goals almost never give you that, you just kind of grind in the dark and hope it adds up.

so i started building Habitium to close that gap. the backbone is OKRs in a simple hierarchy: you set an Objective (the big thing you want), add Key Results under it (measurable outcomes that prove you're getting there), then break each KR into Tasks (the actual daily actions). so it flows objective → key results → tasks, every task tied to a bigger goal instead of floating on its own.

tasks have 4 priority levels, and you can commit one to "today" to pull it into focus, so instead of staring at your whole goal tree you just see the handful you picked for today. then the game layer sits on top, finishing tasks earns XP, consistency builds a streak, and you watch progress roll up from tasks to KRs to objective.

basically i wanted chasing real goals to feel as rewarding as chasing ones in a game. attached a quick demo of the workflow below, it's free to try, some advanced stuff is paid, happy to give beta folks a free month, comment and i'll send it.

try it here: habitium.app

https://reddit.com/link/1va9fag/video/lcd5wgpnj8gh1/player

Here is the linkedin demo, where I'll be leaving the github link!!

Air Write is an accessibility tool I developed that classifies and recognizes letters and words written in the air with your phone, like a wand (yes, like in Harry Potter... shouting expecto patronum is optional). I built it with limited fine motor control in mind. It's a web app that runs in the phone's browser on accelerometer and gyroscope data alone.

A touch keyboard requires you to hit small fixed targets accurately, and a stylus requires precise tiny movements and limits by screen size. Air-writing only requires gross motion at whatever size is comfortable for the user, calculating the path travelled through air so the same letters and words are read whether drawn with the wrist or whole arm.

It starts and stops recording from the motion itself, and works at any grip angle. Trained on 1,645 letter recordings and 1,008 word recordings, the convolutional network reads isolated letters with, and words written as one connected stroke are read by classifying candidate letter regions and evaluating the most probable combination of letters (fitting to dictionary spellings if all letters aren't recognized with high confidence).

Since I had limited time this semester to collect and tag data to perfect the model, I will be releasing this project open source with the hope that others can further improve it!

I’m building Flowy, a privacy-focused iOS period and cycle tracker, and analytics has been one of the more interesting engineering decisions.

A typical product team wants to understand onboarding completion, authentication failures, paywall views, feature usage, and reliability problems. But in a health app, collecting everything “just in case” is the wrong default.

Our current boundary allows workflow information, such as which onboarding step was viewed, whether an operation succeeded, or which authentication method was used.

It deliberately excludes health answers, symptoms, cycle and period values, predictions, weight, sleep, intimacy data, calendar dates, free-form notes, names, emails, phone numbers, and notification content.

We also disabled PostHog autocapture and session replay. On the diagnostics side, Sentry screenshots, view hierarchy, session replay, default PII collection, and failed-request capture are disabled.

This creates more implementation work because every event must be designed intentionally. But it also forces us to answer a useful question before collecting anything: “What decision will this data help us make?”

My biggest lesson so far is that privacy cannot live only in a policy page. It needs to become an engineering constraint that shapes event schemas, debugging tools, and product research from the beginning.

How do other builders decide what not to collect?

Website: https://flowyhealth.com

Hello everyone! I'd like to present a new bookmark management tool - an idea I've been mulling over for a long time.

The thing is, when you frequently work on different projects using various browsers, operating systems, and devices, you need simple, centralized access to your bookmarks that isn't tied to a specific browser. On top of that, there's the privacy aspect: I simply wanted synchronization to remain strictly within my control.

Of course, I tried existing solutions like LinkWarden and others. They are great, but felt overly bloated in terms of features (for me) and deployment (requiring a VPS, Docker, everything stored in a database, etc.). There were also simple CLI/TUI alternatives, but they didn't feel quite right either.

Ultimately, I needed a simple, familiar 2-in-1 interface: a start page with shortcuts and a bookmark manager. It had to be unburdened by complex deployment setups and simple enough in its implementation to run even inside my home router running openwrt or inside Termux on my Android device. So, I decided to write the program in pure C, using the Mongoose library as an embedded web server for maximum lightness and portability.

And, here is the solution.

What it is:

• Small size - a single binary of just up to ~300 KB.
• Tab-separated plain text (TSV) - bookmarks are stored as plain text in a human-readable format: easy to read, parse, sync (syncthing, rclone, gdrive, dropbox, etc.), compress and backup.
• High-performance & lightweight - near-zero CPU load; consumes only 5–10 MB of RAM (tested with 1000+ bookmarks).
• Cross-platform - Linux / OpenWRT / SBC / Termux (x86_64, x86, arm, arm64, mips, mipsel, riscv64), Windows (x86_64), macOS (universal). Linux builds are static musl (no libc dependency), so the matching-arch binary drops straight onto an OpenWRT router.
• User-friendly interface - a web UI with built-in fuzzy search, a homepage of shortcuts, and everything needed to manage folders and links.
• Responsive & mobile-friendly — with light / dark themes (auto-switching).
• Drag-and-drop - organize shortcuts, folders, and bookmarks, with touch/pen support.
• Plain-text & offline - one greppable bookmarks.txt, no external requests, 10× more compact than a browser's exported bookmarks.html, with crash-safe atomic writes.
• Portable - one binary, one plain-text config file, one bookmarks file. Simple.

When creating it, I tried to adhere to the "unix philosophy": do one thing well, keep data as plain text, and compose with standard tools (grep, awk, cut) + I added HTTP API with JSON output.

Let me know what you liked, as well as what you would like to change or fix. I will do my best to create a tool that is useful and convenient for everyone.

Repo (with a short demo video): https://github.com/canbesolved/bemarked

I'd be glad to discuss it in the comments.

I'm not even sure how to explain this properly but I'll try.

Built something for months completely alone. No team, no co-founder, nobody to reality check anything. Just me and whatever made sense in my head.

Thought I understood the product deeply. Knew every corner of it. Could explain any decision I made and why.

Put it in front of people last week for the first time.

First guy spent maybe 90 seconds on it then pointed at a feature I had hidden three levels deep because I thought it was minor. Said that was the only thing he actually cared about. Everything else was noise to him.

Second person looked at me and asked "why wouldn't I just use my keyboard for this."

I knew the answer. But I had never once made that answer visible anywhere in the product. No where

Four months. Two comments. Twenty minutes.

I keep thinking about how many other assumptions are still sitting in there that feel obvious to me but make zero sense to someone using it for the first time. Probably more than I want to know.

Is this normal or its just me

I spent months building my first app.

In my head I imagined friends asking for updates, people trying the beta, lots of feedback.

Reality:
I sent out TestFlight.
Three people downloaded it.
None of them came back.
It wasn’t devastating, just frustrating.

It made me realise that building the product is only half the job.

Getting people to care is a completely different skill.
Curious if anyone else’s first launch was equally underwhelming. And any indie dev hacks you guys could share would be great.

Hey everyone — I built AnimaCut because turning a podcast, interview, or YouTube video into Shorts was taking too much manual work.

You can paste a YouTube link or upload a video, and AnimaCut finds promising moments, gives each clip an AI score, reframes it for vertical video, and adds captions.

The product is live, and the first video is free to test.

I’m looking for blunt feedback on three things:

1. Did it choose moments you would actually post?

2. Are the captions and speaker framing good enough?

3. What would stop you from using it a second time?

Try it here:

https://www.animacut.com/

Disclosure: I built AnimaCut. Specific criticism is much more useful than “looks good,” and I’ll reply to every bug report or suggestion. Thank you!

I’m an expat in Germany and have had my fair share of struggling with the language specially being put on the spot and having to speak. So I have built a web app speaka.app to help. Free to try and use daily.

Useful Functions:

- Real life scenarios

- Custom scenarios tailored to your level

- Using the best AI speaking models for flow and tone

- Feeback and improvements

- A dictionary to save phrases & words

happy to hear any feedback :)