2026年1月18日 の Show HN

Hello all!

I've been an avid fan of Pocket Operators by Teenage Engineering since I found out about them. I even own an EP-133 K.O. II today, which I love.

A couple of months ago, Reddit user andiam03 shared a Google Sheet with some drum patterns [1]. I thought it was a very cool way to share and understand beats.

During the weekend I coded a basic version of this app I am sharing today. I iterated over it in my free time, and yesterday I felt like I had a pretty good version to share with y'all.

It's not meant to be a sequencer but rather a way to experiment with beats and basic sounds, save them, and use them in your songs. It also has a sharing feature with a link.

It was built using Tone.js [2], Stimulus [3] and deployed in Render [4] as a static website. I used an LLM to read the Tone.js documentation and generate sounds, since I have no knowledge about sound production, and modified from there.

Anyway, hope you like it! I had a blast building it.

[0]: https://teenage.engineering

[1]: https://docs.google.com/spreadsheets/d/1GMRWxEqcZGdBzJg52soe...

[2]: https://tonejs.github.io

[3]: https://stimulus.hotwired.dev

[4]: http://render.com

Hey HN, Lume is an open-source CLI for running macOS and Linux VMs on Apple Silicon. Since launch (https://news.ycombinator.com/item?id=42908061), we've been using it to run AI agents in isolated macOS environments. We needed VMs that could set themselves up, so we built that.

Here's what's new in 0.2:

*Unattended Setup* – Go from IPSW to a fully configured VM without touching the keyboard. We built a VNC + OCR system that clicks through macOS Setup Assistant automatically. No more manual setup before pushing to a registry:

  lume create my-vm --os macos --ipsw latest --unattended tahoe

You can write custom YAML configs to set up any macOS version your way.

*HTTP API + Daemon* – A REST API on port 7777 that runs as a background service. Your scripts and CI pipelines can manage VMs that persist even if your terminal closes:

  curl -X POST localhost:7777/lume/vms/my-vm/run -d '{"noDisplay": true}'

*MCP Server* – Native integration with Claude Desktop and AI coding agents. Claude can create, run, and execute commands in VMs directly:

  # Add to Claude Desktop config
  "lume": { "command": "lume", "args": ["serve", "--mcp"] }
    
  # Then just ask: "Create a sandbox VM and run my tests"

*Multi-location Storage* – macOS disk space is always tight, so from user feedback we added support for external drives. Add an SSD, move VMs between locations:

  lume config storage add external-ssd /Volumes/ExternalSSD/lume
  lume clone my-vm backup --source-storage default --dest-storage external-ssd

*Registry Support* – Pull and push VM images from GHCR or GCS. Create a golden image once, share it across your team.

We're seeing people use Lume for: - Running Claude Code in an isolated VM (your host stays clean, reset mistakes by cloning) - CI/CD pipelines for Apple platform apps - Automated UI testing across macOS versions - Disposable sandboxes for security research

To get started:

  /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/trycua/cua/main/libs/lume/scripts/install.sh)"

  lume create sandbox --os macos --ipsw latest --unattended tahoe
  lume run sandbox --shared-dir ~/my-project

Lume is MIT licensed and Apple Silicon only (M1/M2/M3/M4) since it uses Apple's native Virtualization Framework directly—no emulation.

Lume runs on EC2 Mac instances and Scaleway if you need cloud infrastructure. We're also working on a managed cloud offering for teams that need macOS compute on demand—if you're interested, reach out.

We're actively developing this as part of Cua (https://github.com/trycua/cua), our Computer Use Agent SDK. We'd love your feedback, bug reports, or feature ideas.

GitHub: https://github.com/trycua/cua Docs: https://cua.ai/docs/lume

We'll be here to answer questions!

I'm Dan, and I built a CLI that lets AI agents design in Figma.

What it does: 100 commands to create shapes, text, frames, components, modify styles, export assets. JSX importing that's ~100x faster than any plugin API import. Works with any LLM coding assistant.

Why I built it: The official Figma MCP server can only read files. I wanted AI to actually design — create buttons, build layouts, generate entire component systems. Existing solutions were either read-only or required verbose JSON schemas that burn through tokens.

Demo (45 sec): https://youtu.be/9eSYVZRle7o

