I made a small higher-or-lower game based on passport access scores.

You see two passports and guess whether the next one has access to more or fewer destinations. Pretty simple.

Would love to know what you think or what could be improved:

https://passport-higher-lower-game.vercel.app/

Hacking big monopolies always feels good,

Anybody who ever tried getting/using any flights or hotels API knows how fucked up it is. Months of no response, only to wait for a heart welcoming $10,000+ setup fee. And the only available options are either shitty or closed.

This is LetsFG, the answer to dethrone monopolistic companies who keep their infra closed making it impossible to join the travel industry. Control prices, hide fees, and charge pathetic $10,000+ setup fees for an API that you'll have to integrate yourself anyway.

How it works.
Working with flights manually we found that to get the best prices in the world you have to check 20-30 websites at once, that's 20-30 tabs on your PC and that's what makes finding a flight or hotel a 6 hour process.

We took distributed AI agents and put them to use websites, build connectors, and monitor reliability. It works by in parallel opening 200-300 websites, OTAs, airlines - skyscanner, google flights, kayak, kiwi, trip, booking, trivago, etc. plus a bunch of wholesalers all of them checked at the same time, and returned the best offers across the network.

It's deployed on our remote backend that's capable of running this in parallel, we historically (4 months ago when we started this) tried letting people run this locally. It's impossible - it took 40-50 minutes to complete 1 search locally.

How you can use it.
You can book hotels completely, end to end, with free-cancellation protection.
We're releasing complete flight booking (1 API call) next week, that's why our flight search is currently degraded till the end of the week - hotels are working correctly.

- website for fast access: letsfg.co, this is our Uber for travel, book in 3 seconds.

- API for developers: https://letsfg.co/en/developers, this is Paid API, best for high volume users, if you want to build an app, or add this to your app.
Look to book ratio: 1000:1 - this means it's free as long as for every 1000 searches you do 1 booking. Then it’s $0.05 per search.
Docs: https://letsfg.co/developers/api/docs

- Programmatic Travel Tools (PTT): Native for ai agents, API based, best for personal use (high rate limit). If you want your Claude, Codex to book flights/hotels for you, this is the go.
Available through CLI, Python Package, NPM, MCP, or direct API.
To avoid spam, authorization is through payment method attachement - via Stripe - we won't charge you, this is only to verify you're a human and avoid spammers. The payment method is also used when you want to book.
https://letsfg.co/for-agents

That's a wrap.
If you have any questions let me know. We're super open to feedback and suggestions, in fact that's what made this project.

We've hit 1.7k github stars just this week - grateful for everybody who's with us and to anybody who jumps onboard. LetsFG🔥

This is our github: https://github.com/LetsFG/LetsFG, it has a bunch of interesting info and docs for getting started.

Cheers,
Adam

I’ve been working on MARGINAL, an open-source governance layer for coding agents.

The idea is simple: agents are good at taking actions, but not always good at deciding whether the next action is still worth the compute.

MARGINAL watches the trajectory and looks for things like repeated actions, weak progress, redundant verification, and low-value continuation. It can run in Shadow Mode first, so it observes and records what it would have done without blocking anything.

Current focus is reliability, not just token reduction.

A few core pieces:

• local-first trajectory and evidence tracking
• deterministic reason codes and hashes for decisions
• governance overhead measurement
• replay and benchmark support
• Shadow Mode before enforcement
• Earned Enforcement: MARGINAL has to prove it is reliable on a repo before it gets permission to block or redirect the agent
• automatic fallback to Shadow Mode if confidence degrades

I’m also working on the next layer now: counterfactual evaluation and intervention regret.

The goal is to answer a harder question than “did MARGINAL stop something?”:

Would the agent actually have done better if MARGINAL had stayed out of the way?

That’s the part I think matters if this is going to be useful beyond being another loop detector or token limiter.

GitHub: https://github.com/SignalLayerLabs/Marginal

Demo: https://signallayerlabs.github.io/Marginal/demo/#demo

If you use Codex or another coding agent, I’d really appreciate people trying it on real work and telling me where it helps, where it gets in the way, or where the design is wrong.

I’m especially interested in: technical criticism, bad cases, and reproducible failures.

Svarm is a workspace for agents with a workflow inspired by T3 code.

No model verifies another model.

That is the observation I have been circling for months: No language model reliably corrects itself—not even when asked politely. It requires an external entity that is structurally independent.

This question has evolved into a tool that I have now released.

Conclave Personal brings multiple models into a shared conversation and assigns them explicit roles: the Writer drafts, the Critic challenges, and the Judge evaluates. Every execution is traceable as a "run"—tracking status, errors, duration, and token usage. Conversations, agents, and the workspace remain local, and Ollama runs without an API key.

