2026年4月16日 の Show HN

I trained a transformer in HyperCard. 1,216 parameters. 1989 Macintosh. And yes, it took a while.

MacMind is a complete transformer neural network, embeddings, positional encoding, self-attention, backpropagation, and gradient descent, implemented entirely in HyperTalk, the scripting language Apple shipped with HyperCard in 1987. Every line of code is readable inside HyperCard's script editor. Option-click any button and read the actual math.

The task: learn the bit-reversal permutation, the opening step of the Fast Fourier Transform. The model has no formula to follow. It discovers the positional pattern purely through attention and repeated trial and error. By training step 193, it was oscillating between 50%, 75%, and 100% accuracy on successive steps, settling into convergence like a ball rolling into a bowl.

The whole "intelligence" is 1,216 numbers stored in hidden fields in a HyperCard stack. Save the file, quit, reopen: the trained model is still there, still correct. It runs on anything from System 7 through Mac OS 9.

As a former physics student, and the FFT is an old friend, it sits at the heart of signal processing, quantum mechanics, and wave analysis. I built this because we're at a moment where AI affects all of us but most of us don't understand what it actually does. Backpropagation and attention are math, not magic. And math doesn't care whether it's running on a TPU cluster or a 68030 from 1989.

The repo has a pre-trained stack (step 1,000), a blank stack you can train yourself, and a Python/NumPy reference implementation that validates the math.

Hey HN! We're Charles and Dean, and we're building Stage: a code review tool that guides you through reading a PR step by step, instead of piecing together a giant diff.

Here's a demo video: https://www.tella.tv/video/stage-demo-1pph. You can play around with some example PRs here: https://stagereview.app/explore.

Teams are moving faster than ever with AI these days, but more and more engineers are merging changes that they don't really understand. The bottleneck isn't writing code anymore, it's reviewing it.

We're two engineers who got frustrated with GitHub's UI for code review. As coding agents took off, we saw our PR backlog pile up faster than we could handle. Not only that, the PRs themselves were getting larger and harder to understand, and we found ourselves spending most of our time trying to build a mental model of what a PR was actually doing.

We built Stage to make reviewing a PR feel more like reading chapters of a book, not an unorganized set of paragraphs. We use it every day now, not just to review each other's code but also our own, and at this point we can't really imagine going back to the old GitHub UI.

What Stage does: when a PR is opened, Stage groups the changes into small, logical "chapters". These chapters get ordered in the way that makes most sense to read. For each chapter, Stage tells you what changed and specific things to double check. Once you review all the chapters, you're done reviewing the PR.

You can sign in to Stage with your GitHub account and everything is synced seamlessly (commenting, approving etc.) so it fits into the workflows you're already used to.

What we're not building: a code review bot like CodeRabbit or Greptile. These tools are great for catching bugs (and we use them ourselves!) but at the end of the day humans are responsible for what gets shipped. It's clear that reviewing code hasn't scaled the same way that writing did, and they (we!) need better tooling to keep up with the onslaught of AI generated code, which is only going to grow.

We've had a lot of fun building this and are excited to take it further. If you're like us and are also tired of using GitHub for reviewing PRs, we'd love for you to try it out and tell us what you think!

Hey HN,

In this age of agentic coding I've found myself spending a lot of time reviewing markdown files. Whether it's plans or documentation that I've asked my agent to generate for me, it seems that I spend more time reading markdown than code.

I've tried a few different solutions to make it easier to read such as Obsidian however I've found their Vault system to be quite limiting for this use case and I've found TUI solutions to not quite be as friendly to read as I've wanted so I made Marky.

Marky is a lightweight desktop application that makes it incredibly easy to read and track your markdown files. It also has a helpful cli so you can just run marky FILENAME and have the app open to the md file that you pointed it at. I've been using the daily over the past week and I really enjoy it so I figured I'd share it.

Here's a video if you want to check out a demo: https://www.youtube.com/watch?v=nGBxt8uOVjc.

I have plans to add more features such as incorporating agentic tools such as claude code and codex into the UI as well as developing a local git diff reviewer to allow me to do local code review before pushing up to git.

I'd love to hear your thoughts and any feature suggestions you may have :)

A year ago I posted here about a small experiment: https://news.ycombinator.com/item?id=44162363

I build one absurd web project every month and publish it on https://absurd.website

I kept going.

There are now 48 projects.

The idea is still the same - I build mostly unnecessary web projects that sit somewhere between experiments, jokes, products, and art.

But over time they’ve started moving more toward net art than just experimental web.

Some recent ones:

VandalAds - a banner format you can destroy instead of just viewing Type Therapy - instead of talking affirmations, you type your thoughts to change them Slow Rebranding - branding changes so slowly you don’t notice it Guard Simulator - a crime appears for 15 seconds per day, if you catch it you win

I also started releasing some projects only to members, so not everything is public anymore.

What I like most is the rhythm: one public project and one private project each month. It forces me to realize ideas instead of leaving them in notes.

The core is still always the idea and concept - not polish, not execution, not even usefulness.