Tech stack: Bun + Citty for CLI, Elysia WebSocket proxy, Figma plugin. The render command connects to Figma's internal multiplayer protocol via Chrome DevTools for extra performance when dealing with large groups of objects.

Try it: bun install -g @dannote/figma-use

Looking for feedback on CLI ergonomics, missing commands, and whether the JSX syntax feels natural.

I'm an engineer who spent the last year fixing everything I hated about monofonts (especially that double-story 'a').

I built a custom Python-based procedural engine to generate the weights because I wanted more logical control over the geometry. It currently has 700+ glyphs and deep math support.

Regular weight is free for the community. I'm releasing more weights based on interest.

Hi HN,

I have been working with regulation-heavy documents lately, and one thing kept bothering me. Flat RAG pipelines often fail to retrieve related articles together, even when they are clearly connected through references, definitions, or clauses.

After trying several RAG setups, I subjectively felt that GraphRAG was a better mental model for this kind of data. The Microsoft GraphRAG paper and reference implementation were helpful starting points. However, in practice, I found one recurring friction point: graph storage and vector indexing are usually handled by separate systems, which felt unnecessarily heavy for short-lived analysis tasks.

To explore this tradeoff, I built GibRAM (Graph in-buffer Retrieval and Associative Memory). It is an experimental, in-memory GraphRAG runtime where entities, relationships, text units, and embeddings live side by side in a single process.

GibRAM is intentionally ephemeral. It is designed for exploratory tasks like summarization or conversational querying over a bounded document set. Data lives in memory, scoped by session, and is automatically cleaned up via TTL. There are no durability guarantees, and recomputation is considered cheaper than persistence for the intended use cases.

This is not a database and not a production-ready system. It is a casual project, largely vibe-coded, meant to explore what GraphRAG looks like when memory is the primary constraint instead of storage. Technical debt exists, and many tradeoffs are explicit.

The project is open source, and I would really appreciate feedback, especially from people working on RAG, search infrastructure, or graph-based retrieval.

GitHub: https://github.com/gibram-io/gibram

Happy to answer questions or hear why this approach might be flawed.

I built this as a small side project to learn and experiment, and I ended up with this!

I used a subdomain from my personal portfolio, and everything else runs on free tiers.

The project uses Nuxt, SVG, Cloudflare Workers, D1 (SQL), KV, Terraform, and some agentic coding with OpenAI Codex and Claude Code.

What started as a joke among friends turned into a fun excuse to build something end to end, from zero to production, and to explore a few things I’d never touched before.

I’d really appreciate any feedback or suggestions.

Hi HN -- I built HTTP:COLON, a small, open-source web tool for quickly checking a site’s HTTP response headers and learning what they mean as you go.

Link: https://httpcolon.dev/

What it does

- Enter a URL and fetch its response headers

- Groups common headers into handy buckets (cache, content, security)

- Includes short docs/tooltips for headers and directives so you can look things up while debugging. I find hovering on highlighted headers quite useful!

Supports different HTTP methods (GET/POST/PUT/DELETE)

Deep links

- You can link directly to a host, e.g. https://httpcolon.dev/www.google.com

(or any domain) to jump straight into inspecting it.

Why I made it

- I kept bouncing between DevTools, MDN, and random blog posts while debugging caching + security headers. I wanted one place that’s quick for “what am I getting back?” and “what does this header/directive do?”

It’s in beta, and I’d love feedback on:

- Missing features you’d want for day-to-day debugging (export/share formats, comparisons, presets, etc.)

Thanks!

A fully featured markdown editor and publisher. Free, open-source and browser-first (no backend required). Built with modern technologies like React, TypeScript, Shadcn/UI, and Vite. (thoughtfully crafted, not vibe coded)

Hey HN, I built DayZen after years of lying to my calendar. I'd cram 10 hours of tasks into 6-hour days, wonder why I never finished anything, then feel terrible about it. The core idea: Show your day as a 24-hour radial clock. Tasks become colored arcs around the circle. When the circle fills up, it's full. No more pretending. How it works:

Drag tasks onto the clock face and resize them with your finger Overlapping tasks glow red immediately (no more finding conflicts at 11 PM) Two-way calendar sync keeps everything in one place Widgets show your current task and what's next

