2025年12月25日 的 Show HN

We’ve been experimenting quite a bit with AI website builders and kept seeing the same pattern:

Sites often look finished to users — modern UI, fast loads, everything appears “done” — but when search engines crawl them, much of the main content isn’t actually present yet.

In many cases the issue isn’t SEO basics, keywords, or content quality. It’s simply when the HTML is generated and what Google receives on first visit.

We wrote up a calm, non-marketing explanation of what’s going on, how to spot it yourself (even if you’re not very technical), and why this keeps happening with many modern AI builders.

We’re also building a tool (Pagesmith) around this problem, but the article stands on its own and should be useful even if you never use our product.

Happy to answer questions or be challenged on any of the claims.

A reading list for top Hacker News posts grouped monthly. Shows top posts by month with read/unread tracking. Set a monthly goal (15, 25, 50), mark posts as you go, see your progress.

Features: - Monthly view sorted by points (surfaces the best, not just the newest) - Mark as read/unread, or hide permanently - Syncs across browsers via your own private GitHub Gist - No server, no account, no tracking – just open the HTML file - Works offline, state persists in localStorage

Try it out here: [https://www.readhn.top/]

I missed clippy and bonzi buddy, so I spent the past few days reversing and implementing microsofts old agent format (acs) and wrote a small viewer on top of it (wasm + typescript)

You can check out the code here as well: https://github.com/Ell/bonzi

Enjoy! ^_^ https://arielche.net/noel2025

I built Pivor because I wanted a simple, self-hosted CRM without cloud lock-in or per-seat pricing.

Features: Clients, Contacts, Communications tracking (emails, calls, meetings, tasks), dark mode.

Stack: Laravel 12, Livewire 3, Tailwind CSS 4. Runs on SQLite by default, supports MySQL/PostgreSQL. Docker ready.

AGPL-3.0 licensed.

https://github.com/Lexaro-Software/pivor

Looking for feedback!

Tabs, spotlight-like window finder, borders, etc... High Niri parity

At this time, I had to sign multiple documents (energy, gas, water, etc) for our new house.

I'm using a Mac, and I have the option to create my own sign and reuse it multiple times, making it easy for me.

I'm also exploring vibe coding, so I decided to try building a small web app to generate handwritten signatures, allowing me to have a cool-looking signature and for others to use it if they want.

You can generate multiple signatures and only pay if you want to download your 7-signature pack.

I decided to let the users pay for it (only $3), not to become rich obviously :D, but to maybe cover some operational costs, like the VPS and the domain.

Since this is my first vibe-coded project, I'm also open to receiving feedback, so I can give some directions to my "virtual employee" :D

Thanks in advance!

i believe this is the worlds largest publicly accessible aggregated camera (surveillance?) database. hope yall enjoy! :)

I built a web tool that transforms PDB protein structures into retro-style pixel art icons.

Features: - Search by PDB ID or upload .pdb/.cif files - 25+ color palettes (viridis, plasma, rainbow, etc.) - 4 display styles (cartoon, stick, sphere, surface) - Export as PNG or animated GIF - All generated images are CC0 (public domain)

Built with Next.js, 3Dmol.js, and custom pixelation/outline shaders.

Live demo: https://retromol.vercel.app Source: https://github.com/suzuki-2001/retromol

Hey HN! During this holiday season, I got the idea to update a small game I made 4 months ago.

Now, the ant collects snowflakes instead of apples to eat. The background trees have been replaced. I also added a small snowfall animation :)

Happy holidays everyone!

Hi HN,

I built a free tool to check how "ATS-friendly" a resume is.

I noticed that most resume checkers force you to create an account before showing you the results, or they just grep for keywords. I wanted to build something that actually parses the PDF structure similar to how a real Applicant Tracking System does, but without the "signup wall" friction.

The stack is Next.js + `unpdf` for parsing + an LLM layer to analyze the extracted entities (skills, experience, education) against standard job descripti patterns.

How it works: 1. It validates the PDF (magic bytes check). 2. Uses `unpdf` to extract raw text and layout data. 3. Analyzes content for common ATS "trip-ups" (tables, complex columns, missing standard headers). 4. Gives a score based on readability and keyword density. 5. It's completely free and requires no email/signup. I'm currently tweaking the scoring algorithm, so I'd love to hear if the score feels "fair" for your resume.

Link: https://quickcv.io/resume-checker

Thanks!

