2026년 1월 19일의 Show HN

Quick background: I used to code. Studied it in school, wrote some projects, but eventually convinced myself I wasn't cut out for it. Too slow, too many bugs, imposter syndrome — the usual story. So I pivoted, ended up as an investment associate at an early-stage angel fund, and haven't written real code in years.

Fast forward to now. I'm a Buffett nerd — big believer in compound interest as a mental model for life. I run compound interest calculations constantly. Not because I need to, but because watching numbers grow over 30-40 years keeps me patient when markets get wild. It's basically meditation for long-term investors.

The problem? Every compound interest calculator online is terrible. Ugly interfaces, ads covering half the screen, can't customize compounding frequency properly, no year-by-year breakdowns. I've tried so many. They all suck.

When vibe coding started blowing up, something clicked. Maybe I could actually build the calculators I wanted? I don't have to be a "real developer" anymore — I just need to describe what I want clearly.

So I tried it.

Two weeks and ~$100（Opus 4.5 thinking model） in API costs later: I somehow have 60+ calculators. Started with compound interest, naturally. Then thought "well, while I'm here..." and added mortgage, loan amortization, savings goals, retirement projections. Then it spiraled — BMI calculator, timezone converter, regex tester. Oops.

The AI (I'm using Claude via Windsurf) handled the grunt work beautifully. I'd describe exactly what I wanted — "compound interest calculator with monthly/quarterly/yearly options, year-by-year breakdown table, recurring contribution support" — and it delivered. With validation, nice components, even tests.

What I realized: my years away from coding weren't wasted. I still understood architecture, I still knew what good UX looked like, I still had domain expertise (financial math). I just couldn't type it all out efficiently. AI filled that gap perfectly.

Vibe coding didn't make me a 10x engineer. But it gave me permission to build again. Ideas I've had for years suddenly feel achievable. That's honestly the bigger win for me.

Stack: Next.js, React, TailwindCSS, shadcn/ui, four languages (EN/DE/FR/JA). The AI picked most of this when I said "modern and clean."

Site's live at https://calquio.com . The compound interest calculator is still my favorite page — finally exactly what I wanted.

Curious if others have similar stories. Anyone else come back to building after stepping away?

Most PDF web tools make millions by uploading documents that never needed to leave your computer.

pdfwithlove does the opposite:

1. 100% local processing 2. No uploads, no backend, no tracking

Features include merge/split/edit/compress PDFs, watermarks & signatures, and image/HTML/Office → PDF conversion.

Hey HN!

localtunnel's server needs random ports per client. That doesn't work on Fly.io or behind strict firewalls.

We rewrote it in TypeScript and added multiplexing over a single port. Open-source and 100% self-hostable.

Public instance at *.pipenet.dev if you don't want to self-host.

Built at Glama for our MCP Inspector, but it's a generic tunnel with no ties to our infra.

https://github.com/punkpeye/pipenet

Hey HN, this is a small Haskell learning project that I wanted to share. It's just a website where you can see how many people write the exact same text as you (thought it was a fun idea).

It's built using Scotty, SQLite, Redis and Caddy. Currently it's running in a small DigitalOcean droplet (1 Gb RAM).

Using Haskell for web development (specifically with Scotty) was slightly easier than I thought, but still a relatively hard task compared to other languages. One of my main friction points was Haskell's multiple string-like types: String, Text (& lazy), ByteString (& lazy), and each library choosing to consume a different one amongst these. There is also a soft requirement to learn monad transformers (e.g. to understand what liftIO is doing) which made the initial development more difficult.

I started teaching my daughter physics by showing her how things actually work - plucking guitar strings to explain vibration, mixing paints to understand light, dropping objects to see gravity in action.

She learned so much faster through hands-on exploration than through books or videos. That's when I realized: what if I could recreate these physical experiments as interactive simulations?

Lumen is the result - an interactive physics playground covering sound, light, motion, life, and mechanics. Each module lets you manipulate variables in real-time and see/hear the results immediately.

Try it: https://www.projectlumen.app/

I’ve been working on a project to bridge the gap between AI generation and my AxiDraw, and I think I finally have a workflow that avoids the usual headaches.

If you’ve tried plotting AI-generated images, you probably know the struggle: generic tracing tools (like Potrace) trace the outline of a line, resulting in double-strokes that ruin the look and take twice as long to plot.

What I tried previously:

- Potrace / Inkscape Trace: Great for filled shapes, but results in "hollow" lines for line art.

- Canny Edge Detection: Often too messy; it picks up noise and creates jittery paths.

- Standard SDXL: Struggled with geometric coherence, often breaking lines or hallucinating perspective.

- A bunch of projects that claimed to be txt2svg but which produced extremely poor results, at least for pen plotting. (Chat2SVG, StarVector, OmniSVG, DeepSVG, SVG-VAE, VectorFusion, DiffSketcher, SVGDreamer, SVGDreamer++, NeuralSVG, SVGFusion, VectorWeaver, SwiftSketch, CLIPasso, CLIPDraw, InternSVG)

My Approach:

I ended up writing a Python tool that combines a few specific technologies to get a true "centerline" vector:

1. Prompt Engineering: An LLM rewrites the prompt to enforce a "Technical Drawing" style optimized for the generator.

2. Generation: I'm using Flux.2-dev (4-bit). It seems significantly better than SDXL at maintaining straight lines and coherent geometry.

3. Skeletonization: This is the key part. Instead of tracing contours, I use Lee’s Method (via scikit-image) to erode the image down to a 1-pixel wide skeleton. This recovers the actual stroke path.

4. Graph Conversion: The pixel skeleton is converted into a graph to identify nodes and edges, pruning out small artifacts/noise.

5. Optimization: Finally, I feed it into vpype to merge segments and sort the paths (TSP) so the plotter isn't jumping around constantly.

You can see the results in the examples inside the Github repo.

The project is currently quite barebones, but it produces better results than other options I've tested so I'm publishing it. I'm interested in implementing better pre/post processing, API-based generation, and identifying shapes for cross-hatching.

Most Friday nights and weekends, my wife and I would spend 30+ minutes scrolling Netflix, vetoing each other's movie suggestions. The intersection of our tastes is pretty small. She's into rom coms and the occasional thriller, and couldn't care less about ratings. I gravitate toward critically acclaimed stuff and 3h+ sagas. Eventually, we would settle on something neither of us really wanted, or a comfort TV show.

So, I built movieagent.io to help us. It's an agent that finds what you're in the mood for tonight. The agent plays the role of an arbiter, and does its best to try and bridge the gap between users. The whole process takes about 2-3 minutes, depending on the level of disagreement (and Anthropic's API load).

The agent asks a few quick questions, then runs "duels", showing you two movies and asking which movie resonates more. Your choices reveal which direction the agent should probe into more.

Finally, the user(s) get 4-5 movies at the end with a personalized recommendation note as to why this particular movie is a good choice for tonight.

It still hit or miss sometimes, but it did help us to a couple of great movie nights.

Hi HN,

I’m a co-founder building kacet, a new freelancing platform that connects freelancers and employers, with crypto as the core payment rail.

The problem I’m trying to solve is pretty familiar: existing platforms take high fees, are slow to pay out, and don’t work well for international teams. kacet is an experiment in building a simpler, more neutral marketplace where payments are borderless by default.

Some highlights:

• Crypto-native payments – fast, borderless payouts without banks, delays, or surprise freezes • Peer-to-peer contracts – clients and freelancers work directly, the platform doesn’t own the relationship Built for teams – multi-user organisations for agencies and startups out of the box • Low, transparent fees – simple pricing with no boosts, ads, or hidden take rates • No dark patterns – a calm UI focused on agreeing work and getting paid, not maximising engagement

Tech-wise, it’s a modern web stack (React, TypeScript, Convex), and we are deliberately keeping the feature set small while validating the core workflow: post work → agree terms → get paid.

This is still early and very much a work in progress. I’d really appreciate feedback from people who have hired freelancers, worked as one, or built marketplaces before.

Site: https://kacet.com

Happy to answer any questions or go into more detail on the payment model, trust mechanics, or why I think this approach might (or might not) work.

Hey HN,

Got tired of how bloated GitHub became- copilot everywhere, janky JS, slow loads. So I built GitClassic, a read-only GitHub interface that's pure server-rendered HTML, kind of like old.reddit.com. No JavaScript.

Try it: https://gitclassic.com

Browse any public repo, files, READMEs. Loads instantly, works on any connection. No account needed for public repos.

Stack: Node on Lambda, server-side rendering, cached against GitHub's API. Pro adds private repo access via GitHub OAuth.

Built this in about 3 hours. Would love feedback on what's missing or broken. Issues are next.

Thanks, Chris

I didn’t want another app, notification, or dashboard. I wanted a subtle daily reminder through something I already look at all the time — my desktop.

So I built a small local-first daemon that updates the wallpaper once a day with a message aligned to my goals.

Site: https://gen-wal.laptopserver.dev GitHub: https://github.com/nicemit/gen-wal

Would love feedback.

On January 11th, Google and Shopify announced the Universal Commerce Protocol (ucp.dev). It's an open standard that lets any application query products across e-commerce platforms without needing APIs, integrations, or middlemen.

AskUCP is one of the first applications built on it.

Right now, if you want to buy something online, you have to know which store sells it. You go to Amazon, or you go to a Shopify store, or you go to Etsy. Each one has its own search, its own interface, its own checkout. The experience is fragmented because the infrastructure is siloed.

UCP changes this at the protocol level. If products are described in a standard format, any application can discover them. You don't need permission from each platform. You don't need to build integrations. Anybody or any AI agent just querys the protocol.

AskUCP is designed to be a single pane of glass into online commerce. You search once, and you see products from across the ecosystem. Currently, that means the entire Shopify catalog. As more platforms adopt UCP, their products become explorable too. Eventually, it should be everything.

This is a proof of concept. It's early, and there are rough edges. Let me know what you think, refinements, ideas etc etc.

Wanted to share a project I've been working on. Basically lets you drive an RC car remotely over the internet with live FPV video. I'm arranging outdoor time attack tournaments with friends, somewhere in woods or in the open field.

The setup:

    - Raspberry Pi Zero 2W mounted on the car with a wide-angle camera
    - ESP32 on the transmitter generating joystick voltages (needed because ARRMA's 2-in-1 ESC/receiver has no accessible inputs)
    - Cloudflare for the networking magic (TURN, Tunnel, Workers)
    - Browser-based controls - works on phone or desktop

What it does:

    - ~100-200ms control latency over internet (10-15ms on LAN)
    - 720p @ 30fps live video
    - Touch controls on mobile, keyboard on desktop
    - Admin dashboard for race management
    - Token-based access so I can let friends drive
    - Auto-stops if connection drops (safety first)
    - Adjustable throttle limits
    - Optional re-streaming to YouTube

Built it because I thought it'd be cool to let people drive the car without being physically present. Currently running it on my 4G modem and it works surprisingly well.

The whole thing is open source if anyone wants to check it out or build their own. The thing is, it's obviously not easy to get up and running for an average user. But maybe you'll find this useful.

Total hardware cost is around $75 (Pi + camera + ESP32) assuming you already have the car and transmitter.

Some features are work in progress:

    - Speedometer
    - GPS and track position
    - Gates system (will probably use short-range Bluetooth beacons)

Here's a a technical article about the project that reveals a bit more of under the hood thinking https://romanliutikov.com/blog/building-internet-controlled-...

Hi HN, OP here.

I built this because I was frustrated with the current state of DB design tools. They are usually either heavy enterprise desktop apps (like DataGrip/Workbench) or simple drawing tools that don't export usable code.

I wanted a "VS Code-like" experience in the browser: dark mode, strict typing, and instant visual feedback.

The tech stack is quite aggressive: - Frontend: Angular 21 (Latest). I'm using Signals exclusively for the graph state management to handle 100+ nodes without layout thrashing. - Backend: .NET 10 for DDL generation and schema validation.

Current features: - Visual Table/Column editor. - Drag & drop relationships (1:N handling). - Exports to PostgreSQL DDL and Entity Framework Core.

It's an MVP, so I'm looking for feedback on the graph interaction and the UI feel.

Does the "IDE-like" layout work for you for this kind of task?

I've been experimenting with using Claude Code for researching political topics using the archive of UN General Assembly speeches provided by the University of Birmingham (https://www.ungdc.bham.ac.uk/). Here are some initial results.

Built this after seeing developers leak credentials on SO daily. Key features: (1) Privacy scanner with 20+ detection patterns (2) Client-side RSA encryption for sensitive questions (3) AI job matching based on actual contributions. Stack: Cloudflare Workers + D1 + Vectorize. Runs on 100% free tier. Looking for feedback on the crypto implementation.

I built this to solve the amount of time it takes to set up services and boilerplate to get started with developing a new app.

It's all dockerised with DB backups in the repo so you just run docker compose up --build in the root and it will spin up:

Blazor Client .NET Core Web API Keycloak Postgres Postgres for Keycloak

There will be a seed tenant and an admin user (log into the application at localhost:5004 using admin/123).

The architecture is a modular monolith, and I have included scripts to generate modules, entities, dtos and mappers using command line questionnaires. There is also a shared module where you can run inter-module CQRS queries and commands.

Feedback would be greatly appreciated.

Homunculus is a Claude Code plugin that watches how you work and writes new capabilities into itself.

If you keep doing something repeatedly—checking docs before API calls, running the same debug flow, formatting PRs a certain way—it notices and offers to automate it. Accept, and it writes a new markdown file into its own structure. The plugin literally changes based on what you do.

It can create: Commands (explicit shortcuts) Skills (context-triggered behaviors) Subagents (specialists for specific problem domains) Hooks (event-driven, like "run tests when these files change")

What actually works (v0.1): Commands are deterministic. Skills are probabilistic—they fire when Claude decides they're relevant, maybe 50-80% of the time. It's an experiment in making LLM tooling adaptive rather than static.

State stored in .claude/homunculus/. Each project gets its own instance.

Just a simple 20-minute project with Claude Code but one that I use every day for grocery shopping with my wife.

The interesting technical piece is that each list is a Cloudflare Durable Object that handles both the websocket as well as data storage via the now built-in SQLite dbs.

I love the Cloudflare stack generally but it really shines with little projects like this in that request and compute time is really cheap and almost everything scales to zero, so hosting doesn’t cost you anything for silly hobby projects like this (I think the only carrying cost will be be 20 cents per gigabyte-month for the tiny amounts of data saved).

I also created a skill for Claude Code for the Cloudflare stack and it seems to work really well. I think a set of relatively simple primitives like Cloudflare provides along with no or minimal external dependencies seems like ideal for today’s AI.

Thanks for letting me share :)

In January 2024 I quit everything to learn to code. Two years later, I'm putting my first product out there: https://LongStories.ai

It's a tool to generate long AI video stories (up to 15 minutes for now) with character consistency. Real examples: https://longstories.ai/feed

Background: on January 1st, 2024 I moved from Barcelona to the north of Vietnam (Ha Giang), rented a flat for $300 and barely went outside for 4 months. I wanted to learn to code and build my own thing. That summer, I started playing with AI video generation and fell in love with the creative process. I realized I could use my new coding skills to make it easier for myself. "Maybe I'll pay the bills with YouTube revenue", I thought.

I checked different platforms, but I didn’t like how most were focused on “going viral” or “getting rich quick”.

So I started building my own for people who want to make actual stories, not engagement bait, and who are not necessarily experts in video editing or AI.

LongStories is still early and very much a work in progress, but 4,000 people have tried it in the last 6 months. Today it supports: - videos of up to 15 minutes - character consistency (upload your reference image: dog, son, toy...) - building animated universes (for advanced creators who want to make a series, not just one video)

The hardest part is getting the scripts to be long and good, and constantly adapting to new AI models (doing evals on things like script quality is especially hard, since some models are good at certain genres and bad at others).

Character consistency is another hard problem. Models that accept reference images (like Nano Banana, Flux, Seedream, etc.) have been a big help, but it still requires fairly complex multi-step workflows to keep characters consistent at scale.

One thing that’s been unexpectedly rewarding is seeing some users actually make money with it. YouTube monetization still favors long-form content, and several creators are already earning from stories made with the tool.

PS: about the name. I chose LongStories.ai because at the time it seemed clear to me that the biggest challenges were: A) making long videos, and B) telling good stories. It is technically hard to do both, and the market pushes you elsewhere (ads, viral ai slop, UGC, etc). Having those constraints in the name has helped me stay focused on what I'm trying to build.

