frontpage.
newsnewestaskshowjobs

Made with ♥ by @iamnishanth

Open Source @Github

fp.

BERT Is Just a Single Text Diffusion Step

https://nathan.rs/posts/roberta-diffusion/
189•nathan-barry•2h ago•41 comments

Production RAG: what I learned from processing 5M+ documents

https://blog.abdellatif.io/production-rag-processing-5m-documents
75•tifa2up•1h ago•19 comments

AWS Multiple Services Down in us-east-1

https://health.aws.amazon.com/health/status?ts=20251020
897•kondro•10h ago•1360 comments

Alibaba Cloud says it cut Nvidia AI GPU use by 82% with new pooling system

https://www.tomshardware.com/tech-industry/semiconductors/alibaba-says-new-pooling-system-cut-nvi...
146•hd4•4h ago•103 comments

Space Elevator

https://neal.fun/space-elevator/
1141•kaonwarb•12h ago•243 comments

DeepSeek OCR

https://github.com/deepseek-ai/DeepSeek-OCR
706•pierre•10h ago•187 comments

Optical diffraction patterns made with a MOPA laser engraving machine [video]

https://www.youtube.com/watch?v=RsGHr7dXLuI
30•emsign•6d ago•1 comments

How to stop Linux threads cleanly

https://mazzo.li/posts/stopping-linux-threads.html
69•signa11•5d ago•22 comments

Servo v0.0.1

https://github.com/servo/servo
298•undeveloper•4h ago•87 comments

Docker Systems Status: Full Service Disruption

https://www.dockerstatus.com/pages/incident/533c6539221ae15e3f000031/68f5e1c741c825463df7486c
277•l2dy•9h ago•111 comments

Entire Linux Network stack diagram (2024)

https://zenodo.org/records/14179366
491•hhutw•13h ago•40 comments

How to Enter a City Like a King

https://worldhistory.substack.com/p/how-to-enter-a-city-like-a-king
58•crescit_eundo•1w ago•35 comments

Show HN: Playwright Skill for Claude Code – Less context than playwright-MCP

https://github.com/lackeyjb/playwright-skill
79•syntax-sherlock•5h ago•30 comments

Modeling Others' Minds as Code

https://arxiv.org/abs/2510.01272
39•PaulHoule•3h ago•28 comments

How Soon Will the Seas Rise?

https://www.quantamagazine.org/how-soon-will-the-seas-rise-20251020/
24•fleahunter•2h ago•25 comments

Qt Group Buys IAR Systems Group

https://www.qt.io/stock/qt-completes-the-recommended-public-cash-offer-to-the-shareholders-of-iar...
37•shrimp-chimp•5h ago•18 comments

Pointer Pointer (2012)

https://pointerpointer.com
188•surprisetalk•1w ago•23 comments

The Peach meme: On CRTs, pixels and signal quality (again)

https://www.datagubbe.se/crt2/
51•zdw•1w ago•16 comments

Matrix Conference 2025 Highlights

https://element.io/blog/the-matrix-conference-a-seminal-moment-for-matrix/
104•Arathorn•5h ago•65 comments

Automate all the things with Swift Subprocess

https://blog.jacobstechtavern.com/p/swift-subprocess
3•jakey_bakey•1w ago•0 comments

Forth: The programming language that writes itself

https://ratfactor.com/forth/the_programming_language_that_writes_itself.html
287•suioir•16h ago•122 comments

Kohler launches smart toilet camera

https://techcrunch.com/2025/10/19/kohler-unveils-a-camera-for-your-toilet/
19•alangibson•1h ago•25 comments

Introduction to reverse-engineering vintage synth firmware

https://ajxs.me/blog/Introduction_to_Reverse-Engineering_Vintage_Synth_Firmware.html
160•jmillikin•14h ago•23 comments

Fractal Imaginary Cubes

https://www.i.h.kyoto-u.ac.jp/users/tsuiki/icube/fractal/index-e.html
41•strstr•1w ago•3 comments

Duke Nukem: Zero Hour N64 ROM Reverse-Engineering Project Hits 100%

