Show stories

The article discusses the future of news consumption in 2035, predicting a shift towards more personalized, interactive, and immersive news experiences driven by advancements in technology and user preferences.

I built AlgoDrill because I kept grinding LeetCode, thinking I knew the pattern, and then completely blanking when I had to implement it from scratch a few weeks later.

AlgoDrill turns NeetCode 150 and more into pattern-based drills: you rebuild the solution line by line with active recall, get first principles editorials that explain why each step exists, and everything is tagged by patterns like sliding window, two pointers, and DP so you can hammer the ones you keep forgetting. The goal is simple: turn familiar patterns into code you can write quickly and confidently in a real interview.

https://algodrill.io

Would love feedback on whether this drill-style approach feels like a real upgrade over just solving problems once, and what’s most confusing or missing when you first land on the site.

Hi HN, tl;dr we built a bug finder that's working really well, especially for app backends. Try it out and send us your thoughts!

Long story below.

--------------------------

We originally set out to work on technical debt. We had all seen codebases with a lot of debt, so we had personal grudges about the problem, and AI seemed to be making it a lot worse.

Tech debt also seemed like a great problem for AI because: 1) a small portion of the work is thinky and strategic, and then the bulk of the execution is pretty mechanical, and 2) when you're solving technical debt, you're usually trying to preserve existing behavior, just change the implementation. That means you can treat it as a closed-loop problem if you figure out good ways to detect unintended behavior changes due to a code change. And we know how to do that – that's what tests are for!

So we started with writing tests. Tests create the guardrails that make future code changes safer. Our thinking was: if we can test well enough, we can automate a lot of other tech debt work at very high quality.

We built an agent that could write thousands of new tests for a typical codebase, most "merge-quality". Some early users merged hundreds of PRs generated this way, but intuitively the tool always felt "good but not great". We used it sporadically ourselves, and it usually felt like a chore.

Around this point we realized: while we had set out to write good tests, we had built a system that, with a few tweaks, might be very good at finding bugs. When we tested it out on some friends' codebases, we discovered that almost every repo has tons of bugs lurking in it that we were able to flag. Serious bugs, interesting enough that people dropped what they were doing to fix them. Sitting right there in peoples codebases, already merged, running in prod.

We also found a lot of vulns, even in mature codebases, and sometimes even right after someone had gotten a pentest.

Under the hood: - We check out a codebase and figure out how to build it for local dev and exercise it with tests. - We take snapshots of the built local dev state. (We use Runloop for this and are big fans.) - We spin up hundreds of copies of the local dev environment to exercise the codebase in thousands of ways and flag behaviors that seem wrong. - We pick the most salient, scary examples and deliver them as linear tickets, github issues, or emails.

In practice, it's working pretty well. We've been able to find bugs in everything from compilers to trading platforms (even in rust code), but the sweet spot is app backends.

Our approach trades compute for quality. Our codebase scans take hours, far beyond what would be practical for a code review bot. But the result is that we can make more judicious use of engineers’ attention, and we think that’s going to be the most important variable.

Longer term, we think compute is cheap, engineer attention is expensive. Wielded properly, the newest models can execute complicated changes, even in large codebases. That means the limiting reagent in building software is human attention. It still takes time and focus for an engineer to ingest information, e.g. existing code, organizational context, and product requirements. These are all necessary before an engineer can articulate what they want in precise terms and do a competent job reviewing the resulting diff.

For now we're finding bugs, but the techniques we're developing extend to a lot of other background, semi-proactive work to improve codebases.

Try it out and tell us what you think. Free first scan, no credit card required: https://detail.dev/

We're also scanning on OSS repos, if you have any requests. The system is pretty high signal-to-noise, but we don't want to risk annoying maintainers by automatically opening issues, so if you request a scan for an OSS repo the results will go to you personally. https://detail.dev/oss

Hey HN! Like most here regular meetings have always been a big part of my work.

Over the years I've learned the value of active note taking in these meetings. Meaning: not minutes, not transcriptions or AI summaries, but me using my brain to actively pull out the key points in short form bullet-like notes, as the meeting is going on, as I'm talking and listening (and probably typing with one hand). This could be agenda points to cover, any interesting sidebars raised, insights gotten to in a discussion, actions agreed to (and a way to track whether they got done next time!).

It's both useful just to track what's going on in all these different meetings week to week (at one point I was doing about a dozen 1-1s per week, and it just becomes impossible to hold it in RAM) but also really valuable over time when you can look back and see the full history of a particular meeting, what was discussed when, how themes and structure are changing, is the meetings effective, etc.

Anyway, I've tried a bunch of different tools for taking these notes over the years. All the obvious ones you've probably used too. And I've always just been not quite satisfied with the experience. They work, obviously (it's just text based notes at the end of the day) but nothing is first-class for this usecase.