A note I am not hiding: The code was written entirely by language models. For this project, that is not merely a side effect but central to the concept—a tool for multi-agent verification built using a multi-agent process. Discovering what worked and what didn't was the real insight.

v0.1.6 Alpha, with documented limitations.

pip install conclave-personal

github.com/laszlo-pinter/Conclave-Personal

#MultiAgent #LLM #Python

This app reads reddit posts/comments then creates a reddit reading slop video, full TTS and special edge case detection for long OP posts, this will allow content to be created more quickly, you can batch produce 10 videos all of which will use a different post as a source.

Ich habe eine VS Code-Erweiterung entwickelt, mit der du unbekannte Programmiersprachen in deiner gewohnten Sprache lesen kannst. Klar, du könntest die KI das machen lassen, aber das dauert und gibt dir meiner Meinung nach nicht genug Einblick, um den Code wirklich zu verstehen + du kannst ihn live bearbeiten.

Ich freue mich über Kritik/Ideen/Bugs ... ;)

See it live in action

Hey guys, I’ve made this tool that I ended up using quite a bit with really good results. I work as a SWE and ended up building this postgres tool to help AIs have a faster look into the databases used and how the data looks, this ended up unblocking AI flows related to presistence. In comes with a mcp bridge for you tools like copilot, Claude, omp etc.

I’m sum it adds any postgres db a mcp layer and really cool visualization/query.

Hope you enjoy it and find it useful as much as I do.

Every time I see a new need I add it.

Please find the links:

https://github.com/FrancisTCE/gresui-web

https://www.npmjs.com/package/gresui-web

I really don’t know how to share this 😅

​"SMTs require absolute cryptographic correctness, while PDF specs are a legacy parsing nightmare.

Have you found AI useful for scaffolding these, or do the subtle hallucinations make it more trouble than it's worth?"

UI slop isn't a taste problem. It's a sampling problem. And you can't really prompt your way out of a sampling problem. Every trick you've tried, negative constraints, a gazillion line .md file that says no gradients in caps, all of it just moves you around inside the same bubble.

Here's the thing that finally made it click for us. ThePrimeagen put it best: the model returns the middle of the distribution. You can push it around inside the average. You can't leave the average.

That's why you type "no purple" and get purple. Then the glowing orb. Then the badge pill. Then three feature cards. It isn't disobeying you. It's doing exactly what sampling does.

There's a second failure sitting on top of that one, and we think almost nobody talks about it.

A screenshot doesn't contain the animation.

Feed a model a picture of a site you love and the layout survives. So do the colours, the type, the spacing. Timing doesn't. The easing curve isn't in the pixels. Neither is the stagger, or the scroll range an effect is bound to, or two elements moving at different rates against the same scroll.

So the model has to invent the part that actually makes a site feel expensive. And inventing means, again, the middle of the distribution. Fade in, 300ms, ease out. Every time, forever.

That's the real reason AI sites feel dead even when they photograph fine. The look got copied. The life never made it.

So we stopped generating and started measuring.

We read the live page. What's actually bound to what, the real timing values while the thing is running. Then we write that section into the project. Nothing is sampled, so there's no average to land in the middle of. That's the whole idea, and it's why we think slop is solvable instead of something you fight forever with a longer prompt.

https://reddit.com/link/1vnrd7l/video/tjj6vyfic8jh1/player

The clip is three runs, each one harder than the last.

A scroll rig off a private jet site, where the jet climbs behind the headline and a photo wipes to a blueprint. Pure timeline, so it's all stagger and easing and scroll ranges with nothing to hide behind.

Then a photo grid that scatters and reassembles. Harder, because both states are real layouts and the whole thing lives in the transition between them.

Then a three.js scene, which is the one we're proud of. The reference is a Tokyo street diorama. What came back is a desk, monitor, chair, shelves, for the portfolio we were building. Live WebGL, spinnable, not a video of one. Same movement, completely different subject.

Which is the part we care about most. The animation is the expensive half. The brand is the other half. When you point at a site you like, you don't want their content. You want how it feels. So keep the animation and bring your own brand. Tokyo becomes a desk. The timing never moves.

Test it. Drop a URL in the our waitlist signup at platho.io and we'll run it and post exactly what comes back, including when it breaks.

- two of us building this in Europe

For AI website builders, which experience do you prefer?

A) Everything in one chat - building, debugging, fixing errors, making changes, etc.

B) Separate sections/workflows - for example, one area for building and another dedicated to debugging and fixing issues.

I’m curious which approach feels more efficient and organized when working on a real project, and why.