Hey HN, I built this because standard to-do lists let me hoard tasks forever. I wanted a 'use it or lose it' mechanic. The Tech: SvelteKit (Static) Dexie.js (IndexedDB wrapper) for client-side storage Web Audio API for the procedural sounds No account required, no server tracking (except privacy-preserving PostHog). Source code is messy but the logic is simple. Would love feedback on the offline-sync strategy.

If you like the terminal, Claude Code is already lovely. No IDE needed.

The DX friction: it lives in your working directory. Switching branches means stashing, losing context, juggling. Git worktrees fix this. This script just connects them:

gwt-create feature-auth # new worktree + Claude opens gwt-switch fix-bug-42 # jump to another gwt-list # see what's running

Now I run parallel features without thinking about it. No hyped AI IDE needed to find a workflow like this — just git and a shell script.

zsh only. Bash port welcome.

Demo: https://raw.githubusercontent.com/slowestmonkey/gwt-claude/d...

Started off as a fun touch-screen theremin, and evolved into a full-fledged sequencer/groove box. Features hand feature detection to play the instrument and control effects.

Warning: Under heavy development! Still somewhat raw, but good enough to play around with :)

I got tired of copy-pasting API keys every time I scaffolded a project. Built a simple app + MCP server to fix it. You store secrets locally and the AI only sees key names. When it calls write_env(["OPENAI_API_KEY"]), values are written to disk without entering the AI context.

Hi HN,

I’ve been working on a small MVP called Mandate. The idea is simple:

AI agents can spend money and call tools, but today we mostly control them with prompts and conventions. I wanted something closer to IAM / firewall thinking, but for agents.

Mandate enforces authority at runtime, outside the LLM.

Core concepts: - Agent = stable identity (not a process) - Policy = static, versioned authority template - Rules = select policies based on invocation context (env, user tier, etc.) - Mandate = short-lived authority issued per invocation - Enforcement = deterministic allow/block of tool + LLM calls

This lets you: - cap spend per invocation or over time - restrict tools and MCP servers - kill an agent instantly - audit every decision with reason codes

No prompt tricks, no AI judgment — just mechanical enforcement.

Repo (very early MVP): https://github.com/kashaf12/mandate

I’m not sure yet if this is something teams actually want, or if it’s too early / overkill. I’d really value feedback from people running agents or automation in production: - Have you hit failures where prompts weren’t enough? - Do you already enforce hard limits internally? - What would make this useful vs annoying?

Thanks for reading.

I’m constantly building small web-based tools for my own use. Usually, my workflow ends with a dilemma: do I keep a terminal tab open forever running `npx http-server -p 8080`, or do I spend time configuring a Caddyfile for a 50-line HTML tool?

Nothing felt right. I wanted something that felt like a native, always-on, utility that was easily accessible but invisible.

I built Buoy. It’s a minimal server that:

Lives in the status bar: I can see that it's running at a glance without hunting through ps aux.

Is persistent by default: It starts with macOS and keeps my utilities alive in the background.

Zero-config: It points at a XDG‑Standard www folder so I can create a symlink and be done.

Small: I wanted to avoid the modern bloat. Buoy is a single, self-contained binary that's under 10MB.

It’s a minimal tool that lets me build many small things and move on to the next.

Had some fun over the christmas holidays and nunchux is the output.

A fun menu for tmux to reduce the number of apps I need to remember the name for.

Also a nice quick way to browse hacker news via hackernews_tui :-)

I wanted to try Confer — Moxie Marlinspike’s private AI chat — but I don’t have a Mac lying around. Since it requires isUserVerifyingPlatformAuthenticatorAvailable(), and most Linux setups don’t qualify, I put together a minimal platform authenticator that works with what I have: a TPM and a fingerprint reader.

It’s a small bridge: Chrome extension + Go backend, using the TPM for key storage and fprintd for user verification.

Write-up: https://vitorpy.com/blog/2025-12-25-confer-to-linux-tpm-fido... Code: https://github.com/vitorpy/tpm-fido2-prf

Nothing fancy. No guarantees — it was a quick hack. But if it helps someone else get Confer working on Linux :)