So, I decided to build the tool I've always felt I want to use, specifically for regular 1-1s and other types of regular meetings. I've been using it myself and with friends for a while already now, and I think it's got to that point where I actually prefer to reach for it over other general purpose note taking tools now, and I want to share it more widely.

There's a free tier so you can use it right away, in fact without even signing up.

If you've also been wanting a better system to manage your notes for regular meetings, give it a go and let me know what you think!

I've been playing around with rendering pixel text using only CSS. No JS in the final result, and no per-pixel DOM elements (too heavy).

The demo page is rendered as a long list of CSS linear-gradients. Each letter is an 8x8 matrix. Each pixel becomes a tiny background image.

Demo: https://taktek.io Gallery/Debugger: https://taktek.io/gallery Code: https://github.com/taktekhq/taktekhq.github.io

At first, I wrote each linear-gradient pixel manually... When I came to resize each pixel's size, I wrote the generator script.

1. It takes the text -> 2. breaks it into letters -> 3. gets its matrix -> 4. returns the linear-gradients list.

It chooses a variant based on the context window. For example, a period after a sentence ("hello.") should look different than inside a domain ("example.com").

My workflow now is: open the gallery -> generate the CSS in the console -> copy the result into the static page.

It's very small and a dumb tool, but I want it for an upcoming project.

If you have any feedback, maybe some pitfalls, or a better approach, I'd love to hear them.

Build AI Agents, Workflows, Backend systems live every day for 30 days.

fanfa.dev is a website that provides free and open-source tools and resources for web development, including a code editor, task runner, and package manager. The site aims to simplify the development workflow and empower developers with a user-friendly platform.

Each AI has strengths - Claude reasons well, Gemini handles long context, Codex integrates with GitHub. But switching between them means losing context.

Built HiveTechs: one workspace where Claude Code, Gemini CLI, Codex, DROID, and 7 others run in integrated terminals with shared memory.

Also added consensus validation - 3 AIs analyze independently, 4th synthesizes.

Real IDE with Monaco editor, Git, PTY terminals. Not a wrapper.

Looking for feedback: hivetechs.io

This article describes the creation of a Traveling Salesman Problem (TSP) game that was built in just 4 hours, despite being a decade in the making. The game allows users to interactively solve TSP instances and visualize the solutions.

