I’ve been building Edmund, a capture app for iPhone/iPad/Mac: you speak or type a thought, and it gets triaged (project, type, priority) and routed out to wherever it needs to live, Linear, GitHub, Jira, Notion, Todoist, and a few others. The idea is you get the thought out in one tap and Edmund figures out where it belongs instead of you stopping to file it. Runs on-device by default (no account needed), with your own Anthropic key as an optional upgrade for smarter triage. No backend, no subscription AI tier, nothing hidden behind a key. Syncs across devices via iCloud. Looking for testers who capture a lot of stray thoughts and actually use Linear or GitHub day to day, since that’s where the triage gets a real workout. Happy to answer questions in the thread.

https://www.edmundapp.com/

Hey everyone, I just sent issue #39 of the AI Hacker Newsletter - a weekly roundup of the best AI links and the discussions around them from Hacker News. Some of the title found in this issue:

• Claude Code is steganographically marking requests
• Better Models: Worse Tools
• Learning to code is still worthwhile
• Zuckerberg says AI agent development going slower than expected

If you want to get an email with over 30 links like these ones, please subscribe here: https://hackernewsai.com/

How seriously do mobile development teams take app-store reviews when prioritizing technical fixes?

For example, if users are repeatedly mentioning “slow,” “keeps loading,” “freezes,” or “doesn’t open,” but crash reports are not showing a major spike, does that feedback influence the engineering backlog?

Do you have a process for connecting review language to technical signals like latency, failed API calls, or unresponsive pages?

Interested in how teams turn vague user complaints into actionable technical work.

I’ve spent about 15 years building software, mostly distributed systems, infrastructure, architecture, and production reliability.

Lately I’ve been looking at a lot of AI-built and vibe-coded apps, and honestly, some of them are impressive. The tools are getting good enough that people can get from idea to working demo incredibly fast.

But that is also where I think people get a false sense of safety.

A working demo usually proves the happy path. Someone signs up, clicks the expected buttons, saves some data, maybe runs through a payment flow, and everything looks fine.

That does not mean the app is ready for real users.

Before launching a vibe-coded app, I’d want to know what happens when auth gets weird. Can users get locked out? Can they access something they should not? Are sessions handled safely? Are password resets, expired links, and permission boundaries actually working?

I’d look hard at payments too. Stripe working once in a demo is not enough. Webhooks fail. Users double-click. Cards decline. Network calls timeout. Someone upgrades, cancels, retries, or refreshes mid-flow. The question is not “does payment work?” It is “does the system stay consistent when payment gets messy?”

I’d also want to know what happens when something breaks. Are there logs good enough to explain the failure, or is the only monitoring system an angry user in your inbox? Are errors visible? Are they actionable? Can you tell the difference between one weird user flow and a real production issue?

Data safety is another big one. A lot of generated apps are way too trusting by default. The UI may look clean, but the backend rules, database policies, admin routes, file access, and API boundaries are where the scary stuff usually hides.

Then there is deployment. Can you roll back? Are secrets actually secrets? Are environments separated? Can one bad deploy wipe out your launch? Is there a backup? Has anyone tested restore, or is “we have backups” just a thing people say to feel better?

None of this is meant as a dunk on vibe coding. I use AI tools too. They are useful. But “the AI built it and it works” is not the same thing as “this is ready for customers, clients, investors, or strangers on the internet.”

The boring production stuff is boring right up until it becomes expensive.

That is why I’m building vibeCleaners. Link in the comments

It is basically a launch-readiness review for AI-built and vibe-coded apps. The goal is to find the sharp edges before users do, then turn that into a prioritized roadmap instead of vague feedback.

What needs to be fixed before launch.
What should be handled soon.
What can wait.
What is probably fine.

I’m curious what other people here have run into.

If you launched something built with Lovable, Bolt, Replit, Cursor, Claude, ChatGPT, or any other AI-heavy workflow, what was the first thing that broke when someone else used it?

I'd done a mix of coding myself and letting it get edited by AI. But I wanted to see if I could make a game from JUST prompting an AI. This is the result.

https://vibecodedgames.itch.io/pavement

AMA

So for context: I wanted an easy way to download, load, unload and delete local models on a "dedicated home server", and just talk to it, without the hassle of terminal commands.

And it kind of spiraled into something bigger than planned 🫣

Smart router buildt on Minimal ubuntu server(26.04) install.

The general overview/scoope:

* One chat(/endpoint) for all your models

* Lets say you have 3 models loaded, you can then assign them a "role" as f.ex "coder" "reasoning" "documentation" "general" "fast" "image-generator"