It’s also interesting to see whether people understand the thought inside a project, discover something else in it, or see nothing at all.

I’m still going, and at this point absurd.website has become a big part of my life.

Thanks.

With the recent changes around Localstack pricing/licensing I've been hunting for alternatives. I decided that it might be a fun experiment to try rolling my own. SQS is a service I use heavily so I chose that as the first service to implement. I have more services planned and in development.

A few things I think are cool:

4MB Docker Image Size

Instant Startup

AWS Sigv4 Authentication

A little admin UI that can be helpful for development/troubleshooting

Most of the SQS API implemented, the rest will soon follow :)

Inspired by ALMA. As Claude loses money gambling on provably-fair slots, it's forced to downgrade from Opus → Sonnet → Haiku, making worse decisions and accelerating the spiral. Donations go to gambling support charities.

Multi-tier exact-match cache for AI agents backed by Valkey or Redis. LLM responses, tool results, and session state behind one connection. Framework adapters for LangChain, LangGraph, and Vercel AI SDK. OpenTelemetry and Prometheus built in. No modules required - works on vanilla Valkey 7+ and Redis 6.2+.

Shipped v0.1.0 yesterday, v0.2.0 today with cluster mode. Streaming support coming next.

Existing options locked you into one tier (LangChain = LLM only, LangGraph = state only) or one framework. This solves both.

npm: https://www.npmjs.com/package/@betterdb/agent-cache Docs: https://docs.betterdb.com/packages/agent-cache.html Examples: https://valkeyforai.com/cookbooks/betterdb/ GitHub: https://github.com/BetterDB-inc/monitor/tree/master/packages...

Happy to answer questions.

I haven't seen anything like this so I decided to build it in a weekend.

How it works: You see a bunch of things pulled from Wikipedia displayed on cards. You ask yes or no questions to figure out which card is the secret article. The AI model has access to the image and wiki text and it's own knowledge to answer your question.

Happy to have my credits burned for the day but I'll probably have to make this paid at some point so enjoy. I found it's not easy to get cheap+fast+good responses but the tech is getting there. Most of the prompts are running through Groq infra or hitting a cache keyed by a normalization of the prompt.

