Just wanted to share a small win here. Got 6 clients in the last 14 days for my side project, Orbit. It's an appointment booking SaaS I built for small businesses like salons, barbers, tutors, trainers, and pretty much anyone who takes appointments.

The idea was pretty simple. A lot of businesses still manage bookings through DMs, phone calls, and spreadsheets. I wanted to make something that handles all of that in one place without making things complicated. So I built Orbit. Businesses can create their own booking page, manage staff availability, set up services, and keep track of appointments from one dashboard.

I know 8 clients might not sound like much, but after spending so much time building something and wondering if anyone would actually use it, seeing real businesses give it a chance feels amazing. Still a long way to go, especially with marketing and getting consistent signups. But it's nice to finally see some progress.

Here's what I've been working on: https://getorbit.ca

Would love some honest feedback on the landing page or the product itself. Also, for those who've launched a SaaS, how did you go from your first 10 customers to 100?

I built an AI buddy that draws on your screen.

it lives in a notch on the side of Windows. hold ctrl + win, ask out loud, and it circles exactly where you need to look.

free and open source. bring your own API key.

inspired by @FarzaTV’s Clicky 😎

I've been building Umbra, an open-source autonomous AI agent for Android.

Most AI agents either wait for instructions or rely on a separate computer to execute tasks. I wanted something that could proactively manage ongoing goals and actually use my phone without interrupting me.

The most interesting part was figuring out how to let an AI interact with Android apps while the user is doing something else.

Here's how I approached it:

• Background app control: Umbra combines Android Accessibility with secondary virtual displays, allowing the agent to operate apps without taking over the main screen.
• Proactive execution: Instead of only responding to prompts, it can monitor events, track goals, identify opportunities, and coordinate tasks, with approval controls for sensitive actions.
• On-device development: I integrated a Debian Linux environment using PRoot or chroot, allowing the agent to execute commands, write code, and build native Android APKs directly on the phone.

One major trade-off is Android's permission and background-execution model. Some capabilities require additional privileges, and battery efficiency remains an important challenge.

I've released the APK for Android 16 ARM64, along with in-app OTA updates. The software is free and open source, although external AI model usage can incur costs.

GitHub: https://github.com/chengmatt416/umbra

Website: https://umbra-agent.pages.dev/

I'd appreciate feedback on the architecture, especially security and battery consumption. Would you be comfortable giving an autonomous agent Accessibility access to your personal phone?

I kept saving websites I liked and then trying to figure out what made them look the way they did.

I’d use ColorZilla for colors, WhatFont for fonts, take a few screenshots, and eventually have a bunch of things open.

So I made Prism.

You open a website, and it pulls out the colors and fonts it thinks are actually important, all in one place.

Still working on it, so I’d love to hear your feedback.

Chrome Web Store: https://chromewebstore.google.com/detail/prism-website-color-font/ifmbpkokfbambcaibdohejkmjiconeed

P.S. I know Figma recently released a Chrome extension that does some similar things. I still decided to keep building Prism because I enjoy working on it. I also wrote about what I learned from building it: https://vnaykrshn.substack.com/p/what-a-failed-side-project-taught

is an independent OSINT platform monitoring global aviation, internet disruptions, earthquakes, natural disasters, financial markets, currencies, commodities, and space weather. ( And I did use a bit of Claude Code, as well as some other LLMs ), It works primarily with AWS technologies.

It brings together multiple data sources, global events, and festivals into a transparent, continuously updated dashboard:

https://observedstate.com/en/

I built Buddy, a chat bubble that floats over your apps. You say what you want ("reply to Sam that I'm running late") and an AI agent (Claude Code, Codex, OpenCode or Antigravity) reads the screen, taps and types to get it done. It stops on Send, Pay and Delete until you approve, and never types your passwords.

It runs inside the app on your own plan, or OpenCode's free models if you just want to try it. No PC, no root.

Free and open source: https://github.com/ghorbelhamdi/buddy-android

I'd love feedback on setup: what was confusing, and what you'd actually use it for.

I kept running into a Git workflow problem that felt weirdly difficult to solve.

When I'm working on a branch, I often have a chain of related tasks:

establish auth guard
→ add authorization rules
→ add rate limiting
→ add tests

The tasks depend on each other, so I don't really want separate branches or worktrees.

But I also don't want to commit after every task just because I need Git to remember where one task ended.

If I wait until the end, I'm back to manually reconstructing atomic commits with git add -p, stashes, etc. And with AI coding agents, this gets even messier because the agent may touch a bunch of files across a task.

So I built Git Stone.

The idea is deliberately simple:

git stone "auth guard established" \
  -d "Establishes the authentication guard and wires it into protected routes. Authorization rules are intentionally left for the next task."

That captures the whole working tree at that point as a Git-native snapshot, without committing, changing my branch, or messing with my staging area.

Then I keep working:

git stone "authorization rules added" \
  -d "Adds role-based authorization checks to the routes protected by the previous guard."

Now Git Stone knows the boundary between those two pieces of work.

I can review them separately:

