2025年12月15日 的 Show HN

I wanted something like lazygit for databases – run it, connect, and query and frankly just make it enjoyable to access data.

  Sqlit is a keyboard-driven SQL TUI with:

  - Context-based keybindings (always visible)
  - Neovim-like interface with normal and insert mode for query editing
  - Browse databases, tables, views, stored procedures
  - Adapters for SQL Server, SQLite, PostgreSQL, Turso & more
  - SSH tunneling support
  - Themes (Tokyo Night, Nord, Gruvbox etc.)

  Inspired by lazygit, neovim and lazysql. Built with Python/Textual.

https://github.com/Maxteabag/sqlit

The Goal:

Raw Bitcoin Script is notoriously difficult to reason about. Writing raw Bitcoin Script today feels like writing Assembly in the 1970s. You have to mentally juggle the stack (`OP_SWAP`, `OP_ROT`), manually manage distinct execution branches, and pray you didn't leave a stack item unconsumed (which crashes the script). My goal was to bridge the gap between complex contract logic and raw opcodes, allowing developers to write readable, compile-time-safe code.

Key Features:

- Imperative Syntax: Write logic using familiar if/else and return statements instead of mental stack juggling.

- Type Safety: First-class support for bool, signature, string, and number types to prevent runtime errors.

- Targeted Compilation: Support for Legacy, SegWit, and Taproot compilation targets.

- Native Primitives: Built-in keywords for timelocks (older, after) and cryptography (sha256, checksig).

You can try it in the browser here (runs via WASM): https://bithoven-lang.github.io/bithoven/ide/

Here is an example of a Hashed Time-Locked Contract (HTLC):

  (condition: bool, sig_alice: signature)
  (condition: bool, preimage: string, sig_bob: signature)
  {
      if condition {
          // Relative locktime (Sequence)
          older 1000;
          return checksig (sig_alice, alice_pk);
      } else {
          // Hashlock verification
          verify sha256 sha256 preimage == hash;
          return checksig (sig_bob, bob_pk);
      }
  }

The core insight: a critical error repeated 1000x is "normal" (semantically dense). A strange one-off event is anomalous (semantically isolated).

Outputs XML-tagged blocks with anomaly scores. Designed to reduce large logs as a form of pre-processing for LLM analysis.

Architecture: https://github.com/calebevans/cordon/blob/main/docs/architec...

Benchmark: https://github.com/calebevans/cordon/blob/main/benchmark/res...

Trade-offs: intentionally ignores repetitive patterns, uses percentile-based thresholds (relative, not absolute).

Process is simple: - Enter X username / url - Fetch Profile image and choose badge - Generates a badge page which can be shared with nice OG images

The site is deployed on Vercel, with R2 and Browser rendering for OG images and data storage.

I built this because I wanted to give Claude Desktop access to my Notion workspace without running a flaky local Python script via stdio.

