Show HN for January 12, 2026

Hey HN! We’re Will and Jorge, and we’ve built LAD (Language-Aided Design), a SolidWorks add-in that uses LLMs to create sketches, features, assemblies, and macros from conversational inputs (https://www.trylad.com/).

We come from software engineering backgrounds where tools like Claude Code and Cursor have come to dominate, but when poking around CAD systems a few months back we realized there's no way to go from a text prompt input to a modeling output in any of the major CAD systems. In our testing, the LLMs aren't as good at making 3D objects as they are are writing code, but we think they'll get a lot better in the upcoming months and years.

To bridge this gap, we've created LAD, an add-in in SolidWorks to turn conversational input and uploaded documents/images into parts, assemblies, and macros. It includes:

- Dozens of tools the LLM can call to create sketches, features, and other objects in parts.

- Assembly tools the LLM can call to turn parts into assemblies.

- File system tools the LLM can use to create, save, search, and read SolidWorks files and documentation.

- Macro writing/running tools plus a SolidWorks API documentation search so the LLM can use macros.

- Automatic screenshots and feature tree parsing to provide the LLM context on the current state.

- Checkpointing to roll back unwanted edits and permissioning to determine which commands wait for user permission.

You can try LAD at https://www.trylad.com/ and let us know what features would make it more useful for your work. We’d love your feedback!

Hi! I’m Nathan: an ML Engineer at Mozilla.ai: I built agent-of-empires (aoe): a CLI application to help you manage all of your running Claude Code/Opencode sessions and know when they are waiting for you.

- Written in rust and relies on tmux for security and reliability - Monitors state of cli sessions to tell you when an agent is running vs idle vs waiting for your input - Manage sessions by naming them, grouping them, configuring profiles for various settings

I'm passionate about getting self-hosted open-weight LLMs to be valid options to compete with proprietary closed models. One roadblock for me is that although tools like opencode allow you to connect to Local LLMs (Ollama, lm studio, etc), they generally run muuuuuch slower than models hosted by Anthropic and OpenAI. I would start a coding agent on a task, but then while I was sitting waiting for that task to complete, I would start opening new terminal windows to start multitasking. Pretty soon, I was spending a lot of time toggling between terminal windows to see which one needed me: like help in adding a clarification, approving a new command, or giving it a new task.

That’s why I build agent-of-empires (“aoe”). With aoe, I can launch a bunch of opencode and Claude Code sessions and quickly see their status or toggle between them, which helps me avoid having a lot of terminal windows open, or having to manually attach and detach from tmux sessions myself. It’s helping me give local LLMs a fair try, because them being slower is now much less of a bottleneck.

You can give it an install with

curl -fsSL https://raw.githubusercontent.com/njbrake/agent-of-empires/m... | bash

Or brew install njbrake/aoe/aoe

And then launch by simply entering the command `aoe`.

I’m interested in what you think as well as what features you think would be useful to add!

I am planning to add some further features around sandboxing (with docker) as well as support for intuitive git worktrees and am curious if there are any opinions about what should or shouldn’t be in it.

I decided against MCP management or generic terminal usage, to help keep the tool focused on parts of agentic coding that I haven’t found a usable solution for.

I hit the character limit on this post which prevented me from including a view of the output, but the readme on the github link has a screenshot showing what it looks like.

Thanks!

Monitor the situation to your own liking. Polymarket, Subway Surfers, Bluesky integration, Flight trackers. Runs all requests client side and doesn't store information. Open to feedback.

Hi HN,

I built Pane, a spreadsheet-native agent that operates directly on the grid (cells, formulas, references, ranges) instead of treating spreadsheets as text.

Most spreadsheet AI tools fail because they: - hallucinate formulas - lose context across edits - can't reliably modify existing models

Pane runs inside the spreadsheet environment and uses the same primitives a human would: selecting cells, editing formulas, inserting ranges, reconciling tables.

I launched it on Product Hunt this weekend and it unexpectedly resonated, which made me curious whether this approach actually holds up under scrutiny.

I'd love feedback on: - obvious failure modes you expect - whether this is fundamentally better than scripts + formulas + copilots

Happy to answer technical questions.

Author here.

I started seapie as a reaction to pdb's command-driven interface in 2019. I wanted a breakpoint to simply mean 'open a Python REPL here', with debugging functionality layered on top instead of replacing the REPL.

`seapie.breakpoint()` opens a working `>>>` REPL at the current execution state. Any changes to variables or function definitions persist. Debugger state is exposed via built-ins (e.g. `_magic_`), and stepping/frame control/etc is handled via small `!commands`.

I've been using this regularly in my own work for a few years now. Happy to answer questions or hear criticism, especially from people who've used debuggers heavily.

Hi HN,

I built and just released another Geoguessr alternative. The difference from most other games (and the official one) is that it doesn't use Google Maps APIs at all, which makes the game more sustainable while keeping the service free.

This is the successor project to a Geoguessr-like game I built a long time ago. I've been learning since then and felt I could design and implement the project in a cleaner way this time. That motivation led me to rebuild it from scratch.

If you’re a light user who’s hesitant about paying for a subscription and looking for an alternative, feel free to give it a try. I’d really appreciate any feedback.

Source code: https://github.com/spider-hand/geoguess-lite

Hi HN! This is a word search game I launched in the beginning of this year - didn't get much traction then, but it's been posted around a bit (right now getting some traffic from kottke.org) and now has over 12,000 words found!

Now that it's a little more filled out I figured I'd share it again. Really enjoying seeing what everyone is making on it - it appears most people start by just adding a few words to the big clump in the middle, then adding to other people's projects (or ruining them) and finally working on their own little concepts. My favorite is the kitty to the north. Hope you enjoy!

Over the past three months, I’ve been working with my dad on this app as a way to learn Cursor, shadcn/ui, and Next.js. I’m currently studying UX design at the University of Michigan, and I’ve been really impressed by how much vibe-coding tools have advanced over the last six months.

This work journal includes private AI-generated insights with scheduled summaries that can be shared with your team or manager. You can also choose to make a summary public—like I’ve done here for my work on this web app:

https://www.workjourney.ai/summary/mkblt2zt-hn2kdbus

If anyone has feedback or suggestions on how I could improve my design or coding skills, I’d really appreciate it.

Hi HN,

I built SubTrack to help teams find unused SaaS tools and cloud resources before they silently eat into budgets.

The motivation came from seeing how hard it is to answer simple questions: – Which SaaS tools are actually used? – Which cloud resources are idle? – What will our end-of-month spend look like?

SubTrack connects to tools like AWS, GitHub, Vercel, and others to surface unused resources and cost signals from one place. Recently I added multi-account support, currency localization, and optional AI-based insights to help interpret usage patterns.

This is an early-stage project and I’m actively iterating. I’d really appreciate feedback—especially from people managing cloud or SaaS sprawl.

The Thiele Machine is a formally verified universal computational model the surpasses Turing machines in key ways. It's fully proven in Coq (including kernel theorems and universality containment), features a python implementation for simulation and includes hardware designs in Verilog for potential FPGA/ASIC builds. The core idea: a paradigm shift using μ-bits for stricter computation under real-world constraints, tying into physics (e.g., Noether’s theorem) and emergence in chaotic systems.

The repo includes a 13-chapter thesis (PDF and sources), proofs, and tools for exploration. It’s aimed at formal methods enthusiasts, AI researchers, and hardware devs interested in verifiable, adaptive reasoning beyond traditional limits. Feedback welcome on the proofs, emergence chapter, or hardware impl, let’s collaborate!

Hey HN! This is Mayank from Outscal with a new update. Our website is now live. Quick context: we built a tool that generates animated videos from text scripts. The twist: instead of rendering pixels, it outputs React/TSX components that render as the video.

Try it: https://ai.outscal.com/ Sample video: https://outscal.com/v2/video/ai-constraints-m7p3_v1/12-01-26...

You pick a style (pencil sketch or neon), enter a script (up to 2000 chars), and it runs: scene direction → ElevenLabs audio → SVG assets → Scene Design → React components → deployed video.

What we learned building this:

We built the first version on Claude Code. Even with a human triggering commands, agents kept going off-script — they had file tools and would wander off reading random files, exploring tangents, producing inconsistent output.

The fix was counterintuitive: fewer tools, not more guardrails. We stripped each agent to only what it needed and pre-fed context instead of letting agents fetch it themselves.

Quality improved immediately.

We wouldn't launch the web version until this was solid. Moved to Claude Agent SDK, kept the same constraints, now fully automated.

Happy to discuss the agent architecture, why React-as-video, or anything else.

I built this toolkit with my colleague to dive deep into OS internals and automate the identification of privilege escalation vectors. Written in pure C without external dependencies, it explores everything from Linux capabilities and Docker escapes to Windows token manipulation and service permissions. We believe that the constant struggle between breaking and securing systems is the ultimate driver of software evolution. This tool is our contribution to that cycle, designed for researchers who want to understand how low-level misconfigurations can be discovered and audited across different environments.

Source: https://github.com/Ferki-git-creator/ferki-escalator

Startup time is ~10ms with Zig, which is why I built this small CLI tool for Claude Code that shows context usage, git branch, and model info in the status line.

The original JavaScript version took ~143ms to start. Reducing this to ~10ms matters since the tool runs frequently during editor use.

Little tool that I made to understand how (un)reasonable my prompts are.

Most neovim users will be familiar with flash.nvim, which amongst other things, allows you to quickly jump to a word in your visible buffer. It’s a great tool for developers who want to quickly navigate their codebase.

I was looking for something similar, but for tmux. I wanted to be able to search visible words in the current tmux pane, then copy that word to the system clipboard by pressing the associated label key.

I built https://github.com/Kristijan/flash-copy.tmux, with the aim to bring that functionality to tmux.

Here’s a bit of a write up https://blog.kristijan.org/posts/TMUX-Flash-Copy for those interested. I welcome any feedback.

I built Sutra, a Chrome extension that helps you perform intelligent searches and analyses on your own browsing history.

Instead of scrolling through a long list of URLs, you can ask questions like:

“What are the clothing-related sites I’ve visited?”

“What news related to Gaza have I read?”

“What do I usually browse late at night?”

“Which links do I visit most often?”

“What did I open around the time I was on Etsy yesterday?”

Sutra turns your browsing history into something you can actually explore, understand, and reflect on. These analyses can be done either through natural language searches or via predefined operations.

Privacy & AI

All data stays local on your machine.

No browsing history is sent to any server by default.

AI usage is optional and user-controlled.

You can use a local LLM (e.g. via Ollama) or a cloud model if you choose.

GitHub: https://github.com/paulrahul/sutra Privacy policy: https://github.com/paulrahul/sutra/blob/main/PRIVACY_POLICY....

Would love your feedback and suggestions.

used AI to compose this post as I'm traveling without my laptop

I've always found raw SEC filings painful to parse, so I built a site to make institutional holding data more accessible and visual.

I recently updated the data to analyze the peter thiel stock portfolio (tracking Founders Fund and associated vehicles) for Q3 2025. It's interesting to see the divergence from standard tech indices—heavy on defense/hard tech and very little consumer SaaS.

You can see the visualization here: https://www.13radar.com/guru/peter-thiel

Would love any feedback on the UI or suggestions on other metrics I should calculate from the 13F data.

Hi HN,

I built Sidecar (https://sidecar.bz) because I was having issues maintaining a social media presence for my last startup. I would spend a lot of time trying to create content, but I often froze up or burned out, and the marketing died.

How it works: Instead of guessing what to write, Sidecar connects to your existing accounts (Threads, Bluesky, Mastodon, Facebook, Instagram) and analyzes your past posts to see what actually worked.

It uses that data to generate weeks of new, text-based content that mimics your successful posts, which you can then bulk schedule in one go.

I’d love to hear what you think of Sidecar. You can use code HNLAUNCH for a free month if you want to test the ai features.

I built a system to solve the biggest problem with AI-assisted coding: you can't maintain the code 6 months later because you've lost all context about WHY it was written.

The core idea is simple: instead of jumping straight into code, you generate specifications first, then track every planning decision and todo in markdown files that move through folders (plans → in-progress → executed). This execution history stays with your project forever.

The toolkit includes: - Spec generators (architect + development specs from requirements) - Session management (track progress across coding sessions) - Execution history tracking (the 3-folder system) - Git workflow helpers (branches, conventional commits) - Spring Boot test generation - Automated code review agents (OWASP security, SOLID, performance)

It's built for Claude Code but the workflow concepts apply to any AI coding tool.

I used this to build a complete Spring Boot backend — 45-day estimate compressed to 5 days. The execution history is still readable months later.

$49 for the complete toolkit: https://hathwar.gumroad.com/l/spec-driven-ai

Landing page with full details: https://samhath03.github.io/spec-driven-ai/

Happy to answer questions about the workflow.

I built image0.dev, a small set of image utilities that run completely in the browser.

There’s no backend. No uploads. No tracking. No accounts.

All image processing happens locally using browser APIs and web workers. Once loaded, it works offline.

Current features: • Compress images • Resize images • Convert formats (PNG / JPG / WEBP) • Batch processing (including folders) • Before / after preview • EXIF metadata removal

I just released an open-source tool called *Grafana Alerts Dashboard*, and I thought some of you might find it useful altough it might be a bit niche.

Grafana’s built-in alerting works well, but once you have multiple folders, datasources, or environments, it gets surprisingly hard to answer simple questions like:

- Which alerts are currently firing? - Which ones are disabled or silenced? - Direct link between silenced alerts and their contact points?

This project provides a *dedicated dashboard that aggregates and visualizes Grafana alerts* in one place.

## What it does - Simplified alert UI for Walldisplay or TV screens - Shows all alert rules across folders and datasources and multiple Granafana instances - Clear status overview (firing, pending, normal, disabled) - Highlights alerts visually and audibly when they fire - Simple Search and filter views

## What it is not - It’s not a replacement for Grafana’s built-in alerting or notification system - It doesn’t manage or change alert rules, just visualizes them - It does not write to your Grafana instance or modify any settings

## Why I built it In my own self-hosted Grafana setup, alerting grew organically and eventually became messy, specially when handling multiple Grafana instances. I wanted a *single pane of glass* just for alert hygiene and visibility—something Grafana doesn’t really provide out of the box.

## Repository https://github.com/mms-gianni/grafana-alerts-dashboard

Feedback, issues, and PRs are very welcome. Happy to answer questions or explain design decisions if anyone’s curious.

If you’re running Grafana at home or in a homelab and care about alert quality, I think this will save you some time

An all-in-one app that teaches children financial literacy through pocket money, chores, rewards, goals, and bite-sized money lessons.

I built a service that gives you instant Linux boxes using only SSH. No accounts, no CLI tools, no browser – just:

  ssh shellbox.dev

Your SSH key is your identity. First connection creates your account.

Commands work over SSH: ssh shellbox.dev create mybox ssh -t shellbox.dev connect mybox ssh shellbox.dev list

Each box gets a public HTTPS URL for serving apps or webhooks.

Pricing: $0.05/hr running, $0.005/hr paused. Boxes auto-pause on disconnect and resume where you left off.

Even billing stays in the terminal – run `ssh shellbox.dev funds 10` and you get a QR code right in your shell. Scan it, pay via Paddle, done. No account dashboards.

Specs: 2 vCPUs, 4GB RAM, 50GB SSD per box.

I wanted something I could spin up from any machine with just a terminal. No installs, no OAuth flows, no "please verify your email." Works great for quick experiments, running Claude Code in isolation, or giving demos a public URL.

Would love feedback. What's missing?

Hey everyone,

I usually use sparrow for monitoring on desktop, but I wanted a simple way to check my Bitcoin balance on my phone

I didn’t want to expose xpubs or use a mobile wallet that also handles transactions. I was just looking for something watch-only

So I built BitScout, a small tool that lets me add Bitcoin addresses and see their combined balance and transactions

There are no ads, no accounts, and no analytics. Addresses stay on the device. Each one is checked separately using the mempool API

I’ve been using it for a while and found it useful, so I figured I’d share and see what others think

Happy to answer questions

App Store: https://apps.apple.com/us/app/bitscout-track-bitcoin-wallet/...

Source code: https://github.com/mgmx-io/BitScout

Hi HN,

I recently noticed a recurring visual artifact in the "Most Replayed" heatmap on the YouTube player. The highest peaks were always surrounded by two dips. I got curious about why they were there, so I decided to reverse engineer the feature to find out.

This post documents the deep dive. It starts with a system design recreation, reverse engineering the rendering code, and ends with the mathematics.

This is also my first attempt at writing an interactive article. I would love to hear your thoughts on the investigation and the format.