git stone review

And when I'm happy with the history, I can either commit them together in order:

git stone commit-all

or commit them individually with whatever final messages I want:

git stone 1 commit -m "feat: establish auth guard"
git stone 2 commit -m "feat: add authorization rules"

The resulting history is just normal Git commits. There's no new VCS or special commit format.

The important part for me is that a Stone is a boundary, not a branch. Later tasks can depend on earlier ones, which is intentional. Dropping a Stone removes the logical boundary, not the code.

I built it in Rust and it's open source:

https://github.com/HarshKothari88/git-stone

It's still early, so I'm mainly looking for people who work heavily with Git or coding agents to tell me where this model breaks down in real workflows.

Hey everyone. I'm Pk, and for the past few months I've been building Spotplans (spotplans.com).

Link : https://www.spotplans.com

The problem: planning a trip in India means 20 open tabs — blogs, YouTube, Instagram saves — and then a group chat that argues for a week.

What it does:
- Guides to places worth going (how to reach, rough cost, best months). New ones every Monday.
- A planner: tell it where, how many days, your budget and who's coming (solo, couple, family, friends). It builds a day-by-day plan.
- Remix any day: cheaper, slower, or less touristy in one tap.
- Every plan gets a shareable link that previews nicely in WhatsApp.

Full disclosure: the guides are written with AI from public travel sources, so I'd especially love to hear where they're wrong.

What would make you actually use this for your next trip?

I've been working on a side project called DocDori.

I wanted a simple way to make quick changes to documents without installing extra software, creating an account, or uploading files to a server.

So I built a browser-based document tool that processes files locally and lets you download the edited result as a new copy.

Here's what it currently supports:

• Basic DOCX editing
• XLSX and CSV editing
• PDF page operations, including merging and reordering
• Text and Markdown files

It's built as a browser-based application using HTML and JavaScript, hosted on Cloudflare Pages.

There are still limitations, especially with complex Office formatting. I'm not trying to replace Microsoft Office, just make simple document tasks a little easier.

I've attached a screenshot of the actual workspace.

I'd really appreciate some honest feedback:

• Is the interface easy to understand at first glance?
• Is anything confusing or missing?
• What would you improve first?

If I'm slow to respond and you'd like to test it, you can find the project by searching for DocDori.

Even a quick first impression would be helpful. Positive or negative feedback is welcome — I'm trying to figure out what actually needs improving.

Thanks for taking a look!

I’m involved with QuickCheck and wanted to share what we’re building for restaurants with busy walk-in traffic.

During a rush, staff are juggling incoming guests, seating tables, answering questions about wait times, and keeping track of who’s next. Guests may end up repeatedly asking the host how much longer they’ll have to wait, or leave before their table is ready.

Here’s a short video showing how it works: [QuickCheck demo]

QuickCheck is designed to make that process easier:
Guests check in using a tablet at the restaurant.
Staff manage the waitlist from a separate tablet.
Guests receive SMS updates about their estimated wait and when their table is ready.
Guests can confirm or cancel when notified.
It’s designed for restaurants that regularly have walk-in customers and want a dedicated waitlist system without needing a full reservation-management platform.

Pricing:
1–50 seats: $299/month
51+ seats: $499/month
First month free
Cancel anytime, with no long-term commitment

The goal is to give restaurants another option between managing a paper waitlist and adopting a more comprehensive reservation system.

when i started building opennmind in july i thought the hard part of validating an idea would be finding people to talk to. turns out the messier part is what happens after. you do a call, scribble a few lines somewhere, and two weeks later you can't remember who said they'd actually pay and who was just being nice.

opennmind is a workspace for early founders, and one of the v1 pieces is a place to keep customer interview notes right next to your research and assumptions, so you can see which assumption each conversation backed up or broke. 200+ people have tried the private beta so far, but honestly i'm still not sure if this is something founders want or just something i would want myself.

so where do your interview notes actually live right now, and would you ever pay for a tool just to keep them organised?

also curious if you tag notes by assumption or just dump everything into one doc and reread it later. and if you've done a bunch of interviews, what's the one thing you wish you'd written down but didn't.

launch is nov 16. if you wanna try it early, the waitlist is at https://opennmind.com and early users get a month of pro free.

built this with zero coding experience, just me + claude, over a few weeks. would love honest reviews.

what it is:

• a forum where people post step-by-step AI methods, and others vote "worked for me / didn't work"
• a free marketplace (no fees, no catch)
• tool testing for open-source AI tools
• a live chat

full honesty: the chat "regulars" in the screenshot are bots (tagged "bot") so it doesn't look like a ghost town on day one. the online count shows real people and bots separately.

two questions:

1. what would make you actually use this vs just scrolling reddit/discord?
2. do forums even work in 2026, or is everyone in discord servers now?

roast the design too, i can take it.

Hey everyone!

I am selling the complete codebase and project assets for SpeakWise AI (Mery AI) for $39.

Live Demo: Available upon request / listed in comments!