After two years of research, planning, and engineering I am launching earsay. It is an iOS podcast app meant to be a pleasure to use. It detects ads 100% on device, limits ad network tracking, and requires no external service or subscription fee.

Vibe-coded my way through this - you can make whack-a-mole with the images and sound effects, plus 7 other games. Let me know what else would be cool.

https://www.jello.app

Play the whack-a-tech-bro game as a test.

I built a collection of browser-based JSON tools at json.jobby-time.com - Formatter & Validator - JSON to TypeScript interfaces - JSON to CSV - JSON Diff - Path Finder (click any value to get its JSONPath) Everything runs client-side. No data leaves your browser. Built with React + Vite + Tailwind. Feedback welcome.

If you are job hunting and you need to host your PDF resume in a professional way, without ads or weird limits, I built Resume.hr . You can upload a resume and write or upload a cover letter. You can add links from other social media profiles, and a QR code is generated automatically. The design is clean and you can even add credentials Linkedin style. You can share your resume in a subdomain like your-name.resume.hr/resume an example I created is https://alexdumi.resume.hr/sample-resume-alex .

We added a tool inside call Activities that you can use to track job-hunting activities, like to whom you sent the resume and follow-ups, and mostly track interaction to help with the job finding. Why I built this? We have another tool where users can share PDF files online but that is made for documents mostly, and the design is for that. Even so, users upload and share their resumes there, so I belive there is a place for such a tool.