Hi HN, I'm the CEO at https://replay.io. We've been working on time travel debugging for web development for a while (https://news.ycombinator.com/item?id=28539247) and more recently an AI app builder that uses that debugger to get past problems instead of spinning in circles (https://news.ycombinator.com/item?id=43258585).

We've gotten to where we can pretty easily build apps to replace business-critical SaaS tools, some of which we're now using internally:

* We built our own issue tracker to keep track of all our development projects, tickets, bug fixes, and so on, completely replacing Linear.

* We built a knowledge base for managing internal documentation and the status of ongoing initiatives, completely replacing Notion.

* We built a telemetry system that ingests OTLP events via a webhook and supports custom graphs and visualizations, mostly replacing Honeycomb.

We want to have as much control as we can of the apps we need to run Replay. We can tailor these apps to our needs, completely own them and their data, and avoid hostile SaaS vendor behavior like per seat pricing, paywalled features, locking us into their platform, and locking us out from accessing our own data.

Today we're launching Builder (https://builder.replay.io/), the tool we used to make these apps, along with the apps themselves and others we've built. You can copy these apps for free, download the source and self host them if you want, or let us take care of hosting, fixing bugs, and modifying them for your needs.

If you want to just check these out, here are a couple (shared, no login required) copies of these apps:

* Issue tracker: https://16857470-551d-4f50-8e5b-b7d24a4a874a.http.replay.io

* Knowledge base: https://d7e0dff4-f45c-4677-9560-6ea739c00a94.http.replay.io

We're excited for the power of AI app builders to accelerate the pace of software development, unlock the creativity of non-developers everywhere, and especially to help erode the control that so many large companies have over us. We're continuously building new apps ourselves to help in this endeavor, so let us know what you think! What are the apps and vendors that frustrate you the most?

Hey HN! I'm Juan, former reliability engineer at NetApp where I handled 60+ critical incidents per month for Fortune 500 clients.

I built ARF after seeing the same pattern repeatedly: production AI systems fail silently, humans wake up at 3 AM, take 30-60 minutes to recover, and companies lose \$50K-\$250K per incident.

ARF uses 3 specialized AI agents:

Detective: Anomaly detection via FAISS vector memory Diagnostician: Root cause analysis with causal reasoning Predictive: Forecasts failures before they happen

Result: 2-minute MTTR (vs 45-minute manual), 15-30% revenue recovery.

Tech stack: Python 3.12, FAISS, SentenceTransformers, Gradio Tests: 157/158 passing (99.4% coverage) Docs: 42,000 words across 8 comprehensive files

Live demo: https://huggingface.co/spaces/petter2025/agentic-reliability...

The interesting technical challenge was making agents coordinate without tight coupling. Each agent is independently testable but orchestrated for holistic analysis.

Happy to answer questions about multi-agent systems, production reliability patterns, or FAISS for incident recall!

GitHub: https://github.com/petterjuan/agentic-reliability-framework

(Also available for consulting if you need this deployed in your infrastructure: https://lgcylabs.vercel.app/)

hey HN — roni here, full-stack dev out of india (ex-gsoc @ internet archive).

spent last weekend hacking ZON-TS because json was torching half my openai/claude budget on dumb redundant keys — hit that wall hard while prototyping agent chains.

result: tiny TS lib (<2kb, 100% tests) that zips payloads ~50% smaller (692 tokens vs 1300 on gpt-5-nano benches) — fully human-readable, lossless, no parse tax.

drop-in for openai sdk, langchain, claude, llama.cpp, zod validation, streaming... just added a full langchain chain example to the readme (encode prompt → llm call → decode+validate, saves real $$ on subagent loops).

quick try:

```ts npm i zon-format import { encode, decode } from 'zon-format'; const zon = encode({foo: 'bar'}); console.log(decode(zon)); ``` github → https://github.com/ZON-Format/ZON-TS benches + site → https://zonformat.org

YC’s fall rfs nailed it — writing effective agent prompts is brutal when every token adds up. if you’re in a batch grinding observability (helicone/lemma vibes) or hitting gemini limits like nessie did, what’s your biggest prompt bloat headache right now? paste a sample below and i’ll zon it live.

feedback (harsh ok) very welcome

cheaper tokens ftw

Hello Everyone! We built SQLFlow as a lightweight stream processing engine.

We leverage DuckDB as the stream processing engine, which gives SQLFlow the ability to process 10's of thousands of messages a second using ~250MiB of memory!

DuckDB also supports a rich ecosystem of sinks and connectors!

https://sql-flow.com/docs/category/tutorials/

https://github.com/turbolytics/sql-flow

We were tired of running JVM's for simple stream processing, and also of bespoke one off stream processors

I would love your feedback, criticisms and/or experiences!

Thank you

Hi HN,

I built Freedom Graph because I wanted an FI calculator that modeled market variability and flexible spending more realistically. Lots of calculators assume constant returns, fixed withdrawal rules, and the "real = nominal – inflation" approximation. That’s fine for ballpark numbers, but not great when you care about sequence risk or decisions like, "should I spend another year working?"

These are the real-world factors I wanted to model explicitly:

* Sequence of Returns Risk: Optional market randomness (mix of positive/negative years, long-run ~10% CAGR) to show how early retirement plans can fail even when the long-term average looks fine

* Correct real-return math: Uses the Fisher equation instead of the linear approximation, which compounds differently over long time horizons

* Adaptive strategies: Model “one more year” scenarios and spending flexibility to see how behavior affects success probabilities

Other QoL things:

* Built with React + Vite; no input data is sent anywhere

* Local storage persists inputs between browser sessions

* FI income automatically adjusts when you hit your target

* Dark/light mode

I’d really appreciate feedback on both the UX and assumption/behavior levers. If you think something’s wrong or misleading, please tell me.

Thanks!

Immiva is a digital platform that connects businesses with qualified freelancers, offering a streamlined process for finding, hiring, and managing remote talent across various industries.

Hi Hacker News,

I've been relying on the Functional Option pattern to build clean, flexible constructors for my Go projects, but the constant need to write repetitive boilerplate for every struct became tedious and error-prone.

I built *foggo* to solve this pain point.

It's a simple, zero-dependency CLI tool that reads your configuration structs and automatically generates all the necessary, idiomatic Go code for the Functional Option pattern.

### Key Benefits: * *Massive Boilerplate Reduction:* Eliminates the manual work of writing option functions, making your code more focused on business logic. * *Consistency:* Ensures all your constructors adhere to the same, robust pattern across the entire project. * *Speed:* You define the struct, run `foggo`, and the pattern is instantly ready.

I primarily designed this for fellow Go library and package maintainers looking to standardize their configuration setup.

I'd love to hear your feedback on the utility and design of the tool, especially concerning its syntax or how it handles edge cases.

Thanks for checking it out!

*GitHub Repository:* https://github.com/rikeda71/foggo

I built a small trilogy of Go tools:

- fileprep — preprocessing & validation using struct tags (trim, replace, normalize, etc.)

- fileframe — a lightweight, immutable DataFrame for filtering, mapping, grouping

- filesql — run SQL directly on CSV/TSV/LTSV/Excel/Parquet (SQLite under the hood)

Repos:

- https://github.com/nao1215/fileprep

- https://github.com/nao1215/fileframe

- https://github.com/nao1215/filesql

Hi HN,

I recently got the AnkiMobile app for iOS for Mandarin. It was buggy and feature-lacking in my opinion, so I made a nice looking Anki-compatible alternative app, with more features.

It uses a tuned FSRS5 algorithm and supports image occlusion out of the box. You can import your existing Anki decks into it or create a new one. Pretty quick to add cards with the image feature.

I'm using it right now and will add more to it so let me know what you think.

FYI, it has a one-off purchase of $14.99 to unlock it for lifetime (no taksies backsies) after a test period of seven days.

OpenDataLoader is an open-source tool that provides a simple and flexible way to load data from various sources into a database. The tool supports a wide range of data formats and can be easily integrated into data processing pipelines.

Hi!

I got tired of setting up tools I can't explain to a team in a few words like sops or git-crypt, just to store few files with environment variables or secrets, so I built lockenv as a simple alternative.

It's basically a password-protected vault file you commit to git. No gpg keys, no cloud, just lockenv init, set a password, and lock/unlock the secrets.

This tool integrates with OS keyring, so you're not typing passwords constantly. Should work on Mac/Linux/Windows, but I tested it only on linux so far.

I am not trying to replace any mature / robust solution, just making small tool for simple cases, where I want to stop sharing secrets via slack.

Feel free to try, thank you!

Hi HN! I've been building ReadyKit, an open-source SaaS boilerplate that handles all the hard parts: multi-tenant workspaces, Stripe billing, OAuth + MFA authentication, and a production-ready stack.

Built with Python/Flask, PostgreSQL, Redis, and Vue 3, it's designed for indie makers and teams who want to ship SaaS products fast. Clone, configure your OAuth and Stripe keys, and you're running in 5 minutes.

Features include automatic query scoping for workspace isolation, audit logs, role-based access, and a modern UX kit. MIT licensed and free forever.

GitHub: https://github.com/level09/readykit

A tiny tool to detect text from ChatGPT/GPT-5/Claude/Gemini/LLaMA. Free and fast: https://dechecker.ai/

The Clearbit Logo API finally went down yesterday after the HubSpot acquisition. I relied on it across several projects (heavily), so I built a drop-in replacement:

https://logos.apistemic.com

Key features:

- Free to use, no signup or API key needed

- Both companies and domain names work as input identifiers

- WebP format for smaller payloads and better cache hit rates

Stack: S3 for storage, heavily cached fastapi, Next.js for the site. Everything's behind Cloudflare for proper CDN/caching. This was the first time I tried to build something end-to-end from idea to deployment with Claude Code (Max) and I have to say, Opus 4.5 took it like a champ!

For the younger folks, here's what the old Clearbit API looked like: https://web.archive.org/web/20230920164055/https://clearbit....

Happy to answer questions about the implementation or hear your thoughts!

Web: https://logos.apistemic.com

X: https://x.com/karllorey

Octopii is a Rust-based framework that aims to simplify the deployment and management of containerized applications. It provides a declarative configuration model, automated infrastructure provisioning, and integration with popular container orchestration platforms like Kubernetes.

Diesel-Guard is a tool that helps detect and prevent diesel engine tampering, allowing fleet managers to monitor engine performance and emissions compliance through real-time data analysis and notifications.

Vieta Space was built to reduce the friction of writing and editing LaTeX for mathematical expressions.

Existing tools often slow down math communication and force a slow iteration cycle of manual LaTeX. The growing demand for digital math across classrooms, research, and LLM based workflows made a faster and more direct editor necessary.

The project focuses on visual construction, natural language actions, and stable structural behavior.

It's free. Feedback on usability and future directions is welcome!

I built a tool that learns structural code transformations from a single before/after example.

It isn’t a transformer or LLM — it doesn’t generate code. It extracts the structural pattern between two snippets and compiles a deterministic rewrite rule. Same input → same output, every time.

Examples: • console.log(x) → logger.info(x) generalises to console.log(anything) • require(“x”) → import x from “x” • ReactDOM.render → createRoot • custom project conventions

The rules apply across an entire codebase or through an MCP plugin inside Claude Code, Cursor, or plain CLI.

It runs entirely on CPU and learns rules in real time.

Tool: https://hyperrecode.com I’d really appreciate feedback on the approach, design, or failure cases.

A small tool that parses C declarations and outputs a simple visual representation at each stage, as it encounters arrays, pointers or functions.

The program uses a table-driven lexer and a hand-written, shift-reduce parser. No external dependencies apart from the standard library.