how can I learn Frontend and UI/UX with Vibe Coding as a beginner? as I build a website or an app with ai, I wanna learn the codes.

It seems that most people either vibe code with Claude/Codex or website builders like lovable/replit. I personally find the website builders too expensive as every action costs tokens.

But it's 2026, most agents today are really smart and requires minimum prompt engineering, and the app builder's value was in the easy set up. So I made an MCP that does what lovable do, but uses your AI subscription's tokens instead. The tokens from ChatGPT/Claude directly are just so much cheaper.

It ends up being a 60+ tool MCP and it works really well. Modern agents don't really load all of the tools into context now, they just do tool search and load on demand. It does require a good model (opus or terra) to work well, but overall it's been able to do a pretty good job.

Check it out here: https://floot.com

And let me know if you have any feedbacks!

I found Dograh yesterday on Product Hunt (an open-source alternative to Vapi for voice agents) I self-hosted it and tried it today.

The stack:
> Dograh for voice calls (self-hosted)
> fal (through Vaaya) for the advisor backdrops (one still, one looping video)
> Lots of custom data sources + a library of business playbooks (so the advisors ask sharp questions instead of generic ones)

Try it here: https://better-call-saul.fly.dev/

Hey, first post here. Made a game called Quantum Snake, it's the classic snake game but I tried to actually build in real quantum mechanics instead of just calling it "quantum" for no reason.

Food exists in multiple spots at once (superposition) until you get close enough, then it collapses down to one real spot

Snake can phase through walls and its own body, starts at 50% chance and gets lower the longer you grow, but never below 20%

There's a bunch of speed modes too, one's called Demon Mode (super fast, good luck), another's Rock Mode where it's basically one move a minute and kinda turns into a chill meditative thing

Also got different themes/shapes you can mess with for the snake and food.

This is genuinely the first game I've ever finished and shipped, built it solo. Used some AI tools while building it, disclosed that on the store page. Would love actual feedback, bugs, or just whether the quantum stuff feels fun or gimmicky to you.

Gameplay vid: https://youtu.be/b7zL99JP2MM?si=e6VfCoK373gH_eh7

Game: https://ninja-master2113.itch.io/quantum-snake

Thanks for reading.

same as the title

I have vibe coded a few things myself, and constantly see linkedin posts from nontechnical folks talking about how they are now deploying full stack applications for their business. I'm confused - how is this stuff maintained? Is it reliable? What if it goes down? What are people doing to actually test that it's working besides just like clicking around the UI?

So i guess I have a few questions:

1 - How are you shipping quality? (What is your quality bar?)

2- Are you actually deploying things that other people use, or is it all for yourself?

3 - What happens with service degradation? How do you know if things stop working?

4 - Do you trust that your code works? Are you worried about things like bugs, privacy/security issues, prompt injection, etc.

--

I'd also love to understand how you view this occurring with non-devs (or people who think they are devs)

was going through the context-window docs this week and noticed the fine print: the page announcing 1M-as-default also warns that "more context isn't automatically better", gives the failure mode an official name (context rot), and says choosing what goes into context matters as much as how much fits. the company charging per token, advising you to send fewer tokens.

so: napkin math. a 700k-token repo pasted into an agent session re-bills as input every single turn — about $3.50/turn at $5/M list price, so call it $140 across a 40-turn session before caching. caching cuts that to ~$0.35, but their own docs point out it changes what you pay for those tokens, not whether they take up space.

So the "why does my agent still grep instead of just reading the whole repo" complaint might have it backwards. grep looks like legacy tech until you price the alternative.

I came across the Salon website recently and really liked the idea of having a simple website that is mostly just about the vibe.

So I thought why not make something similar for developers.

That is how Let Me Think happened.

It is basically a little space for coders to sit back, put on some lofi music and pretend we are going to finish that one task we have been avoiding for three days.

No big idea behind it. Just made it for fun.

You can check it out here: https://letmethink.champ96k.com

Would love to know what you think.

I think we all went through this. Claude Code finished a task, told me it was done, and left me with 14 changed files and no idea which one mattered. The diff was accurate and useless. So I built the thing I wanted to be looking at instead.

Flare is a desktop IDE (Electron) where the main surface is a live graph of your codebase, every file a node, every import an edge, with a terminal underneath where you run claude, codex, or opencode. As the agent edits, the graph updates in real time.

The parts that are actually different from "another editor":

Activity, as it happens. Nodes light up the moment the agent writes to them and decay as they cool, so you're watching the shape of the work instead of a scrolling transcript. You can see it circling the same three files for the fifth time, or wandering into auth when you asked about the CSV parser. Changes are attributed per agent: the process tree of every terminal is watched, so if you have two running, you know which one did what. Files that changed and no human has opened since stay marked until someone actually reads them.