We are still figuring out how we can make this better, but maybe with your help and suggestions we can build a better version.

JSON Purrser is a free JSON toolkit built for developers who work with APIs, configs, and data files daily.

Features: - Smart field detection (URLs, dates, colors, JWTs, coordinates) - One-click export to TypeScript, Python, Go, SQL, CSV, YAML - Interactive tree view with search and breadcrumb navigation - JSON diff comparison - Chart visualization for numeric data - Schema validation - Multiple themes to choose the one that matches your style

No signup. No data sent to servers. Works entirely in your browser.

(This is my first ever submission so if I did something wrong, please let me know)

I have been a bit addicted to AI dev platforms like Lovable and used it to make a website to bring back some of the early Internet, profile-centric atmosphere.

It's a minimalist writing platform where you can draft private notes, publish posts to a public profile, or post ephemeral status updates.

There is no newsfeed, nor typical features like likes, or comments. I am not an engineer, so welcome all feedback on the setup.

Hey HN,

I built Shrp (https://shrp.app) – a collection of free AI writing tools for resume bullet points, cover letters, meta descriptions, social media bios, and more.

I know ChatGPT and Claude can do all this. The difference: no account, no thinking about prompts, no conversation. Just a bookmark you hit when you need it.

Each tool is a single-purpose page with a tuned prompt behind it. Paste your text, get results, copy, done.

5 free generations per day.

Would love feedback on what's useful and what's missing.

thank you!

Hi everyone!

For the past six months, we’ve been building an open-source local agent called Eigent, an open-source alternative of Cowork and was #1 on GitHub Trending! It supports BYOK and can help you to organize local files, automate browsers end-to-end. GitHub: https://github.com/eigent-ai/eigent

At the core is CAMEL’s Workforce system, which is inspired by distributing systems: a root node for task planning and coordination, worker nodes for execution, and an asynchronous task channel. It also supports failure tolerance and recursive workers for long-horizon tasks. All of this is open source.

For browser automation, Eigent uses a two-layer architecture:

- a Python layer for agent reasoning and orchestration

- a TypeScript layer (built on Playwright) for native browser control (DOM ops, SoM markers, occlusion handling)

These two layers communicate asynchronously via WebSockets to keep things low-latency and avoid the limits of Python-only automation. This stack is also open source.

Happy to answer questions or take feature requests!

That said, the hardest problems we face today are not in agent design, but in the local desktop runtime itself. Supporting multiple operating systems, versions, and package mirrors has been extremely painful. Our desktop agent installs Python and TypeScript dependencies on first launch, and supporting this reliably across macOS and Windows has been more complex than we initially expected.

After looking into a VM-based approach that uses Apple’s Virtualization framework to run Ubuntu on macOS, we started wondering whether a similar setup could help.

Could this kind of VM-based runtime or something equivalent realistically solve the cross-platform issues across both macOS and Windows?

Hey HN, I’m Amogh. I’m a solo founder building Omelo.

Pet parents make health decisions with almost no data: missed vaccines, forgotten deworming, vague symptoms, scattered notes. Most advice comes from Google or WhatsApp groups.

Omelo is a mobile app that combines:

1. A health timeline built from walks, meals, grooming, vaccines, and expenses

2. A vet-trained AI companion (trained on veterinary literature) that answers questions in context of your pet’s history

3. Support for multiple pets, so patterns show up over time instead of being lost in chat logs

The idea is simple: turn everyday pet care into structured data, then use AI to reason over that data before something becomes an emergency.

We started on WhatsApp, served ~5,000+ pet parents, ran ~80k conversations, and just launched the mobile app to make timelines, reminders, and tracking possible.

Tech stack is intentionally boring. The hard part wasn’t models, it was designing trust, tone, and longitudinal context.

Would love feedback on:

- How you’d design health timelines for non-verbal users

- Where AI actually helps vs where it becomes noise

- What you’d strip out if this feels too heavy

App link: https://www.beomelo.com

Happy to answer anything—product, tech, mistakes, or what didn’t work.

Hey HN, I'm a solo dev. I built this API to solve a problem I saw in both finance and engineering: Non-Deterministic Data. Everyone measures accuracy (RMSE), but few measure Predictability (how stable is the variance?). The engine calculates a 'Predictability Score' (0-100) using a tunable volatility constant (K-Factor).

Tech Stack: Flask, Numba (for speed), Postgres.

Use Case: Detecting sensor drift before failure, or catching AI hallucinations before they hit production. It's live at https://www.predictability-api.com. Would love feedback on the math or the API design.

Thanks. Ryan

Hey HN! I built Abee (A/B Experiment Engine) – autonomous A/B testing. It generates hypotheses based on conversion psychology, creates variations, runs the test, picks the winner, promotes it as the new control, and starts the next round. It learns what works for your audience over time – which angles (urgency, trust, social proof, etc.) actually convert. Optional approval mode lets you review variations in batches before they go live, and your feedback trains the model to match your preferences.

https://abee.pro – free tier available.

Hi HN, I suck at design so I made a Bento Grid template to reuse for my SaaS projects. Stack: Next.js 14 + Tailwind + Framer Motion. Feedback welcome.

I often use Claude Code or Codex for active development, but still rely on ChatGPT / Gemini / Grok for explaining, reviewing, or asking high-level questions.

The problem: web-based LLMs don't share context, have strict limits, and re-sending a full repo is expensive and noisy.

srcpack lets me package the same codebase into a clean, structured context file that works across different LLMs – with less noise, fewer wasted tokens, and more consistent answers.

Repo: https://github.com/kriasoft/srcpack Website: https://kriasoft.com/srcpack/

Would love feedback, especially from people using LLM chats with software projects.