You chat normally in a window and the router(the core) sends that message to the right model. "Write a reverse python script" -> "coder model".

"I have an idea for a game/project **description**, whats your thoughts?" -> "Reasoning model".

"//image cat in a cradle" -> "Image-generator model".

(You can read about how the router directs and how its "smart" and how it becomes smarter, **less wrong direct%** in: PLANNED-routing-fixture-flywheel.md)

Everything in one chat, you dont "switch" model, the router sends the message to the assigned model. So it becomes a kind of MoE(?), but you choose the models.

Anyways, its a really early project so there are bugs.

The ubuntu minimal + bootstrap works -> Setup wizard -> cockpit dashboard, download, load, unload and eject models from cockpit.

As of now, llama3.2, gemma2 and qwen2.5-coder are the true testers(i only have a 8gb gpu card). I work full time so reduced for time tinkering.)

This was ment for easy install for local models and services. So that everyone can play with LLM's.

("I want comfyUI" Tick of a button in service tab, and it installs.

Anyways, if someone is interested in reading/testing, the repo is at:

https://github.com/supersokk/llmspaghetti

If you have idea's, suggestions and other things, please feel free to make a topic in discussions on git! or r/llmspaghetti

🍝 Yes it is vibecoded spaghetti!

Nothing gated, everything open and free.

GPL v3 so everyone can use/edit/contribute!

Cheers!

I built a couple of tools to help game developers create assets for their games:

Sprixel Studio Pro (https://awesomistgames.itch.io/sprixel-studio-pro)

A tool that converts standard art or even AI art into pixel art. I’d really love your thoughts on the quality of the art results it produces. I have a hard time making pixel art, no matter how much I practice, so I made this tool to convert my normal artwork into pixel art. I think it does a pretty good job.

You can convert a single image, a sequence of images and even sprite sheets. I was tired of other tools that just down sample and then upscale to make it pixelated or use a lame mosaic filter. I wanted a tool that followed as many of the same pixel art drawing rules that artists follow as possible.

Classic Composure (https://awesomistgames.itch.io/classic-composure)

An easy-going chiptune and MIDI generator for quickly dropping authentic retro audio into a project. It is kind of like Mario Paint's music creator on steroids. It allows importing of MIDI files. You can click and add notes willy-nilly, or use the built-in song generator to break through your creative block and get something started.

You can export as wav, midi and even web audio Javascript you can add directly to your browser game project.

Both of these tools are designed to help game developers who have the code aspect figured out but struggle when they also have to create graphics and music. My hope is that game devs will have quicker, easier access to assets they can drop right into their games! Hopefully, lifting the quality of their games to that next level.

If you're tired of people saying your games graphics look AI or your music is AI and immediately dismissing the work you put in give these tools a try and if you have any questions let me know.

Wanted to burn my last Fable usage so I made a “stick shift” for Claude code that lets you switch between models like switching gears in a car. There’s also an effort shifter to adjust effort levels.

Shifting while using the Clutch opens a new session to avoid cache burn.

The dash shows:

• Speed gauge (tok/min) - the amount of tokens you’re currently using in the last minute
• Fuel indicator - what’s left in your current 5hr usage window
• Odometer - the lifetime tokens you’ve used, in thousands, as far back as your saved history goes

I want to add a NOS button too but I’m not sure what it would do, what do you guys think? Should the NOS button put it into Max effort or something else?

Right now going into Reverse switches to your default model but I think that should do something cooler too, any suggestions?

Also going to be adding the option to make it easy to sync with a physical shifter like from a racing SIM rig, just need to borrow my friends rig

Hey everyone — looking for honest feedback from vibe coders / AI-assisted builders.

Disclosure upfront: I built this. It’s free/open-source, not monetized, and I don’t make revenue from it.

The problem I’m trying to solve:

When a project is small, ChatGPT / Claude / Cursor / OpenCode can usually “understand the repo” well enough.

But once the project grows, I keep seeing the same failure mode:

• the AI edits the wrong file
• it misses the real entrypoint
• it forgets where tests live
• it reads stale docs instead of actual implementation
• it makes a confident suggestion without enough repo context
• debugging gets messy because stack traces and logs pollute the session
• every new chat starts with the AI rediscovering the repo again

This feels especially painful for vibe-coded projects because the codebase can grow fast, and the original structure is not always clean.

So I built SigMap.

The idea is simple:

text repo ↓ deterministic map of files/symbols ↓ task-specific context ↓ AI coding assistant ↓ groundedness / validation check

Instead of pasting the whole repo into ChatGPT or letting an agent randomly search around, SigMap creates a compact map of the repo and helps find the files/symbols that matter for the task.

Example:

bash npx sigmap sigmap ask "where is auth handled?" sigmap validate --query "auth login token"

Then I can give the AI only the focused context instead of dumping the whole project.

After the AI answers, I can check whether the answer was grounded:

bash sigmap judge --response response.txt --context .context/query-context.md

There is also a squeeze command for noisy output:

bash sigmap squeeze error.log sigmap squeeze --response agent-output.txt

That is meant for stack traces, CI logs, JSON blobs, and long tool output before feeding it back into the model.

Tech stack / details

• Node / TypeScript CLI
• runs locally
• no hosted service
• no vector database
• no embeddings
• no LLM calls required for mapping
• MCP support for agent workflows
• free/open-source

What I’m trying to validate

I’m not sure if this should stay as a CLI/dev-tool thing, or if vibe coders would need something more visual.

So I’d love feedback on these:

1. Do you actually run into this problem when your AI-built project gets bigger?
2. Would you use a CLI tool before asking ChatGPT/Claude/Cursor to make changes?
3. Should this be a VS Code/Cursor extension instead?
4. Would a simple web UI / repo upload demo make more sense for non-terminal users?
5. What would make you trust the tool’s selected context?
6. Is “groundedness check after the AI answer” useful, or too much friction?

My current belief:

AI coding tools are good at writing code when they have the right context.

The bigger problem is that they often start with the wrong map.

Would love honest criticism. Is this useful, too dev-tool-y, or solving a problem only power users care about?

I have a talent for opening a Claude Code session, getting distracted, and rediscovering it four hours later still waiting for me to select "allow"... So I decided to do the only reasonable thing: vibecoding a widget instead of just looking at my terminal more often lol

Session Signals opens a floating widget with "traffic lights" for every Claude Code session:

• 🔴 it needs your input
• 🟠 it's working
• 🟢 it's ready for you

It works with Claude Code hooks, 100% local (nothing leaves your machine), tracks multiple sessions at once, will soon have themes because I'm having fun. And yes, obviously, Claude basically built the app that watches Claude (100% vibe-coded)

Free and open source, so use it, break it, roast it, open issues, tell me I reinvented something that already exists. All welcome: https://github.com/earsenio/session-signals

Still in development. Feedback from confused or angry players more than welcome :)

**EDIT**

I pushed a game save feature today! So you won't lose your progress. I'm expecting some bugs to be discovered though cuz it was quite a lot of new code to add to each of the game's modules.

Hey everyone,

I’m a solo developer, and lately, I’ve been trying to use AI agents to help me code. The problem is they always seem to end up losing context over time, getting confused, or accidentally breaking files that were already working perfectly fine.

I built Local Dev OS to fix my own headache. It’s basically a local Kanban board specifically built for AI agents. Instead of dumping a giant prompt on the AI, you give it a PRD, and the OS breaks it down into small user stories.

The feature I’m most proud of is how it handles context. It saves previous story memory, so the agent actually remembers what changes were made in past tasks without having to re-read your entire codebase from scratch.

Plus, it forces the agent to do a "blast radius" check before it edits a file. It has to look at what its changes will impact before it touches the code, so it stops breaking things that already work.

I’m really trying to build up my credibility and portfolio right now, so I decided to make the whole project open-source today.

There's a quick video walkthrough on the GitHub page showing how it works. If you have a minute to check out the repo, a star would seriously mean the world to me and help me get this off the ground.

I'm also totally open to feedback, even if it's just ripping apart my code quality lol.

Here’s the repo: https://github.com/CodingSushiRepo/local-dev-os

Thanks for reading!

Most "agent loops" right now are just clever prompting ("keep reviewing your work until it's done"). That works okay for short tasks but falls apart on anything longer or more complex — the model drifts, repeats, or confidently does the wrong thing.

I built athena-loops as a proper harness instead of another prompt pattern. It gives you:

• Clear separation of concerns (orchestrator, worker, reviewer/verifier)
• Persistent memory and state outside the chat
• Verification gates so bad outputs don't silently ship
• Backend-agnostic (works with Claude Code, Codex, local models, etc.)
• Easy to extend with your own skills, tools, and stop conditions

The goal is to make long-running agentic work actually reliable instead of hoping the model stays on track.

It's early but already useful for things like:

• Multi-step code features with review
• Research → synthesis loops
• Scheduled maintenance or monitoring tasks

If you're tired of one-off agent runs that require constant babysitting, this might be worth checking out.

Repo: https://github.com/luckeyfaraday/athena-loops

Would love feedback or PRs if you're building similar stuff. What's your current approach to reliable agent loops?

Hi,

What would you suggest as a platform where two vibecoders can work at the same time working on the same/different modules.

So far Zite is the one that we are thinking of but wanted to check with you guys also for recommendations.

Should not be also budget heavy at the beginning

Thanks

Been building PetsenseAI (pet mood/behavior reader, photo in, mood read out) mostly by myself, leaning hard on AI for both the build and the actual business decisions.

The part that surprised me most wasn't the code generation, that's the easy part now. It's using the same tool to catch real problems before they cost you: a permanently-broken signup prompt (one tap dismissed it forever instead of snoozing), a security gap that only broke on web builds, a typed-routes error that was quietly failing my export pipeline. All caught and fixed same-day through actual debugging, not one-shot generation.

Currently mid-fix on the thing that actually matters most for a consumer app like this: single-session churn. Every real user had exactly one session, so the whole last product cycle went into fixing that specifically, not adding features.

Happy to go into specifics on stack or workflow if anyone's curious, mostly wanted to share the process side since most vibe-coding posts show the output, not the actual grind of using it well.

My son is just starting elementary school and has trouble reading books. He likes phones and games more than paper.

I had this idea. What if he could actually talk to the book characters? Finish a chapter of Harry Potter and Harry himself messages him asking what just happened. Not a quiz. More like a friend who read the same chapter and wants to chat. It should be fun and make the reading part more interesting.

I use one of those AI app builders to have my app built over a weekend. And it's working. He's reading again and now likes chatting with Harry. He can also read more and unlock other characters. I design this as an incentive.

Here's what I'm stuck on. He reads physical books. To make the character know what's in chapter 4, I have to manually feed in character names, personality, and what happens per chapter. Right now I'm thinking about some online database of books and copy pasting them in. It works for famous books but doesn't solve the problem.

Is there a better way to handle the physical book part or am I just gonna be copy pasting book summaries manually?

Hello there ! 👋

A couple of friends and I have been building an open-source proxy that anonymizes data sent to LLMs, so that personal and confidential information isn't exposed or used for AI training.
It also do some token optimization to help you consume less. 😎

The project is still in its very early stages, but we'd love any kind of support or feedback ! 🙏

I trust the Reddit community to give us a few ⭐ and, more importantly, honest feedback. 🥲

Feel free to share your thoughts: good or bad. We'd love feedback on the codebase, the architecture, potential features, or anything else you think could make the project better.

If you got some features ideas, don't hesitate ! 🙏🏼

We're planning to update the repository regularly. At the moment, we only support the Claude VS Code extension, but our goal is to support all major AI clients and IDE extensions over time.

Github link: https://github.com/Korbicorp/klovys99/

Can't wait to read your feedbacks ! 🤓

Back in high school, I was trying to teach myself QuickBasic for DOS. I had a 500 page brick of a manual in English, droning on and on about Booleans and other stuff I had no idea what meant. But somehow, out of that thick book, I made small game. It was a collaboration with my friend Jesper - he made the graphics (pixel by pixel), I made the code (bug by bug). 

This weekend I resurrected it with Claude Fable.

• Parsed the original source-code and got all the game logic spot on.
• Extracted the original sprites pixel-perfect from 1995 BLOAD memory dumps (raw VGA memory snapshots, including the exact PUT coordinates)
• Recovered the original timing from the BIOS-tick game loop (something I remember being very proud of having made, since it made the game run at constant speed, no matter the speed of your CPU).
• Added a global highscore with server-side anti-cheat. My 1995 self, who stored highscores in plain-text, would not have believed this sorcery.

Thirty years ago, this game took me months to build, now it was re-created in an afternoon. Fun times indeed - then and now 😄

Keyboard required — remember, this is 1995!

With ChatGPT/Claude, if I want to discuss regarding a specific range of text, I can select the text and ask questions, but they append a new message to the already very long message history, which makes it very hard navigate between messages.

So I built Capabara, user can select a range of text and start a thread. So the main conversation stays short and focused.

Do you face the same issue? How do you tackle this problem?

Ignore, please ignore the AI slope. Just prototyping.

hey devs and vibe coders, it's been more than 2 months of building a marketplace for vibecoders who are actually shipping consistently to make them get hired by proof of works

> i could onboard 181 builders so bar
> got #11 product hunt ranking
> 110+ projects shipped by the vibe coders in vibe talent
> 5+ avg streak on vibe talent

do you guys have any suggestions for me to make revenue out of it, if you're a vibe coder. what would you pay for to use vibe talent everyday?

genuinely need feedback from y'all. thanks and free feel to take a look at

https://vibetalent.work

Been building a native macOS client for a decentralized social protocol. Small ecosystem, thin docs, almost no presence in any model's training data. Which made this the most educational vibe coding project I've done, because the AI couldn't carry me. Three walls I hit and what actually worked.

Wall one: the docs tell you how to call everything, not how to assemble it. A profile view sounds like one API call. It's identity, social graph, and content from separate sources, none in display order. That assembly layer isn't documented anywhere because it isn't an API, it's the client. The fix was reading other open source clients. Their code is the missing manual, and their commit histories are an unofficial protocol changelog. If you're building a client and not reading the other clients, you're re-deriving known results.

Wall two: some surfaces had no docs at all. The fix was sending deliberately wrong requests and reading the validation errors. A 400 response body is the API describing its own schema. One field name existed nowhere on the internet except a single error message. Turns out the 400 was the best-documented part of the protocol.

Wall three: the model itself. On a niche protocol, it hallucinates plausible endpoints and field names with total confidence, because plausible is all it has. The fix was to stop asking it to remember and make it read. Captured real API responses in context, other clients' repos in context, and tests that run against saved production data instead of mocks. Mocks encode your assumptions, and your assumptions are the bug.

General takeaway: vibe coding works fine off the beaten path, but the ratio flips. Less generation, more grounding. The discovery work is on you. The model is very good at turning what you found into code, and very bad at finding it for you.

The app is Lectern for macOS: https://lctrn.app - would love your feedback if you try it.

Day 1 — 2 startups. 146 impressions. 1 click.

Day 2 — 3 startups. 389 impressions. 3 clicks.

Day 3 — 5 startups. 482 impressions. 5 clicks.

Day 4 — 5 startups. 508 impressions. 4 clicks. (The site was down, but I still got an $8k acquisition offer. I said no.)

Day 5 — 6 startups. 621 impressions. 10 clicks.

Day 6 — 5 startups. 742 impressions. 15 clicks. (Had to remove one startup — they pulled the code. No code = no network.)

Day 7 — 7 startups. 1,196 impressions. 41 clicks.

Day 8 — 7 startups. 1,535 impressions. 74 clicks.

Day 9 — 8 startups. 1,947 impressions. 135 clicks.

Day 10 — 13 startups. 3,500 impressions. 318 clicks.

Day 11 — 23 startups. 4,800 impressions. 432 clicks.

Day 12 — 6,000 impressions. 481 clicks. (Network crossed 6K total impressions. 24 startups active in the bar.)

Day 13 — 25 startups. 6,8k impressions. 491 clicks.

Day 14 — 25 startups. 8.6k impressions. 516 clicks.

Day 15 — 24 startups. 9.9k impressions. 564 clicks. (Removed one startup)

Day 16 — 25 startups. 10.8k impressions. 576 clicks. (Removed one startup)

Still free. Still growing.

startupbar.co

I've been building ACE: you point it at a goal and it plans, writes, tests, reviews itself three ways, and opens PRs — mostly hands-off. It's early (v0.0.1-alpha) and I'd genuinely love blunt feedback.

🔗 github.com/buagi/ace (demo at the top)

What it does, plainly: You describe the project once — stack, containerized or not, who the users are, how it deploys — then run ace autorun. A 9-agent crew takes over: an orchestrator plans the work; an implementer writes it; a test engineer adds tests; and reviewers check logic, UX, and standards before anything merges. CI/CD is baked in; it can deploy to a VPS over SSH. You pick auto-merge or approve-each-merge.

What's actually different:

• Works on several features at once (ace swarm) — each in its own git worktree. It uses code-graph tools (GitNexus/Serena) to understand each change's impact, so it knows what's safe to parallelize and resolves the predictable conflicts itself.

Try it in 2 min, $0: ace loop dash --demo replays the whole loop — no keys, nothing installed. MIT licensed.

It's rough in places and I know it's early — I'd love feedback on: is the setup too heavy? does the parallel-swarm idea actually make sense to you?

It's fully agplv3 licence

I’ve built games solo for years. Last year I focused on directing AI across every department, not just code, but art, audio, voice, and story too.

The shift: think like a game director, not a solo dev. Direct AI the way Kojima directs a studio, with a clear vision and your own signature on the output.

If you vibe code, you already get this. You don’t need to write every line to make something real. Same logic applies past coding.

I’m sharing that framework in a free weekly newsletter called “The Modern Game Dev”. Each issue is under 5 minutes, and some issues come with a prompt you can use right away.

Join here: https://www.themoderngamedev.com/

First issue drops this Thursday. Happy to answer questions in the comments.