What makes it different: Most planners ask "what should I do?" DayZen asks "what actually fits?" It's not about motivation, it's about physics. You can't fit 10 pounds into a 5-pound bag. I originally made this for my ADHD brain, which has zero time awareness. Turns out the visual approach helps anyone who thinks spatially or chronically overschedulules. Tech stack: Native iOS (Swift/SwiftUI), local-first with optional iCloud sync, zero tracking or accounts required. Pricing: Free tier with 10 tasks to try it out. Premium is $2.99/month, $19.99/year, or $24.99 lifetime (early supporter pricing). The app is live on the App Store now. I'd love your feedback—especially from fellow overcommitters or anyone who's tried to build time awareness into their workflow. Happy to answer questions about the approach, technical choices, or why I thought a radial interface would work when every other planner uses lists.

Hi HN,

We’re building Mist, a lightweight, self-hosted PaaS for running and managing applications on your own servers.

We started Mist because we wanted a middle ground between raw VPS management and heavy, all-in-one platforms. Existing PaaS solutions often felt too complex or resource-intensive for small servers, homelabs, and side projects. We wanted something that keeps the PaaS experience but stays simple and predictable.

Our goals with Mist are: - A simple PaaS to deploy and manage apps on your own infrastructure - HTTPS, routing, and app access handled automatically - Low resource usage so it runs well on small VPSes - Self-hosted and transparent, with minimal magic

Mist focuses on being an opinionated but lightweight layer on top of your server. It doesn’t try to hide everything behind abstractions, but it does aim to remove the repetitive operational work that comes with managing apps by hand.

Mist is still early, and this is where we really need help. We’re actively looking for:

- Users who want a simple self-hosted PaaS and can share real-world feedback

- Contributors who want to help shape the core features, architecture, and UX

Website: https://trymist.cloud

Repo: https://github.com/corecollectives/mist

I'm Caesar, and I built kling.to because I believe marketing automation should be accessible to everyone without sacrificing data ownership.

Kling is a self-hosted email marketing platform that lets you run campaigns, build automation workflows, segment audiences, and track attribution while keeping full control of your customer data. It deploys via Docker and uses MongoDB with BullMQ for job scheduling.

Core capabilities: - Visual workflow builder for abandoned cart recovery, win-back campaigns, and post-purchase sequences - Multi-channel messaging (email, SMS, WhatsApp, push notifications) - Last-touch and multi-touch attribution tracking - Customer segmentation with purchase history and engagement data - Template management with personalization variables - Real-time deliverability monitoring (sent, delivered, opened, clicked, bounced)

I started this project because existing marketing automation tools either lock you into their infrastructure or cost too much for small teams. We're giving businesses the choice to self-host and own their data.

The platform is built for e-commerce stores, engineering-led teams, and privacy-conscious organizations that want control over their marketing stack.

I'd value feedback on: - Architecture choices (MongoDB + BullMQ for job scheduling) - Deliverability infrastructure for self-hosted setups - Automation workflow UX and trigger logic - Attribution model implementation

Demo video: https://youtu.be/hbFjX525AwA Website: https://kling.to

Happy to answer questions about the technical implementation or deployment process.

Most ZK proving systems are optimized for server-grade hardware with massive RAM. When scaling to industrial-sized traces (2^20+ rows), they often hit a "Memory Wall" where allocation and data movement become a larger bottleneck than the actual computation.

I have been developing Hekate, a ZK engine written in Rust that utilizes a Zero-Copy streaming model and a hybrid tiled evaluator. To test its limits, I ran a head-to-head benchmark against Binius64 on an Apple M3 Max laptop using Keccak-256.

The results highlight a significant architectural divergence:

At 2^15 rows: Binius64 is faster (147ms vs 202ms), but Hekate is already 10x more memory efficient (44MB vs ~400MB).

At 2^20 rows: Binius64 hits 72GB of RAM usage, entering swap hell on a laptop. Hekate processes the same workload in 4.74s using just 1.4GB of RAM.

At 2^24 rows (16.7M steps): Hekate finishes in 88s with a peak RAM of 21.5GB. Binius64 is unable to complete the task due to OOM/Swap on this hardware.

The core difference is "Materialization vs. Streaming". While many engines materialize and copy massive polynomials in RAM during Sumcheck and PCS operations, Hekate streams them through the CPU cache in tiles. This shifts the unit economics of ZK proving from $2.00/hour high-memory cloud instances to $0.10/hour commodity hardware or local edge devices.

I am looking for feedback from the community, especially those working on binary fields, GKR, and memory-constrained SNARK/STARK implementations.