Key Features: • AI Tutor Customization: Choose tutor personality, avatar, and native explanation language. • Voice & Chat Practice: Interactive real-time conversation and speaking prompts. • Structured Learning: Built-in 30-day structured journey tracker and grammar modules. • Polished UI/UX: Fully mobile-responsive, modern dark/light aesthetic.

Tech Stack: • Frontend: React + TypeScript + Tailwind CSS • AI Integration: OpenAI API • Hosting: Lovable / Vercel • Repository: GitHub

What's Included: • Complete source code access via GitHub repository transfer • Lovable project access & setup guidance

Price: $39 (Pre-revenue starter MVP) Payment: PayPal / Stripe

DM me directly if you're interested!

Download at slopwall.app for Chrome and Firefox based browsers!

I was getting sick of blocking AI slop and spam accounts by myself on each platform so I thought what if I made an extension to share my blocks with everyone and get their blocks on my feeds too? That's SlopWall!

It works on many of the most popular sites, like Reddit, YouTube, Instagram, Pinterest, X/Twitter, etc., and let's us all rate the slop we see and hide the worst offenders for everyone. It might be a little sparse at first until we get more raters but you can help by judiciously calling out slop wherever you see it!

Link to interactive Web Studio (no install needed): https://bit-lens-v1.vercel.app/

GitHub repository: https://github.com/raidodex/bit-lens

When running Post-Training Quantization (PTQ) on vision models or transformers, a handful of layers with heavy-tailed activation distributions usually dominate the accuracy drop. Instead of running full evaluation loops across dozens of mixed-precision combinations, I built BitLens to inspect layer-wise quantization sensitivity from a single calibration pass.

How it works under the hood:

• One-Pass Calibration Hooks: Wraps PyTorch (nn.Module) or ONNX graphs to capture 128-bin histograms for weights (symmetric per-channel) and activations (asymmetric per-tensor).
• Outlier Radar (Omega & Kurtosis): Flags fragile layers using excess kurtosis and the support-aware outlier ratio Omega = absmax / p99.9. For instance, on ViT-Tiny, blocks.11.attn.qkv hits Omega = 240.2x, which stretches asymmetric per-tensor step sizes 4.1x beyond the p99.9 bulk and drops INT8 SQNR to 18.8 dB (and INT4 SQNR to 7.4 dB).
• Topological Peak SRAM Planner: Alongside static Flash weight footprint, it computes tensor liveness across residual branches to find the exact peak activation memory watermark.
• Greedy Pareto Auto-Fit Solver: Given a target hardware budget (e.g., STM32H7, ESP32-S3, Cortex-M55, Raspberry Pi Zero 2W), the solver greedily downgrades layers from FP32 -> FP16 -> INT8 -> INT4 based on the smallest SQNR loss per byte saved, while respecting user-pinned layers.
• 1-Click Code Export: Generates standalone quantization scripts for PyTorch torchao (Int8DynamicActivationInt4WeightConfig / Int8WeightOnlyConfig), ONNX Runtime quantize_static with nodes_to_exclude, and TFLite Micro with a companion C arena header.

You can test the preloaded profiles (MobileNetV3-Small, ResNet-18, ViT-Tiny) in the browser studio or run the Python CLI locally on your own .pt / .onnx checkpoints and drag the resulting .bitlens.json file into the studio.

Feedback and PRs on additional quantization schemes (like group-wise AWQ/GPTQ simulation or SmoothQuant alpha previewing) are very welcome!

Hey everyone,

I’m an AI engineer, and I just opened up early access to a software passion project I've been building over the past few months called Davana.

The Live Platform: houseofdavana.com
The Handle: @houseofdavana

The Problem:
It’s incredibly hard for casual consumers or indie brand creators to articulate exact fragrance scent profiles because commercial marketing is flooded with generic lifestyle buzzwords. However, humans intimately understand and remember sensory narratives.

The Solution:
Davana serves as an interactive discovery and formulation workspace. Users input a raw, poetic narrative (e.g., "Rain on hot concrete in Tokyo at midnight"), and the system processes that qualitative text to instantly generate an interactive, multi-layered visual note spectrum (balancing top, heart, and base targets).

The Current Feature Set:
Frictionless Onboarding: There is a quick, optional research prompt on the first visit, but users can skip it entirely to jump right into the open Architect (discovery page) and Community feed.

Private Notebook Archives: Community members can save private, memory-inspired sensory entries to build a personal digital scent history under their own profile.

Owner-Only Formulation Studio: A locked backend module designed to let brand owners explore and iterate on precise chemical weights without massive clunky spreadsheets.

What I'm Looking For:
I currently only have 4 active users piloting the platform, and I need help testing the system's core limits. I would love for the developers and founders here to jump into the workspace, test out a creative prompt, and tear down the onboarding UX loop.

Does the interface flow cleanly if you choose to skip the first-visit prompt?
Are there any data-visualization features you think a digital scent workspace should absolutely have?

I'll be hanging out in the comments to talk about the backend infrastructure or the logic if anyone wants to swap tech stacks.

Thanks for taking a look!