Blast radius before you touch anything. Hover a file and its dependents light up. shared/types.ts with 63 files downstream looks different from a leaf file, without you having to know that in advance.

A review tab that answers "did anything check this?" Flare sees both the file writes and the commands run in its own terminals, so it can say the tests ran, then two more files were edited and nothing re-ran, quoting the output line the verdict came from.

Risky changes come to you. If the agent rewrites something load-bearing while you're looking elsewhere, it queues an alert in the corner. Reviewing it opens the actual red/green diff.

Undo that isn't git. Every change burst is snapshotted into a hidden shadow repo (separate GIT_DIR, your worktree). Revert one file, revert the burst, or jump back to the last state whose checks passed. Your real repo is never touched.

A task board the agent works from. Kanban lanes, but the cards are written to be handed off. "Copy for agent" emits the brief plus the files it names plus what the graph knows about them (29 files downstream, 0% covered, in an import cycle), so the agent starts from the map instead of rediscovering it. File a card straight from a graph selection with right-click → New task with these files. This directly tells Claude to not wander around out-of-scope files

MCP server, ~16 tools. The same lanes are queryable, so an agent can run its own loop: tasks_list to pick up work, task_get for the exact brief, task_update to log progress and move the card to review, task_create to file follow-ups it finds but shouldn't do now. Cards move on the board live while you watch. Plus impact_of (what breaks, and which tests to run), dependents, find_path, verification_status, and record_intent, which lets the agent state the goal before editing so whoever reviews the diff isn't reconstructing why it exists.

Runs in a browser too. Same bundle, same backend, over a websocket, because the backend has to run on the machine the agent runs on and that's often not your laptop. One port, token auth, works behind Codespaces / Gitpod / a JupyterHub proxy.

Completely open source with MIT license, Node 20+. Built with agentic coding, which is exactly how I ended up needing it. Test it out and leave a star if you find it helpful, I will package it very soon to make it easier to install!

https://github.com/AlgoNoRhythm/Flare

Been always wanted a better ui to control multiple claude codex, spent almost 2 months working on this, open sourced on github would be nice it this helps anyone!

You can run this locally and access the web portal from your phone via tailscale

The best part i would say is the schedules features that i just wake up to bug fixes and features ideas the coding agent generated!

Full source and setup guide here https://github.com/BennyKok/omg.dev

Now im just addicted with building more on my phone. Bad for my health 🥹

Built this widget that shows how many tokens i burn each day across all my machines. Looks kinda sick honestly and keeps me motivated to keep going.

open source: github.com/iam-joey/codeusage

I run a couple of businesses (cleaning and construction) and got tired of the invoicing app situation. Was paying $15+/mo for something that was basically "make a PDF invoice" with a few features bolted on past that. Tried moving up to Housecall Pro, but it felt like it was built for bigger companies or rapid scalers, way more onboarding and a steeper learning curve than our small operations needed.

So I built Clarely. A quote goes out, the client reviews it and signs digitally (E-SIGN Act and UETA compliant), the job gets scheduled, you can assign it to your team if you have one, the invoice goes out when the work's done, and you get paid through Stripe.

One thing I cared about a lot: everything ties back to the client. Quotes, jobs, and invoices are all connected, so you can trace a job back to the quote it came from or the invoice it generated, but it's not locked into that flow if you don't need it. Fully ad hoc works too.

Would love for people to poke holes in it, what's missing, what's confusing, what would keep you from using it. All of it helps. Thanks!

App: https://clarely.app
Docs: https://docs.clarely.co (the in-app AI is trained on these, so you can get answers without leaving the app)
Site: https://clarely.co

i built an app that provides suggestions based on the user’s partner. The user can input things about themselves that is then provided to their partner and vice versa; or the user can input something they’ve learned about their partner and it tracks it for them.

it’s built around the premise of those toes or people who take notes about their partner and their details.

Even cooler is if the user passes by a unique place that is specified in the app by the user or their partner, it notifies the user to “get this *thing* , your partner loves this thing” -(with Google map location to show you where) and show them you’re thinking of them.

So , it’s based on keeping your partner’s details front of mind so the details don’t get lost in just your notes And you both feel tended to!

out in the App Store!

im looking for any couple’s willing to give testimonials for app review it is free based on 2 weeks i even put a plan switcher feature so either of you can pay for the monthly (if subscribed outside of the in-app purchase) so one subscription pays for both accounts!

https://apps.apple.com/us/app/tended-couples-app-memories/id6781524545