https://github.com/Gillou68310/DukeNukemZeroHour
220•birdculture•20h ago•92 comments

Optimizing writes to OLAP using buffers (ClickHouse, Redpanda, MooseStack)

https://www.fiveonefour.com/blog/optimizing-writes-to-olap-using-buffers
23•oatsandsugar•5d ago•7 comments

Gleam OTP – Fault Tolerant Multicore Programs with Actors

https://github.com/gleam-lang/otp
173•TheWiggles•18h ago•74 comments

Commodore 64 Ultimate

https://www.commodore.net/product-page/commodore-64-ultimate-basic-beige-batch1
85•guerrilla•2h ago•37 comments

What I Self Host

https://fredrikmeyer.net/2025/10/18/what-i-self-host.html
33•FredrikMeyer•1h ago•47 comments

'Phased Out'–Google Confirms Bad News for All 3B Chrome Users

https://www.forbes.com/sites/zakdoffman/2025/10/19/phased-out-google-confirms-bad-news-for-all-3-...
24•RupertWiser•1h ago•7 comments
Open in hackernews

Launch HN: Jazzberry (YC X25) – AI agent for finding bugs

46•MarcoDewey•5mo ago
Hey HN! We are building Jazzberry (https://jazzberry.ai), an AI bug finder that automatically tests your code when a pull request occurs to find and flag real bugs before they are merged.

Here’s a demo video: https://www.youtube.com/watch?v=L6ZTu86qK8U#t=7

We are building Jazzberry to help you find bugs in your code base. Here’s how it works:

When a PR is made, Jazzberry clones the repo into a secure sandbox. The diff from the PR is provided to the AI agent in its context window. In order to interact with the rest of the code base, the AI agent has the ability to execute bash commands within the sandbox. The output from those commands is fed back into the agent. This means that the agent can do things like read/write files, search, install packages, run interpreters, execute code, and so on. It observes the outcomes and iteratively tests to pinpoint bugs, which are then reported back in the PR as a markdown table.

Jazzberry is focused on dynamically testing your code in a sandbox to confirm the presence of real bugs. We are not a general code review tool, our only aim is to provide concrete evidence of what's broken and how.

Here are some real examples of bugs that we have found so far.

“Authentication Bypass (Critical)” - When `AUTH_ENABLED` is `False`, the `get_user` dependency in `home/api/deps.py` always returns the first superuser, bypassing authentication and potentially leading to unauthorized access. Additionally, it defaults to superuser when the authenticated auth0 user is not present in the database.

“Insecure Header Handling (High)” - The server doesn't validate header names/values, allowing injection of malicious headers, potentially leading to security issues.

“API Key Leakage (High)” - Different error messages in browser console logs revealed whether API keys were valid, allowing attackers to brute force valid credentials by distinguishing between format errors and authorization errors.

Working on this, we've realized just how much the rise of LLM-generated code is amplifying the need for better automated testing solutions. Traditional code coverage metrics and manual code review are already becoming less effective when dealing with thousands of lines of LLM-generated code. We think this is going to get more so over time—the complexity of AI-authored systems will ultimately require even more sophisticated AI tooling for effective validation.

Our backgrounds: Mateo has a PhD in reinforcement learning and formal methods with over 20 publications and 350 citations. Marco holds an MSc in software testing, specializing in LLMs for automated test generation.

We are actively building and would love your honest feedback!

Comments

bigyabai•5mo ago
> Jazzberry is focused on dynamically testing your code in a sandbox to confirm the presence of real bugs.

That seems like a waste of resources to perform a job that a static linter could do in nanoseconds. Paying to spin up a new VM for every test is going to incur a cost penalty that other competitors can skip entirely.

MarcoDewey•5mo ago
You are right that static linters are incredibly fast and efficient for catching certain classes of issues.

Our focus with the dynamic sandbox execution is aimed at finding bugs that are much harder for static analysis to detect. These are bugs like logical flaws in specific execution paths and unexpected interactions between code changes.

winwang•5mo ago
Do you guide the LLM to do this specifically? So it doesn't "waste" time on what can be taken care of by static analysis? Would be interesting if you could also integrate traditional analysis tools pre-LLM.
bananapub•5mo ago
how did and do you validate that this is of any value at all?

how many test cases do you have? how do you score the responses? how do you ensure random changes by the people who did almost all of the work (training models) doesn't wreck your product?

winwang•5mo ago
Not the OP but -- I would immediately believe that finding bugs would be a valuable problem to solve. Your questions should probably be answered on an FAQ though, since they are pretty good.
decodingchris•5mo ago
Cool demo! You mentioned using a microVM, which I think is Firecracker? And if it is, any issues with it?
mp0000•5mo ago
Thanks! We are indeed using Firecracker. No issues so far
sublinear•5mo ago
I'm kinda curious how this compares to GitLab's similar offering: https://docs.gitlab.com/user/project/merge_requests/duo_in_m...
mp0000•5mo ago
We are laser focused on bug finding, and aren't targeting general code review, like comments on code style and variable names. We also run your code as part of bug finding instead of only having an LLM inspect it
jdefr89•5mo ago
Ton of work already being done on this. I am a Vulnerability Researcher @ MIT and I know of a few efforts, just at my lab alone, being worked on. So far nearly everything I have seen seems to do nothing but report false positives. They are missing bugs a fuzzer could have found in minutes. I will be impressed when it finds high severity/exploitable bugs. I think we are a bit too far from that if its achievable though. On the flip side LLMs have been very useful reverse engineering binaries. Binary Ninja w/ Sidekick (their LLM plugin) can recover and name data structures quite well. It saves a ton of time. Also does a decent job providing high level overviews of code...
hanlonsrazor•5mo ago
Agree with you on that. There is nothing about LLMs that makes them uniquely suited for bug finding. However, they could excel re:bugs by recovering traces as you say, and taking it one step further, even recommending fixes.
winwang•5mo ago
One possibility is crafting (somewhat-)minimal reproductions. There's some work in the FP community to do this via traditional techniques, but they seem quite limited.
MarcoDewey•5mo ago
Correct, what is unique about LLMs is their ability to match an existing tool or practice to a unique problem.
MarcoDewey•5mo ago
I definitely agree that there's a lot of research happening in this space, and the false positive issue is a significant hurdle. From my own research and experimentation, I have also seen how challenging it is to get LLM-powered tools to consistently find real.

Our approach with Jazzberry is specifically focused on the dynamic execution aspect within the PR context. I am seeing that by actually running the code with the specific changes, we can get a clearer signal about functional errors. We're very aware of the need to demonstrate our ability to find those high-severity/exploitable bugs you mentioned, and that's a key metric for us as we continue to develop it.

Given your background, I'd be really interested to hear if you have any thoughts on what approaches you think might be most promising for moving beyond the false positive problem in AI-driven bug finding. Any insights from your work at MIT would be incredibly valuable.

mp0000•5mo ago
We largely agree, we don't think pure LLM-based approaches are sufficient. Having an LLM automatically orchestrate tools, like a software fuzzer, is something we've been thinking about for a while and we view incorporating code execution as the first step.

We think that LLMs are able to capture semantic bugs that traditional software testing cannot find in a hands-off way, and ideas from both worlds will be needed for a truly holistic bug finder.

csnate•5mo ago
Solving the false positive problem is like solving the halting problem. I don’t think we get to a world where static analysis tools don’t have them, AI or otherwise.

That said, I have found LLMs can find bugs in binaries. It’s not all false positives, as far as I can tell. I have a side project I’ve been working on that does just this (shameless plug): PwnScan.com. It’s currently free and focused on binaries.

The bad news is that you quickly get into a situation where you have too many false positives where it’s sometimes not feasible to sort through them all.

ninetyninenine•5mo ago
It's definitely not like solving the halting problem. A solution 100% exists. You are it. If human intelligence can be realized in physical reality by an actual human brain, then it is provably realizable.

Few things in science exist as a north star in such abundance. We KNOW it can be built. Other futuristic things like interstellar travel... we don't actually know.

ToValueFunfetti•5mo ago
I think it maps perfectly onto the halting problem: just say one of the requirements of your program is halting. Humans can decide whether a program halts in a lot of cases, including more-or-less all of the programs we're likely to encounter. But for the overwhelming majority of possible programs, we can't figure it out.

A useful bug detector doesn't need to overcome this because it would be detecting bugs in the kind of code we write, but there is no bug detector which gives the correct answer for all inputs.

ninetyninenine•5mo ago
I don’t think you realize how universal the halting problem is in the universe.

Like the law governs everything that exists in the universe so it governs humans as well.

If a human can know that a program halts it also means the program is provably haltable. If a human doesn’t know whether a program will halt it likely means that the program is not provably haltable.

The halting problem refers to a general algorithm that can prove any program will halt.

jollofricepeas•5mo ago
The funny thing is…

You’re stating the problem with that whole sector.

I really wish product owners, researchers and tool creators had more actual real world experience on the remediation side. I think that’s the reason we have so many crappy tools.

- We need a better way of addressing business logic issues and sensitive data leakage which starts at the data model and flows from there.

- Within large organizations we need better risk data about vulns to aid with prioritization and remediation which is always the larger problem (sifting through noise)

- We need automated threat modeling tools that reduce a teams need to start from zero

Fundamentally a tool is a waste of time if it can’t tell you there’s “x% possibility of downtime or sensitive data leakage.”

Addressing the risk equation (r=il) where the impact and likelihood variables are baked into every tool and based in real world data is where we should be.

Until then, vulnerability scanning and management will continue to suck.

MarcoDewey•5mo ago
I also wish that I had more real world experience. It would help me a ton if I had 25 years of software testing experience.

It sounds like you do have experience, and I would love to learn from you. It would be awesome if you could help us build a tool that is truly useful for you and your work.

ArnavAgrawal03•5mo ago
I've used your product and particularly like that you show bugs in a table instead of littering my entire PR.

Does Jazzberry run on the entire codebase, or does it look at the specific PR? Would also like some more details about the tool - it seems much faster than others I've tried - are you using some kind of smaller fine-tuned model?

mp0000•5mo ago
Thank you! This is definitely a design choice we believe strongly in.

Jazzberry starts by viewing the patch associated with the PR, but can choose to view any file in the repo as it searches for bugs. All the models in use are off-the-shelf for now, but we have been thinking about training a model from the beginning, stay tuned!

RainyDayTmrw•5mo ago
I wish I could click into the "real bugs" and see full example output.
MarcoDewey•5mo ago
The bugs shown in the "real bugs" section are real output from the tool. Are you referring to looking at the full table of bugs that we return? Sometimes we only find one bug in the PR, sometimes our clients don't want us to share other bugs that could expose their work.
bluelightning2k•5mo ago
Interesting choice to have your only demo video be testing a CLI. Unless that's literally the use-case it's for?
MarcoDewey•5mo ago
That is one of the obvious use cases. There are many others, you are welcome to install the bot and play around with it. I would love to hear your feedback.
AIorNot•5mo ago
Very cool - what’s the scope of its abilities:

Can this be used for UX bugs eg nav bugs or finding runtime errors in a react site? Ie will it check the frontend

MarcoDewey•5mo ago
Yes, we have caught some navigation bugs on the front end.

There are some other really cool tools built explicitly for this, like QualGent and Operative.sh

rylanu•5mo ago
Having an agent explore a sandbox environment, install dependencies, execute tests, etc. This sounds slow and resource intensive. Does Jazzberry scale for large teams with monorepos and dozens of PRs daily?
MarcoDewey•5mo ago
We are working daily on making Jazzberry better for larger teams and repositories. Our goal is to find deep, difficult bugs in large repos
sorokod•5mo ago
What is your experience on running your product on it's own code?
lacker•5mo ago
I tried it out but I don't have any pending pull requests on my personal repositories, and I don't want to give a new tool write access to a professional repository where other people are working before trying it out a bit. It would be great if it would scan a repository and tell me if it found any bugs, so that I could see if it worked before messing with real pull requests.
rylanu•5mo ago
Microsoft is having so many issues it would be really helpful for tools like this to be used now.