It's about to be 2026 and we're still stuck in the CLI era when it comes to chatbots. So, I created an open source library called Quint. Quint is a small React library that lets you build structured, deterministic interactions on top of LLMs. Instead of everything being raw text, you can define explicit choices where a click can reveal information, send structured input back to the model, or do both, with full control over where the output appears. Quint only manages state and behavior, not presentation. Therefore, you can fully customize the buttons and reveal UI through your own components and styles. The core idea is simple: separate what the model receives, what the user sees, and where that output is rendered. This makes things like MCQs, explanations, role-play branches, and localized UI expansion predictable instead of hacky. Quint doesn’t depend on any AI provider and works even without an LLM. All model interaction happens through callbacks, so you can plug in OpenAI, Gemini, Claude, or a mock function. It’s early (v0.1.0), but the core abstraction is stable. I’d love feedback on whether this is a useful direction or if there are obvious flaws I’m missing. This is just the start. Soon we'll have entire ui elements that can be rendered by LLMs making every interaction easy asf for the avg end user. Repo + docs: https://github.com/ItsM0rty/quint npm: https://www.npmjs.com/package/@itsm0rty/quint

Hi HN,

Crossplane is powerful, but once you start working with multiple compositions, claims, and managed resources, it becomes hard to understand how everything is connected.

We built Crossview to solve this problem for ourselves. It’s an open-source UI that visualizes Crossplane resources and compositions as graphs, making it easier to explore relationships, debug issues, and reason about complex setups.

Some of the things we focused on:

Visualizing relationships between compositions, claims, and managed resources

Real-time views with search and filtering

Multi-context support to switch between clusters easily

The project is still early, and we’re actively improving it. We’d really appreciate feedback from people using Crossplane, Kubernetes, or building internal platforms:

Is this useful in real-world setups?

What features would you expect from a Crossplane visualization tool?

What’s missing or unclear?

Repo: https://github.com/corpobit/crossview

Thanks for taking a look.

A Nano Banana Pro prompt for 90s Christmas studio portraits. Tried it—results are amazing. Copy, paste, and test it on the Gemini app.

Does your mom show you love by the amount of cakes she bakes for you? If yes, please note that transient insulin resistance can develop within a week if you are pushing it.

I’m a precision health consultant for longevity clinics, focused on spotting metabolic risk early and I built this comprehensive Glucose Metabolism Interpreter:

- All labs are optional — plug in whatever you have

- Uses HOMA2 instead of classic HOMA (which isn’t great because it’s linear). It also provide estimated beta-cell function

- Includes insulin-independent markers, so it works even with basic annual labs

- Gives you meaningful interpretation, not just numbers

Don’t blame your mom :) I need to figure out where to secretly donate half of the cakes, because if I ate them all, my mom’s secret gift would be type 2 diabetes :)

Merry Christmas to you and your pancreas!

I built Picunic, a web-based port of a terminal image viewer that converts images to Unicode art using a CNN.

*Demo:* https://mnur.me/picunic/

*GitHub:* https://github.com/mohammed-nurulhoque/picunic

*How it works:* - Splits images into 8×16 pixel chunks (matching terminal cell aspect ratio) - Runs each chunk through a CNN encoder to get a 64-dim embedding - Finds the Unicode character with the most similar embedding (cosine similarity) - The CNN was trained on ~2000 Unicode characters rendered in DejaVu Sans Mono

Everything runs client-side via WebAssembly - no server needed. Features include adjustable width, dithering for photos, and ASCII-only mode.

Built with Rust (compiled to WASM), ONNX Runtime Web, and vanilla JavaScript. The original terminal version is also available in the repo.

Currently works best for images with clear dark/light distinction. Would love feedback on the improving quality!

I built VideoReview to reduce review overhead for team members working on game cutscenes and animation. It lets collaborators leave time-based comments, draw directly on video frames, and discuss feedback in a lightweight, SNS-like interface.

Live demo: https://demo-video-review.d16slh4aq95cwn.amplifyapp.com/

Integrations include Jira (create tasks from comments) and Slack (share comments).

I’d love feedback on usability from people who review game or animation footage.

Hi HN,

FailCore is a small execution-time safety runtime for AI agents.

Instead of relying on better prompts or planning, it enforces security at the Python execution boundary: blocking SSRF, private network access, and unsafe filesystem side-effects before any tool side-effects occur.

I added a short live demo GIF in the README showing it blocking a real tool-use attack, along with a DESIGN.md that explains the architecture and trade-offs.

GitHub: https://github.com/zi-ling/failcore Design notes: https://github.com/zi-ling/failcore/blob/main/DESIGN.md

Feedback welcome — especially thoughts on runtime hooking vs. kernel-level approaches like eBPF.

Tried building a startup that honors speed and fluidity in motion.

It's a concept called "AI Islands" that I'm working on, hoping to build it into the next interaction layer after point and click GUIs.

Currently supports search + AI for any data.

I would really appreciate if you would try it out!