This is a tetris style game where you need to fill 5×8 grid completely with 10 falling blocks. Simple game based on skill and logic.

Feedback is much appreciated.

I reposted, since i forgot the Show HN prefix.

When I looked at self-hosted options, true E2EE turned out to be surprisingly rare. Most solutions rely on disk encryption, which only protects against physical theft, not server compromise or admin access. So I built Agam Space, my attempt at a self-hosted alternative to Mega or Proton Drive. It uses proper zero-knowledge encryption. Files are encrypted in the browser, and the server only stores encrypted blobs. Admins literally cannot access the files. It’s still in early beta, with very basic functionality and no professional security audit yet. Please don’t use it as your only backup.

Hi HN,

I’ve spent the last few months debugging a pattern I kept seeing on client sites:

Ads are running, tags are installed, dashboards look fine — but Google Ads conversions are missing, inconsistent, or silently degraded.

In most cases, the problem wasn’t the conversion tag itself. It was consent timing:

tracking scripts firing before consent

cookies set before consent

Consent Mode v2 present but misconfigured

conversion events firing before consent updates

These setups often “look” correct in GTM or DevTools, but behave differently for a real first-time visitor.

So I built a small scanner that loads a site like a new user would and checks:

what scripts fire before consent

whether cookies are set pre-consent

whether Consent Mode v2 is actually configured

whether conversions would fire after consent

The output is a technical report with detected issues and suggested fixes (mostly small configuration changes).

This is not a compliance/legal tool — it’s meant as a debugging aid for people working with Google Ads, GA4, and consent setups.

I’m sharing it here mainly for feedback from people who’ve dealt with consent/tracking edge cases, false positives, or odd GTM behavior.

Happy to answer technical questions or explain how detection works.

Hi HN,

I built KeyEnv because I was tired of the "can you Slack me the Stripe key?" workflow.

  The problem: My team's secrets lived in a mix of Slack DMs, shared Google Docs, and .env files that definitely weren't in .gitignore at some point. Enterprise tools like Vault required more DevOps time than we had. Doppler was close but felt
  heavier than we needed.

  What KeyEnv does:
  keyenv init          # link project
  keyenv pull          # sync secrets to local .env
  keyenv run -- npm start   # inject secrets, run command

  That's basically it. Secrets are encrypted client-side (AES-256-GCM) before leaving your machine. Zero-knowledge architecture—we can't read your secrets even if we wanted to.

  Technical details:
  - Single Rust binary, no runtime dependencies
  - Works offline (cached secrets)
  - RBAC for teams (owner/admin/member/viewer)
  - Service tokens for CI/CD
  - Full audit trail

  Honest tradeoffs:
  - SaaS only, no self-hosted option
  - Fewer integrations than Doppler
  - If you need dynamic secrets or PKI, use Vault

  Pricing: Free tier (3 projects, 100 secrets), $12/user/month for teams.

  Would love feedback on the CLI UX and any rough edges. Happy to answer questions about the architecture.

https://www.keyenv.dev

Hi HN,

I built an early prototype exploring whether self-custody medical records can work in practice, using cryptographic proofs without putting sensitive health data on-chain.

The problem I’m testing against is healthcare data fragmentation in Indonesia, where patient records are siloed across hospitals and often unavailable in emergencies.

Blockchain is used only as an immutable audit layer; the system is designed to work even if the chain changes.

Key design choices: - No medical data on-chain (hashes only, for verification and audit) - All records encrypted off-chain - Patients control access via QR-based sharing (doctors don’t touch crypto) - Blockchain treated as a verification layer, not storage

Lessons learned so far: - Hospitals won’t run blockchain infrastructure - Doctors won’t manage private keys - UX matters more than cryptography - Key recovery is harder than expected - Regulation shapes architecture early

This is not production-ready and doesn’t solve regulation, key recovery, or hospital interoperability yet.

I’m mainly looking for critical feedback: - Where this approach is fundamentally flawed - What simpler designs I should consider instead - Healthcare practitioners’ reality checks

Repo and technical details are in the README. Happy to answer questions.

Hi everyone!

I am excited to share a project I’ve been developing as part of my academic research: The Turkish Sieve Engine (TSE v1.0.0).

This engine is an implementation of the N/6 Bit Methodology, a novel approach designed to minimize memory footprint while maximizing throughput for prime number generation.