This is a Node.js/Express implementation of the Model Context Protocol (MCP) that uses SSE (Server-Sent Events) for transport. It’s designed to be stateless and deployable as a container (I'm hosting it on Apify, but it works anywhere with Node).

The Stack:

TypeScript + Express

@modelcontextprotocol/sdk

Zod for input validation

Bearer Auth for security (since it exposes an HTTP endpoint)

Capabilities: It allows the LLM to search pages, read database properties, and append blocks. I use it primarily to have Cursor/Claude summarize documentation and create tasks in my sprint board directly from the chat context.

Repo: https://github.com/piskunproject/notion-mcp-server/ One-click deploy (Apify): https://apify.com/piskunlab/notion-mcp-server

Feedback on the SSE implementation is welcome!

We’ve built a demo that anyone can try here: https://kenobi.ai/start

We believe that large parts of the web are about to go from being static to dynamic because of how adept LLMs are at transforming rendered HTML. And right now we’re focussing on B2B landing page content (as opposed to application UIs) because there is a lot of commercial opportunity for increasing top-of-funnel inbound conversions.

Our journey to Kenobi today is a long and snaking one. You may notice from the post title that we did YC’s Winter 2022 batch (I know that 4 years is practically ancient in YC-dog-years). Kenobi is a hard pivot from our original idea that we got accepted into YC with — a company called Verdn which did trackable environmental donations via an API. Since the summer, we’ve been hacking on different ideas… We started with personalized UI screenshots for outbound campaigns, but then people told us they wanted transformations to their actual site[0] — so we built an agentic workflow to research a visitor-company and “pre-render” changes to a landing site for them. Ultimately, there was too much friction in getting people to incorporate personalized URLs into their cold outbound campaigns[1]. Besides, people kept asking for us to do this for their inbound traffic, and so our current iteration was born.

Right now with Kenobi you pick a page that you’d like to make customizable, and choose [text] elements that you’d like to make dynamic. You can define custom prompting instructions for these elements, and when someone visits your page, our agentic workflow researches their company, and presents the updated content as quickly as possible, usually within a few seconds.[2] You also get a ping in Slack every time this happens so you know who is using your site.

We’ve been experimenting with features such as generating custom imagery that actually looks good and native to the page design, and pulling in company data sources so that e.g. the right case study can be presented based on a visitor’s industry and ICP profile. Our most requested feature is deanonymizing traffic so that Kenobi’s personalization can happen automatically as visitors land on your page — this is coming very soon, as right now you have to specify where you’re coming from.

It’s surprised us just how much business value we’ve gotten from knowing who (most probably) is on the page and asking for a personalized experience. We’ve seen response rates 3x of what we would normally from following people up from companies we know visited our site.

There are many players in this space already, and everyone seems to have their own angle. We are keen to hear thoughts on what people think the future of the personalized internet looks like!

Cheers from London!

P.S. - there's also a video that Chris recorded showing the end-to-end Kenobi experience right now https://www.loom.com/share/bc0a82a2f2fd40f695315bae80e8f5d8

[0] - Many of them had tried AI “microsite” generators but found the maintenance of managing a separate website(s) just for closing deals to be burdensome and inefficient.

[1] - Despite having a CSV export and Clay integration option for our pre-generated website changes, getting people to weave the URLs into their email sequences (everyone uses different tools) seemed almost insurmountable without building what would ostensibly be our own sequencing software.

[2] - We use light foundation models with grounded search for the research step, and translate these into markup changes via another light LLM pass and our own DSL which is optimized for speed.

Marketplace: https://marketplace.visualstudio.com/items?itemName=TouchGra...

Built in a week with Claude Code after seeing Chad IDE get ratio'd for integrating real gambling. Happy to answer questions or get roasted on the code.

This project started shortly after Claude Code launched. I had already worked on a few other AI coding projects, and decided to see how far I could realistically take something end-to-end. While I had some help from a developer, I increasingly felt capable of taking on more work myself. So about 9 months in the making, working full time on it past 2 months.

Stack:

Postgres, Next.js on Render. Monorepo with both frontend and backend services.

Some takeaways from using Claude Code on this project:

- I built all project pages directly in frontend JavaScript with mock data — no Figma or other layout tools.

- In the early days, scope got out of hand; I learned quickly that Claude tends to overbuild unless tightly constrained.

- Initially, I used Claude Desktop to refine prompts for Claude Code.

- My skills with Git, SQL, Docker, and local/remote environments were shaky at first, but they no longer get in the way.

- Using Flowbite CSS saved a lot of pain and made it possible to produce reasonably high-quality designs quickly.

- Getting details right has always depended on pushing people, now that responsibility falls entirely on me.

- About six months in, I adopted the Functional Core, Imperative Shell approach and documented it in claude.md (inspired by this HN post: https://news.ycombinator.com/item?id=45701901).

- I built an Airbnb-style referral program in a day, after spending time on a detailed to-do spec and following the above approach.

What Jetogo does:

- Issues you long-term, data-only eSIMs for mobile data

What is Jetogo for:

- Saving money on travel roaming data costs

- Secondary devices (e.g., a kid’s iPad, laptop, or backup connection)

What we built:

- Parse CDR usage data to calculate accurate user billing

- Implemented pay-as-you-go and subscription options using Stripe

- Subscriptions support rollover and overage, applied at the end of each billing period

- Built referral, bonus, and coupon programs

- Aggregate usage across multiple eSIMs under a single account and present a unified total

Live now at: https://jetogo.com

A big open question in AI is whether there's enough brand differentiation for AI companies to capture real profits. Will models end up commoditized like cloud compute, or differentiated like smartphones?

I built ModelGuessr to test this. I think that people will struggle more than they expect. And the more model mix-ups there are, the more commodity-like these models probably are.

If enough people play, I'll publish some follow-up analyses on confusion patterns (which models get mistaken for each other, what gives them away, etc.). Would love any feedback!

I’ve been working on an experimental programming language called XXML. The project started from a frustration I kept running into across systems languages:

Languages with strong ownership tend to avoid runtime reflection.

Languages with rich reflection usually rely on GC or give up memory guarantees.

Compile-time code generation often requires a separate macro language.

I wanted to explore whether those tradeoffs are truly necessary.

What XXML is trying to do

XXML is a statically-typed, native language that:

Uses explicit ownership and borrowing (no garbage collector)

Supports runtime reflection while respecting ownership rules

Allows compile-time code generation using normal language constructs, not macros

Compiles to LLVM IR and produces native binaries

Reflection APIs are constrained so unsafe ownership operations are rejected at compile time. The goal isn’t “dynamic at all costs,” but introspection without losing safety.

What it’s useful for (so far)

Some concrete use cases I’m exploring:

Safe plugin/mod systems for native applications

Auto-generated serialization (e.g., JSON/RPC) without macros

Debugging and inspection tools that can reason about user types

Declarative domains (UI/layout/asset graphs) that benefit from structured syntax

What it’s not

This is early-stage and definitely not production-ready:

The ecosystem is minimal

The language is still evolving

Documentation and tooling are incomplete

I’m mostly interested in feedback from people who’ve worked on:

compilers

language runtimes

systems with heavy serialization or plugin boundaries

Code

GitHub repo: https://github.com/ThatSoulyGuy/XXMLCompiler or https://xxml-language.com

I’d especially appreciate criticism around:

the ownership model

reflection safety boundaries

where this design is fundamentally flawed

Thanks for reading — happy to answer questions.

The project is designed for education, systems research, and latency instrumentation, not for live trading. It focuses on understanding exactly where every nanosecond goes in a trading execution path.

Key features:

- Kernel-bypass networking: Direct userspace access to NICs via custom drivers, 20-50 ns RX latency - Lock-free SPSC/MPSC queues: Zero-copy architecture - SIMD feature extraction: About 40 ns per update using AVX-512 - Deterministic replay: Bit-identical execution paths, SHA-256 verified - Nanosecond-level metrics: Full audit logs and performance dashboard

Technical stack: C++17 and Rust, NUMA-aware memory allocation, cache-line alignment, inline assembly for hot paths.

The framework is modular, allowing experimentation with different NIC drivers, feature extraction pipelines, or order-flow models such as Hawkes processes or Avellaneda-Stoikov logic. Everything is open source and documented.

Links:

Live demo: https://submicro.krishnabajpai.me/ Source code: https://github.com/krish567366/submicro-execution-engine Bare-metal NIC drivers: https://baremetalnic.krishnabajpai.me/

I would welcome feedback from anyone working on low-latency systems, networking, or HFT research.

Some questions for discussion:

- Which part of the execution path is typically hardest to optimize? - What measurement techniques do you trust for sub-microsecond systems?

This project is for research and educational purposes only. It does not connect to exchanges or execute real trades. It is intended as a sandbox for understanding ultra-low-latency execution.

I am happy to answer questions about methodology, performance, or design trade-offs.

The key insight: most photo sorting time is spent reviewing near-duplicates. Professional photographers shoot in bursts, so you get 10+ shots of the same moment.

PicPick uses CLIP embeddings to cluster visually similar photos, then adds face recognition to keep groups coherent (so you don't mix up "bride with parents" and "bride with friends" just because they look similar).

Tech stack: - CLIP for semantic similarity (not just perceptual hashing) - face_recognition (dlib) for person detection - DBSCAN clustering on combined features - FastAPI + vanilla JS for the UI - SQLite for everything

It reduced my review set from 5,000 → ~1,000 clusters, which I then filtered down to 300 for the album in a few hours instead of days.

The clustering parameters are tunable - tighter for professional shoots with many duplicates, looser for casual photos.

Open to feedback! Especially around: 1. Better clustering algorithms (currently DBSCAN on CLIP embeddings + timestamps + face vectors) 2. UI improvements for rapid reviewing 3. Handling photos without faces (landscapes, food, etc.)

Works entirely offline, no cloud uploads needed.

If you're like me, notifications disappear into the void and todo apps get buried under 47 browser tabs. I used to plaster my monitor with post-its because out of sight = out of mind.

So I built Mozart Says, a reminder that literally floats on top of everything until you deal with it.

It's a free Mac app where you can write any message, customize how it looks (typography, colors), and drag it anywhere on screen.

Agent Deck is a TUI built on tmux that shows all sessions with live status - green (working), yellow (needs input), gray (idle).

Works with Claude Code, Gemini CLI, Aider, Codex.

Can also fork Claude conversations to try different approaches from the same context.

Built with Go + Bubble Tea. Early development, using it daily with 20+ sessions.

Looking for feedback

it’s intentionally not cryptographically realistic; the goal is to make avalanche effects and the meaninglessness of near-matches intuitive.

this was a quick front-end experiment; the code isn’t published yet.

everything runs client-side; no tracking; no accounts.

The product targets early-stage developers and focuses on reducing initial setup and preparation when building new apps. It abstracts away some of the repetitive early decisions and boilerplate that tend to slow down first-time builders, especially around project structure, configuration, and “what should exist on day one”.

I have a small number of active users, but churn is relatively high, which suggests either:

the problem is not painful enough

the abstraction leaks too early

the UX or onboarding fails to communicate value

or the tool solves a problem that disappears after the first session

I would really appreciate technical feedback on:

whether the abstraction layer makes sense

if the mental model aligns with how you bootstrap projects

where the product feels opinionated vs restrictive

what would make this something you would actually keep installed

Thanks for reading. Direct, critical feedback is very welcome.

  I’m a grad student and need to cover some tuition this semester. I’ve
  been scraping freelance job boards for a while and turned it into
  a dataset.

  Data:
  - 134,861 unique postings (Apr–Nov 2025)
  - Fields: description, hourly/fixed budget, client country, tech tags
  - Format: SQLite + CSV; scraped with Python (Selenium/Scrapy) with basic
  dedup/normalization (currencies, month-level timestamps, no company names/
  URLs)

  Sample insight: In this scrape, CV gigs pay more than LLM ones: median fixed
  budgets ≈ $3k vs ≈ $2k (Apr–Nov 2025; n≈270 CV, n≈18k NLP).

  Free sample (50 rows): https://docs.google.com/spreadsheets/
  d/1wvvX8JeOIEO2rYeuMf99LEBN4bmVoZ3ZQqHY_clvCvc/edit?gid=0#gid=0
  Full dataset: https://noctscraper.gumroad.com/l/freelance-ai-dataset

  Happy to answer questions about the schema or run a quick aggregate if
  you’re curious.

I built a lightweight, open-source Python CLI tool that runs on Linux and Windows.

Designed for fast discovery of devices on local IPv4 networks, focused on ethical diagnostics and basic administrative auditing.

It supports automatic LAN subnet detection or manual IP/range targeting, combines ICMP, ARP, socket-based discovery and scans common service ports (FTP, SSH, SMB, HTTP, RDP and more).

The output is console-based, with optional export to a TXT log file.

One of the most frustrating parts of working with RabbitMQ for me has always been the management interface, especially when dealing with DLQs. At some point, I proposed improving the native UI internally, but the response I got was basically: "Don't fix what isn't broken." Fair enough... so I went ahead and built something instead.

Rabbit GUI is a Mac desktop app that connects directly to the RabbitMQ Management API, it works with both self-hosted instances and services like CloudAMQP.

Think of it as an IDE for RabbitMQ. You can connect to multiple environments (local, staging, prod...), browse and filter through queues messages, and selectively republish or discard items in your DLQs.

The app is a one-time payment for a lifetime license, no subscriptions nonsense.

I'd love feedback from anyone who deals with RabbitMQ day to day!

I'm a Product Manager who used to be terrible at working with Engineering. I treated devs like feature vending machines and didn't understand why "just one small button" during a refactor was a war crime.

I realized that most PM training focuses on frameworks (RICE, SQL, Product Sense & Strategy) but ignores the actual job: managing political capital and technical trade-offs.

So, I built a "Flight Simulator" for Junior PMs. It's a text-based RPG where you have to navigate crises without burning your "Trust Battery" with the Engineering Lead.

The Stack:

Frontend: [React/Next.js/HTML]

Logic: State machine tracking 3 variables (Eng Trust, Tech Debt, Business Value).

No AI wrapper yet—this is hand-coded branching logic based on real mistakes I made.

The Scenario: You are an APM. Your VP of Marketing sold a feature that doesn't exist. Your Tech Lead is 50% through a critical database migration. You have to figure out how to solve the customer problem without touching the prod database.

I'd love feedback on the realism of the "Grumpy Engineer" dialogue. Did I capture the pain correctly?

Try it here (no login required for first scenario): https://apmcommunication.com/scenario

I built CryptoBob, a small API that provides precomputed market intelligence for crypto trading systems.

Instead of signals or predictions, CryptoBob focuses on: - regime filtering (when NOT to trade), - ranking markets by setup quality, - providing simple risk hints (stop / trail percentages).

It’s designed to be consumed by bots, dashboards, and quant workflows.

The API exposes a small set of stable endpoints and uses Firebase-based authentication with subscription plans.

Docs: https://cryptobob.de/docs Website: https://cryptobob.de

This is an early-stage project and I’d really appreciate feedback, especially from quants and algo traders.