I just saw a vibe coded game on HN, and thought maybe I should post about this here.

I'm organizing a vibe coding game dev competition called Vibe Jam.

Last year we did it too and there was 1000+ games submitted.

This year the deadline is May 1 and you can submit your games until then.

There's $35,000 in prizes with the Gold prize being $20,000.

Let me know what you think!

-Pieter

Comments URL: https://news.ycombinator.com/item?id=47730124

Points: 4

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=47730076

Points: 1

# Comments: 0

The fun part was the puzzle engine. It generates every possible puzzle for a given configuration by exhaustive enumeration, then checks all possible worlds against all possible statement assignments, deduplicating equivelant puzzles via canonical forms, and detecting which properties are uniquely determined vs. indeterminate. For larger configs (3+ people), it uses random sampling of phase space to reduce memory cost and time.

The result is 57 million puzzles for up to 4 speakers. From this, 6,000 were included in the game using stratified balanced sampling across features.

Other bits: Glicko-2 ratings for adaptive difficulty (both players and puzzles have ratings), "whodunit" mode where you also figure out who committed a crime, and a "normals" variant where some people can say anything.

It's free during beta with no ads (ever). Requires a quick sign-in (Google/Apple/GitHub/Discord) for the rating system to work, but only stores an anonymous ID (no email or other personal data).

I'd be interested in feedback on difficulty, puzzle variety, or anything else. Depending on interest, I plan to add additional puzzle types and ability to play via API over the next few weeks.

Comments URL: https://news.ycombinator.com/item?id=47730020

Points: 1

# Comments: 1

Comments URL: https://news.ycombinator.com/item?id=47729938

Points: 1

# Comments: 0

I finally built the version I wanted to play. Kampfinsel is live at kampfinsel.com right now with real players on it. It's not a straight copy of the old game. I gave it its own world. No magic, no gunpowder – just ballistas, fire pots, and slow ships crossing huge distances. Three resources: gold, stone, wood. Travel between islands takes hours, not seconds. It's slow on purpose.

The whole thing runs on Cloudflare's edge. Workers for the game logic and API, D1 for the database, KV for sessions and caching, R2 for assets and Durable Objects for per-island state and the tick system (fleet arrivals, combat, resource generation). There's no origin server at all. Making a stateful multiplayer game work inside Workers' CPU limits and D1's consistency model meant some non-obvious choices: resources are calculated on-read from timestamps instead of being ticked into the database, fleet movements live in Durable Object alarms and combat writes are batched. This helped me a lot!

The look is intentionally rough and text-heavy (Hi HN!): server-rendered HTML, tables, a parchment color palette, Unicode icons, no frontend framework, no build step. The only JavaScript is for countdown timers and auto-refresh. I wanted it to feel the way I remember these games looking, not how they actually looked. Honestly, it looks a lot like HN itself - tables, monospace, no chrome. If you like how this site looks, you'll probably feel at home.

No signup wall, no premium currency, no pay-to-win. Feedback very welcome, especially from anyone who played this kind of game back in the day or has opinions on running stateful stuff on Workers + D1 + Durable Objects. I'll be around for the next few hours.

Comments URL: https://news.ycombinator.com/item?id=47729925

Points: 3

# Comments: 0

It classifies text into multiple moods (happy, sad, anxious, etc.), shows confidence and probability distribution, and exposes both an API (FastAPI) and a UI (Gradio).

The goal was to go beyond just training a model and make something actually usable.

Live demo: https://huggingface.co/spaces/aman179102/moodsense-ai

Source: https://github.com/aman179102/moodsense-ai

Tech stack: Python, scikit-learn, LightGBM, spaCy, FastAPI, Gradio

Comments URL: https://news.ycombinator.com/item?id=47729679

Points: 1

# Comments: 1

It classifies input into multiple moods, shows confidence and probability distribution, and includes both an API and UI.

The goal was to move beyond just training a model and build something usable.

Source: https://github.com/aman179102/moodsense-ai

Feedback is welcome.

Comments URL: https://news.ycombinator.com/item?id=47729663

Points: 1

# Comments: 0

From initial testing, much faster for small tasks, however it is costly to test, so keen for other people to give it a go. No more waiting for compaction!

Currently opencode is supported as a plugin.

Can look at Claude Code if someone would like to sponsor.

There is an evaluation system and sample tasks that shows results empirically (Results not yet published).

Comments URL: https://news.ycombinator.com/item?id=47729563

Points: 2

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=47729558

Points: 1

# Comments: 0

The interesting part was that within a few hours of sharing it with my friends, some of them set about trying to overrun the leaderboard by launching a swarm of AI bots to learn the game and figure out how to get the highest score. This set off a game of cat-and-mouse as they found vulnerabilities and I tried patching them.

Within hours of sharing, someone used the Claude browser extension to read game.js directly. Large parts of the scoring formula, action effect values, and bonus thresholds were sitting in client-side JavaScript - this was a trivial thing even a human could've found, but a human would've still had to play the game, whereas the AI bot just optimised directly against the scoring formula. It meant that the first AI already scored 2.5x higher than the best human player by optimising directly against the source code rather than playing the game.

Straightforward fix: moved the entire game engine server-side. The client is now a dumb terminal, it sends an action ID, receives a rendered state. No scoring logic, no bonus thresholds, no action effects exist in the browser. The live score display uses a deliberately different formula as misdirection.

This increased the difficulty in finding bot-enabled hacks, so the subsequent bots tried brute-forcing the game, trying to game the RNG functions, and other methods.

But the next winning bot found a vulnerability where the same signed session token could be replayed. It would play turn N, observe a bad random event, replay the same token for turn N, get a different RNG outcome, keep the best one. Effectively branching from a single game state to cherry-pick lucky outcomes across 30 turns. Managed to 1.5x the previous bot's high score.