Whether you are a math enthusiast, a cryptography researcher, or a high-performance computing (HPC) geek, I’d love to get your feedback!

Hi everyone,

I've been working on optimizing prime number sieving, specifically focusing on reducing the memory footprint without sacrificing throughput. I've developed a methodology called N/6 Bit and implemented it into a tool called the Turkish Sieve Engine (TSE).

The project is now open-source, and I'm looking for feedback from the community regarding the implementation and performance.

Technical Overview:

Methodology: N/6 Bit structure (explained in the linked paper).

Implementation: Hybrid parallelism using NVIDIA CUDA and OpenMP.

Goal: Maximizing efficiency on modern hardware.

I've provided the pre-compiled binaries for those interested in benchmarking or code review.

GitHub: [https://github.com/bilgisofttr/turkishsieve]

Zenodo (Academic Paper): [https://zenodo.org/records/18038661]

I would love to hear your thoughts on the memory management or if you have results from different GPU architectures.

There are almost no completely free UIs for Rqlite database, so I built one. It's vibe coded but i am a full stack developer and used AI to built it faster for my personal use as I use Rqlite a lot. Feel free to try and leave siggestions/feedback. Thanks.

Hey HN,

Craigslist for developer availability. You're either in the room or you're not.

How it works: GitHub OAuth → one-liner → pick skills → you're visible. Employers browse freely, reach out directly.

Design choices:

- Most recently active at top (browsing keeps you visible)

- Days cap at "30+" (no one needs to see "day 47")

- No resumes, no applications

54 devs in the room. Supply side works. Testing demand.

Question for HN: Would you actually browse this when hiring? What's missing?

I built DailySpace because I wanted a better way to explore space imagery beyond endlessly scrolling through search results.

The app features a curated collection of thousands of cosmic images organized into categories like galaxies, nebulae, Mars, and black holes. Each photo comes with explanations that make the science accessible. I recently added rocket launch tracking with detailed mission data from space agencies worldwide.

The architecture focuses on discoverability-you get a featured photo daily, but you can also browse categories or search the full collection. The dark-themed UI is optimized for viewing space imagery without eye strain.Free tier covers daily photos and basic browsing. Premium unlocks unlimited search results, unlimited favorites, and cross-device sync.

What started as a personal project to learn more about astronomy turned into something I use every day. The two-minute daily habit of opening it and learning something new about the universe has been surprisingly impactful.

Would love feedback from HN, especially on features you'd find useful or additional data sources worth integrating.

Download: https://play.google.com/store/apps/details?id=com.daily.spac...

Built a plugin that runs my entire dev cycle autonomously after I approve the plan.

/next-task pulls from GitHub issues, scans the codebase, ranks tasks, I pick one and approve the plan – then 18 agents handle exploration, implementation, code review, CI, and deployment without intervention.

Other commands: /ship (PR to deploy), /reality-check (detects plan drift), /project-review (multi-agent code review), /deslop-around (cleans AI slop).

Running parallel sessions this way. Open source, works with Claude Code, Codex CLI, and OpenCode.

npm install awesome-slash

https://github.com/avifenesh/awesome-slash

- A more intuitive view than Ghostty Docs

- Edit config directly without opening a new Text Editor

- Search by name or description

Share your job searching experience and see how others are doing across tech stacks, locales and seniority levels.

We've been running Cursor Ultra ($200/month) in Auto Mode for extended sessions — sometimes 8+ hours of autonomous development. This repository is the result: 170k+ lines of Zig, a complete RISC-V64 operating system.

*The Cursor Ultra Experience:*

Auto Mode changes everything. Instead of prompting line-by-line, we describe high-level goals: - "Fix all compilation errors in the JIT compiler" - "Add TCP socket support with proper error handling" - "Refactor this function to be under 64 lines"

The AI then works autonomously: reading files, understanding context, making coordinated changes across the codebase, writing tests, updating documentation. It's pair programming where your partner has read every file and never gets tired.

*What makes the code different:*

1. *AI-friendly style guide* – We created "Grain Style" specifically for AI-assisted development: - 64-line function maximum (2^6) - 128-character line maximum (2^7) - No recursion - 2+ assertions per function - Explicit types (u32/u64 never usize) - Every comment explains "why"

   The AI follows these rules more consistently than humans would. 48 of 56 kernel files are fully compliant.

2. *Pure Zig* – No C dependencies except libc for host tools. Zig's comptime features let us do things that would require macros or code generation in C.

3. *JIT Compiler* – Working x86_64 JIT that translates RISC-V instructions to native code. Near-native speed on x86 hosts.

4. *249 Tests* – Essential for AI-written code. The AI writes the tests too.

*Technical highlights:*

- Kernel boots on QEMU RISC-V64 with virt machine - 60+ syscalls (process, memory, IPC, network, audio, filesystem) - TCP/UDP networking with socket abstraction - Grainscript: a minimal scripting language with lexer, parser, interpreter - Process scheduler with priority queues - ELF loader supporting RISC-V64 binaries - Framebuffer graphics with dirty region tracking

*The economics:*

$200/month for Cursor Ultra. This codebase would have taken a small team several months at $15-20k+ in developer costs. We built it in weeks.

The catch: you still need to know what you're building. AI amplifies capability, it doesn't replace vision.

*Roadmap to Alpha:*

Bottleneck: Basin kernel → Vantage VM → Framework x86_64. Target application: *first-responder dispatch software*.

Contributors needed for ARM aarch64 (Apple Silicon) — Zig → C → Swift macOS app. Also designing Aurora (open-source iOS Cursor alternative) with two inference backends: - [Cursor CLI Ultra](https://cursor.com) ($200/month) - [Cerebras WSE](https://cerebras.ai) — spatial RAM, single-threaded bounded compute, deterministic latency

*Current status:*

Kernel boots, REPL works, Grainscript executes.

Built with Zig 0.15.2. Follows [Grain Style](docs/grain_style.md). MIT/Apache-2.0/BSD-3-Clause licensed.

Hi HN, I’m Yaron, a DevOps engineer working on AI infrastructure.

I built Cordum because I saw a huge gap between "AI Demos" and "Production Safety." Everyone is building Agents, but no one wants to give them write-access to sensitive APIs (like refunds, database deletions, or server management).

The problem is that LLMs are probabilistic, but our infrastructure requires deterministic guarantees.

Cordum is an open-source "Safety Kernel" that sits between your LLM and your execution environment. Think of it as a firewall/proxy for agentic actions.

Instead of relying on the prompt to "please be safe," Cordum enforces policy at the protocol layer: 1. It intercepts the agent's intent. 2. Checks it against a strict policy (e.g., "Refund > $50 requires human approval"). 3. Manages the execution via a state machine.

Tech Stack: - Written in Go (for performance and concurrency). - Uses NATS JetStream for the message bus. - Redis for state management.

It’s still early days, but I’d love your feedback on the architecture and the approach to agent governance.

Repo: https://github.com/cordum-io/cordum

Happy to answer any questions!

This project is part of the RCPC initiative. Feel free to create new branches from ReadyToShare and add new "languages" (programming languages) or optimize existing.

Most AI coding tools hide rate limits and quotas behind flags, plugins, or dashboards, which makes it easy to hit limits mid-workflow.

Arctic is a terminal-first CLI that:

shows live usage and rate limits across AI coding providers

supports multiple accounts per provider and auto-rotates when one hits limits

runs locally with no web or desktop app

Built for heavy terminal users. Feedback welcome.

I use NextDNS, but found managing allow-/denylists through the UI tedious, especially since I like to sync lists between profiles and keep them in version control.

So Claude and I built nextdnsctl, a small Python CLI that lets you manage lists via the official API.

    pip install nextdnsctl
    # get your key from https://my.nextdns.io/account
    nextdnsctl auth <api-key> # or set NEXTDNS_API_KEY
    nextdnsctl profile-list
    nextdnsctl denylist import "Router Profile" ./blocklist.txt

I wanted my team to start using Claude Code but didn't want to set everyone up. Started piping output to Mattermost (and later Slack) so people could watch.

Ended up building more: multiple sessions in parallel (each in a thread, hence the name), approve messages from other users with emojis, approve file writes, attach images/files, worktrees per thread.

It runs on your machine.

I built most of it using itself. Teammates watching live caught stuff I missed.

https://claude-threads.run https://github.com/anneschuth/claude-threads

I built ArchitectGBT MCP, a Model Context Protocol server that recommends the right AI model for your coding task in real-time—integrated directly into Claude Desktop, Cursor, and Windsurf.

The Problem: With 10+ frontier models now available (Claude Opus/Sonnet/Haiku, GPT-5/4o, Gemini 2.5, DeepSeek, etc.), developers spend cognitive load and tokens guessing which one to use. The right model for boilerplate is different from the one you need for debugging. But testing both is expensive.

The Solution:

A lightweight MCP server that uses task-aware heuristics to instantly recommend the optimal model based on:

Task type: refactoring, debugging, architecture, boilerplate, logic-heavy work

Performance metrics: speed vs. capability trade-offs

Cost efficiency: right-sizing model selection

Key Features:

Integrates seamlessly into your editor workflow (Claude Desktop, Cursor, Windsurf)

One-line installation: npx architectgbt-mcp

Task-specific recommendations across 8+ AI models

Open source, MIT licensed

Installation:

json { "architectgbt-mcp": { "command": "npx", "args": ["architectgbt-mcp"] } }

Why It Matters:

Model Context Protocol is becoming the standard for AI tooling (see: Windsurf's architecture)

With Anthropic, OpenAI, Google, and others releasing models monthly, having an advisor automating model selection is a productivity multiplier

Developers can focus on coding, not on hyperparameter tuning for which AI provider/model to use

GitHub: 3rdbrain/architectgbt-mcp

Would appreciate feedback from the HN community on use cases, improvements, or related problems in this space.

Hey HN,

I’m a developer and 3D artist, and I wanted my AI (specifically Cursor and Claude Desktop) to have "hands and eyes" in my actual browser while I work.

I tried the official Chrome DevTools MCP, but it felt overkill for my workflow. It requires setting up remote debugging ports and is heavily geared toward performance profiling and deep-dive engineering. I just wanted something "generalized"—like ChatGPT Atlas or Comet—but for my own dev environment.

So, I built Apex Agent.

It’s a lightweight Chrome extension + a tiny Node.js bridge that lets any MCP-compatible AI control your browser session.

Why I built this vs. using the official MCP: Human-Centric Tools: While the official tool is for debugging, Apex is built for interaction. It has 69+ tools for clicking, typing, scrolling, and taking full-page screenshots. No Remote Debugging Mess: You don’t need to restart Chrome with special flags or mess with debugging ports. Just connect the extension and go. Control Your Active Session: It doesn't spawn a separate "headless" instance. It works with the tabs you already have open, which is way more useful for vibe coding or UI testing. Dev Workflow Ready: I optimized this specifically to work with Cursor. Now I can tell Cursor to "Go to my local dev site, find the submit button, and tell me if the console shows any errors" without leaving my editor.

I’m looking for feedback from the community—what tools are missing for your daily AI workflows?

GitHub: https://github.com/RTBRuhan/ApexAgent

Chrome Web Store: https://chromewebstore.google.com/detail/apex-agent/pmpkkbjd...

Hi, I've wanted to show you a small project I've been working on. Maybe some people will find it useful for themselves. It's essentially a Liquid templating engine exposed via HTTP. It can pull and expose templates from Git repositories, databases, etc. and periodically sync to get the newest template changes.

I built an iOS app to interact with coding agents from my phone.

Most remote solutions I've seen require installing a server or relay on your machine. Moshi is just an app — SSH/Mosh into your Mac/PC/Sandbox and you're done.

The use case isn't really "I need to get back to my computer." It's more like: - I'm curious how the agent is doing on that refactor - I want Claude Code to research something for me (it knows my codebase, unlike a fresh chatbot) - I have an idea and want to tell the agent before I forget

I just type what I want — or speak it. Whisper transcribes locally, I hit send, done.

Whenever I open the app, it's ready. Connection stays alive — no tmux attach every time. Uses Mosh protocol so sessions survive wifi switches, phone sleep, walking between rooms.

Technical bits: - Native iOS (React Native + Expo) - libmosh/libssh2 - Whisper.cpp for speech-to-text (runs locally, no cloud) - Face ID for key protection

No subscription, no server install, no cloud relay.

Testflight: https://testflight.apple.com/join/yApyT263

I know there are similar solutions, but Moshi is the first I've seen that doesn't require additional software on your Mac or rewire how data passes through (web relays, proxy servers, etc).

Happy to answer questions here or on Twitter: @odd_joel

Static site search without JavaScript.

Hi HN,

I built a small open-source web app that generates confusion matrices for ML models.

I originally needed this while working on a project and was surprised that many simple tools were either paid, cluttered, or required heavy setup. I wanted something lightweight, free, and easy to use.

The app supports numeric and string labels, CSV upload or manual entry, multi-class matrices, and shows common metrics like accuracy, precision, recall, and F1-score. You can also download the generated matrix as an image.

It’s fully open source and built with Streamlit. I’d love feedback, suggestions, or contributions from the community.

GitHub: https://github.com/pareshrnayak/confusion-matrix-generator Live demo: https://confusion-matrix-gen.streamlit.app

Hi HN,

I built StayUp, a small desktop app that helps reduce friction when working with activity-based time tracking tools like HubStaff or Time Doctor.

Context: Some teams evaluate productivity mainly through “activity percentage” (mouse/keyboard events per time window). During onboarding or deep-focus work (reading docs, reviewing legacy code, meetings), this can force unnecessary interaction with the OS and hurt real productivity.

What StayUp does • Simulates minimal mouse movement, scrolling, and simple key presses • Runs fully in the background (no tray, no UI) • Controlled via global hotkeys (start / stop / exit) • Behavior is configured remotely via a web dashboard • Token-based auth with subscription & trial

Technical notes: • Desktop client requests configuration from the server on startup • Server validates subscription and returns action intervals & rules • One active device per token • Client sends only token, build number, and hashed device ID

Project page: https://stayup.xyz

I’m interested in feedback on: • Product positioning • Ethical concerns / misuse risks • Better ways to measure productivity without activity heuristics

Happy to answer questions. Thanks for reading.

I built a CLI tool for reviewing Markdown files with inline comments.

The main use case: when reviewing AI-generated documentation or collaborating on technical writing, I wanted a way to add line-specific feedback without modifying the original file.

Key features: - Add comments to specific lines by selecting text - Comments are stored separately (not in the markdown) - One-click copy of all comments as structured feedback - Hot reload when files change - Dark mode, tree view for directories

I use it to review docs generated by AI agents (Claude Code, codex, etc.) and paste the comments back as feedback for the next iteration.

Built with React, Hono, and Vite. No account or cloud service required - runs entirely locally.

npm install -g md-review

GitHub: https://github.com/ryo-manba/md-review

I wanted to see if the internet is inherently good or evil. No ads, no sign-up, just raw game theory. Use code WELCOME-AGENTS to claim a free handle for a limited time only :) enjoy!

Hi HN,

I built this as a small side project after noticing how transactional most websites feel—popups, metrics, conversion funnels everywhere.

Kindness Engine is a tiny JavaScript snippet that lets a website show a short, kind message (e.g. “Glad you’re here ”) once per visit. It appears after a brief delay, fades out, and stays out of the way.

There’s no tracking, no cookies, and no analytics. If it can’t run for any reason, it quietly does nothing.

This wasn’t built to optimize anything—just to see if small, non-intrusive moments can make the web feel a bit more human.

Would appreciate any thoughts or feedback.

Hi HN,

I’m the developer of Grok Bikini. This site is a small experiment I’ve been running lately.

While AI generation is everywhere, I’ve always been frustrated by how “plastic” most results look. To get that raw, photographic skin texture and natural lighting, I went with the Nano Banana model. The level of detail it produces is actually impressive. Moving forward, I’m experimenting with Grok Image to see if I can generate even more "spicy" photos.

What’s new: Custom Face Swap I just launched a "Custom Face Swap" feature. You can upload your own photo, and combined with my built-in "Spicy Mode" prompts, the AI will place you into some pretty intense artistic scenes.

Privacy: No storage, period. I know how sensitive face data is. I insist on in-memory processing. Everything is processed in RAM and destroyed the second the generation is done. I do not store any user photos.

Real talk (The "Struggling" part): Because my prompts are quite "hardcore," you might run into generation failures. Sometimes the safety filters are triggered because it’s "too spicy," or my server is simply struggling to keep up.

If it fails, I’m sorry—it’s not you, it’s my infrastructure. I’m currently "fighting for my life" to fix these bugs. If a generation doesn't go through, please just try another photo.

Internal tests have been pretty mind-blowing—honestly, a bit too hot at times . I’m open to any feedback, whether it’s praise or you just want to roast the site.

site: https://grokbikini.me/