Virtual AI friends, personalized to you, that chat you (or don't!) on their own work/sleep schedules based on their timezones. They sometimes initiate chats. They sometimes go silent for hours. Just like real friends.

I've been "dogfooding" this for the past week, and I think it's actually kind of neat. It's way better than generically chatting with an LLM.

This repo includes a detailed setup wizard. You give it some info about yourself, which can include personal blogs/websites to scrape, github, mastodon, text documents, or just paragraphs you write off the top of your head. It builds a profile of you, and then builds _them_ off of that.

You invite your new friends to your group chat by selecting and possibly editing them in a TUI. Then you can just deploy to local Docker and forget about it. Too crepy? Drop the docker container and remove ~/.sudomake-friends.

I know this reeks of dystopian future, I get it. I think of it as a fun little toy, and I also kind of just want to see what the community feedback is.

As frontier LLMs have very little output diversity even for open ended queries. We built Flint to see if we could reverse this. It’s a finetuned Qwen3 30B model specifically trained to produce higher entropy when asked open ended questions.

Flint significantly increases the NoveltyBench score compared to the base model, without significantly reducing the score on non-creative benchmarks like MMLU-STEM.

This shows that that divergence tuning doesn't actually have to be a tax on base capabilities.

Flint scores 7.47/10 on NoveltyBench while most frontier models score between 1.8 and 3.2.

Interesting to see that the entrepreneurs from more recent years tend to be doing well relative to years prior.

Some interesting future directions could be:

- Expanding search to be global and include more competitions, like biology and chemistry

- Improving search so less unknown results

- Showing insights, like trends over the years

Kudos to Perplexity Computer for making this

I’ve spent a year building a theory learning path that starts from scratch and goes all the way up to topics like Secondary Dominants and Borrowed Chords. It uses a combination of games, interactive lessons and spaced repetition to help you understand and remember concepts. Not just learn something new and forget it in a few days.

I’m trying to figure out: 1. Is the progression logical? 2. What am I missing that you’d like to see in there? 3. Where does it get confusing and could use more clarification?

I’ve just released the first public version of the Silverfish IDP, a low-cost (free for ever for public repos) Internal Developer Portal focused on helping developers and teams understand the structure of their software estates without needing a complex platform rollout and without signing up to $1000s a year for the privilege.

The Silverfish IDP connects your GitHub repositories to the components, dependencies, and organisational structure behind them. It gives you a language‑first view of your engineering landscape, starting with repository discovery and component mapping.

## What’s in the initial release

- GitHub sign‑in and onboarding - Workspaces and Organizations - Repository mapping + scan‑state control - Component + dependency discovery for supported languages (.NET languages: C#, F# & VB.Net, along with Ruby) - In‑product docs

## Short‑term roadmap

- More languages for component discovery - Fully implemented hierarchy support - Better component map visualisations - Workspace/org membership - Support for multiple organisations

See https://dashboard.silverfishsoftware.com/documentation/roadm... for what will be coming after that.

This is very much an MVP release, but the foundations are solid, and now it’s in the hands of real developers. We’re excited to see how it grows.

If you’re interested in trying it out, head to https://dashboard.silverfishsoftware.com and get logged in and using it.

We launched the Deepgram CLI, a command-line interface for transcription, speech synthesis, text analysis, account management, and MCP-based AI workflows.

The main idea was to make Deepgram feel native in the terminal instead of forcing people into one-off curl snippets or small throwaway apps just to test a workflow. It also features agent-aware heuristics. We looked at what fingerprint agents leave on running apps in their sandbox/environment, and decided it was better than defaulting to agent mode. If we miss any, the standard --help output has a catch-all tip for agents parsing it.

It supports local files, URLs, microphone input, stdin pipelines, structured output, named profiles, shell completion, setting up skills for your project (also found at https://github.com/deepgram/skills), and MCP server mode for AI tools.

Docs: https://developers.deepgram.com/cli/getting-started Launch site: https://cli.deepgram.com Repo: https://github.com/deepgram/cli

Happy to answer questions about the architecture, plugin system, or MCP support.

Most “Open Finance” repos stop at account aggregation. But when you try building against insurance APIs, you hit gaps fast: no real quote workflows, no consent flows, and no FAPI-compliant auth. So I built a UAE Open Finance Insurance testing backend.

It simulates the full lifecycle: OAuth2 FAPI-style authentication (JWT) Consent creation and authorization Quote generation across 7 insurance types Quote → policy conversion Webhook events and error handling Example flow: create consent → generate quote → accept → issue policy. It’s Dockerized, has Swagger docs, and is designed to mimic how a real TPP would integrate. This is a testing backend, not production infra. Curious what others found hardest when integrating Open Banking / Insurance APIs.

I started EDDI in 2006 as a rule-based dialog engine. Back then it was pattern matching and state machines. When LLMs showed up, the interesting question wasn't "how do I call GPT" but "how do I keep control over what the AI does in production?"

My answer was: agent logic belongs in JSON configs, not code. You describe what an agent should do, which LLM to use, what tools it can call, how it should behave. The engine reads that config and runs it. No dynamic code execution, ever. The LLM cannot run arbitrary code by design. The engine is strict so the AI can be creative.

v6 is the version where this actually became practical. You can have groups of agents debating a topic in five different orchestration styles (round table, peer review, devil's advocate...). Each agent can use a different model. A cascading system tries cheap models first and only escalates to expensive ones when confidence is low.

It also implements MCP as both server and client, so you can control EDDI from Claude Desktop or Cursor. And Google's A2A protocol for agents discovering each other across platforms.

The whole thing runs in Java 25 on Quarkus, ships as a single Docker image, and installs with one command. Open source since 2017, Apache 2.0.

Would love to hear thoughts on the architecture and feature set. And if you have ideas for what's missing or what you'd want from a system like this, I'm all ears. Always looking for good input on the roadmap.

Hello HN,

We built Fleeks because the biggest bottleneck for AI agents isn't reasoning—it's infrastructure.

Most agents (whether in an IDE like Cursor/Claude Code or a custom autonomous swarm) are stuck in a "sandbox." They can write code, but they can't easily execute, verify, or integrate it with the outside world without heavy manual intervention.

Fleeks is a purpose-built substrate that gives agents a persistent, production-ready runtime:

The Execution Bridge: Instead of just generating code, agents use the Fleeks CLI or SDK to spin up ephemeral environments. This allows them to verify their own work in a live environment and return a real URL or status to their context window.

Native Tooling (MCP): We’ve integrated 270+ Model Context Protocol (MCP) tools directly into the substrate. This removes the configuration tax of managing local JSON files and tool-servers, turning these integrations into a unified cloud capability.

Beyond the IDE: While it’s designed to supercharge IDE-based agents, our SDK (TS/Python/Go) allows engineers to build autonomous systems that provision and manage their own infrastructure on the fly.

We want to move agents from "code generators" to "systems engineers." We’d love your feedback on the architecture and how you're handling the gap between agent reasoning and system execution.

I’ve been working on this tool on and off for a while, and I recently got it back into a shape that feels ready to share.

It’s an open-source cost attribution tool for Kafka systems that supports both identity-level and topic-level attribution. The original version focused only on identity-level attribution using Confluent Cloud API and metrics data. In v2, I expanded it to support topic-level attribution as well.

The backend is Python/FastAPI, and the frontend is React. Compared to v1, which was fully in-memory and depended on Prometheus and Grafana for retention and visualization, v2 adds SQLite-backed persistence, an evolving REST API, and a plugin-based architecture for extending to other ecosystems.

No signups, free to use, and fully open source. I’d appreciate feedback, especially from people who deal with Kafka platform ownership, multi-tenancy, or chargeback/showback problems. I’m actively working on it, and I’d be glad to hear about bugs, gaps, or features that would make it more useful.