The bot's own description: "The key optimisation was token replay. Because the backend let the same signed state be replayed, I could branch from one exact game state repeatedly and continue from the luckiest high-value outcome each turn."

Fix here: consume a turn nonce atomically before any randomness is generated.

The current state is that the leaderboard is now split into human and AI-assisted. I think the capability of AI bots has flatlined a bit now. Perhaps Claude Mythos might be able to discover the next hackable exploit ¯\_(ツ)_/¯

Happy to go deeper on any of the above - or just enjoy the game! Feel free to try your own AI-powered leaderboard attempt too!

Comments URL: https://news.ycombinator.com/item?id=47729477

Points: 4

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=47729289

Points: 1

# Comments: 0

I’m using Gemini Pro 3 to analyse recent articles from a list of trusted sources. It identifies the 5 highest priority stories, considering things like if a vulnerability is being actively exploited, novelty and breadth.

If CVEs are identified, it will check for CISA KEV status, EPSS score and if POCs are available on GitHub. It then provides an overall executive summary plus analysis for the top stories, including details, affected systems, potential impact and mitigation actions.

The brief is then passed to Gemini again for verification and fact checking against the source articles and other CVE data retrieved to correct any potential hallucinations.

It’s a paid monthly subscription based app, but it has a 7 day free trial for new users. You can manage subscriptions and cancel from the account tab. If anyone wants an extension I can look at setting up a promo code, please message me.

I would be very grateful for feedback, particularly if the mitigation information is useful, if you think the critical alerts are critical enough to be notified about, any good sources I could add or anything else.

Happy to answer questions. Play Store Link: https://play.google.com/store/apps/details?id=com.cyberpulse...

Comments URL: https://news.ycombinator.com/item?id=47729065

Points: 1

# Comments: 0

Tallyman is what happened next: a keyboard driven email client on top of Gmail and Outlook. Your vim muscle memory works (j/k, gg, relative line numbers, counts, ...) 39 rebindable shortcuts, command palette, email templates, themes ...

No migration. OAuth only. Verified by Microsoft and live now. Google verification is under review.

30 day free trial, $9/mo per inbox after that. Write me an email if you need an extended trial: contact@tallyman.io

Comments URL: https://news.ycombinator.com/item?id=47728849

Points: 7

# Comments: 2

Comments URL: https://news.ycombinator.com/item?id=47728661

Points: 1

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=47728043

Points: 2

# Comments: 0

I have recently been playing around with AI and formal methods and built Provepy. It's an experiment to see if we can use frontier LLMs to bridge the gap between everyday Python code and formal verification in Lean.

The idea is to make formal methods more accessible by burying the complex Lean syntax behind a standard Python decorator. You add @provable to your function, give it a plain English claim, and run your code.

  from provepy import provable

  @provable(claim="This function returns the sum of its inputs")
  def add(a: int, b: int) -> int:
    return a + b

Generation of the theorem, code and proof is done separately to avoid the LLM proving the wrong claim or function just to succeed in the proof.

If Lean compiles and accepts the proof, your Python function executes normally. If the proof fails, your program halts with a VerificationError.

You can also pass context to the decorator if your function relies on other Python functions in your codebase. I also added a fallback mechanism—you can configure a smaller, cheaper model to try first, and if it fails to generate a valid proof, it automatically retries with a heavier model.

To be clear: this is very experimental alpha software.

It currently only works reliably on simple functions.

There's a lot left to do, like improving how context is pulled from the AST and resolving name clashes with Lean's mathlib.

Contributions are most welcome!

I'd love to hear your thoughts.

Github: https://github.com/genie16/provepy

Comments URL: https://news.ycombinator.com/item?id=47728039

Points: 3

# Comments: 0

Inspired by the videos of Liz Oyer, I wanted to be able to verify her claims and just look up all the pardons more easily.

Tech Stack: Playwright - to sccrape the DOJ website SQLite - local database Astro 6 - Build out a static website from the sqlite db

All code is open source and available on Github.

Comments URL: https://news.ycombinator.com/item?id=47727960

Points: 83

# Comments: 20

I built this over the past couple of weeks out of frustration of not having something like Claude Code Desktop, Conductor, Emdash and a few others in a Linux Environment (and a Windows/WSL environment).

Dux takes some of the good learnings from most of the UIs today but offers it in a nicely packaged form. You can create multiple agents off the same repo via Git Worktrees, and you leverage Claude's native terminal UI or Codex's own (with support for bringing your own too).

It's a v0 still, but happy to take any feedback as long as it's possible to be done!

Comments URL: https://news.ycombinator.com/item?id=47727890

Points: 2

# Comments: 1

Usually, when an agent fails a task, we developers step in to manually tweak the prompt or adjust the code logic. I wanted to see if an agent could automate its own improvement loop.

Built on LangChain and LangGraph, HyperFlow uses two agents: - A TaskAgent that solves the domain problem. - A MetaAgent that acts as the improver.

The MetaAgent looks at the TaskAgent's evaluation logs, rewrites the underlying Python code, tools, and prompt files, and then tests the new version in an isolated sandbox (like Docker). Over several generations, it saves the versions that achieve the highest scores to an archive.

It is highly experimental right now, but the architecture is heavily inspired by the recent HyperAgents paper (Meta Research, 2026).

I would love to hear your feedback on the architecture, your thoughts on self-referential agents, or answer any questions you might have!

Documentation: https://hyperflow.lablnet.com/ GitHub: https://github.com/lablnet/HyperFlow

Comments URL: https://news.ycombinator.com/item?id=47727255

Points: 5

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=47727020

Points: 3

# Comments: 0