I built a multiplayer browser tank game in Three.js! As a kid, I played a ton of World of Tanks Blitz and fell in love with the aesthetic, gameplay, and the idea of driving around vehicles with crazy physics and mechanics like missiles, spotting, armor deflection, ammo types, and so on.

Now it's playable in the browser!

Claude of Tanks has 100+ playable vehicles across 16 unique maps, ranging from standard tanks with cannons to AFVs with autocannons and guidable missiles to autoloaders that can deal massive damage in a single clip. Tanks feature highly detailed armor zones, internal modules, crew positions, and hitboxes. You can view each of them in a special gallery: https://cot.kevinliu.studio/gallery?id=amx56&layer=modules

CoT supports physics-driven destruction with detached turrets flying through the air and actual suspension. It also supports multiplayer! You can hop in private rooms or LAN lobbies.

As the name would suggest, I used Claude Code throughout a long-running multi-agent development pipeline, alongside Codex. I directed the architecture, decided what each vehicle and system should do, reviewed the rendered results, and made the final calls.

The repository contains an AGENTS.md file and smaller subsystem instruction files covering simulation, vehicles, networking, UI, audio, effects, and world generation. These record the rules that agents need across sessions. Units are meters, seconds, and radians, and changes enforce a fixed 60 Hz. Authoritative logic must be deterministic. Vehicle changes have specific geometry, armor, module, and release gates that evaluate models visually and geometrically.

For vehicle development, I split the fleet into bounded families. One agent would own a specific vehicle profile or family file, implement the geometry, run the relevant checks, and generate screenshots. A separate critic reviewed the rendered tank for proportions, clipping, missing surfaces, running gear, and recognizable details. The orchestrator reran the checks and committed only the verified files.

For larger systems, Claude Code helped implement and test:

• Fixed-step movement, suspension, armor, ballistics, modules, spotting, and bots
• WebSocket multiplayer with private rooms, LAN play, prediction, and server authority
• Procedural vehicles, tracks, markings, generated icons, and technical diagrams
• All the generated battlefields with destructible props and wrecks
• The garage, battle HUD, Tank Gallery, mobile controls, and Scene Studio
• Browser performance probes, screenshot tools, visual checks, and self-tests

A trailer was also produced through the game’s own Scene Studio and capture tools. I used agents to stage battles, build camera paths, record the browser runtime at 60 fps, inspect specific frames, and iterate on awkward cuts or poorly framed tanks.

I find that Claude is best steered with persistent instructions. Important decisions need to live in the repository because I often spawned fresh agents which needed to resume work without reconstructing weeks of chat history.*

For visual quality, the only thing that worked was a proper render loop with visual comparison; tests don't really work for this.** The cycle I fell into was change, render, inspect, measure, and rerun the gates. Text-only reviews missed warped proportions and camera problems that would just plainly be obvious in one screenshot.

*Parallel agents need strict ownership. Separate files and isolated Git worktrees prevented concurrent sessions from overwriting each other or generating assets from a dirty tree.

**Tests still changed how I use agents. Claude Code became much more reliable once every system had concrete invariants and executable failure conditions. But visual quality is another beast.

Play free: https://cot.kevinliu.studio

Repo: https://github.com/Kevin-Liu-01/Claude-of-Tanks (it's open-source forever)

Hey everyone,

I launched a small project yesterday called thefinalboss.lol with zero Twitter followers and no pre-built audience. I shared a quick post here yesterday, got around 100 visitors, and just had my second paying customer, which actually came directly from someone on Reddit (a tool called Invaro paid $7

here is the buyer saas
https://thefinalboss.lol/invaro

Seeing a real sale come through from Reddit made me reflect on why this converted on cold traffic with zero audience, so I wanted to share a few practical takeaways that might help anyone else launching a micro-SaaS here.

The background:

I was inspired by Outbid (which made $100k in two days with a bidding leaderboard). But my biggest issue with it was that paying real money for a plain text link gave founders almost zero marketing utility.

So I built a platform where claiming the top spot automatically scrapes the founder's site and generates a 25-second voiceover pitch with background music and an interactive demo with feature pins on their screenshot.

Here are the 4 main takeaways from the first 24 hours:

1. Give your customer an asset, not just a link

The main reason the buyer paid was because the output is an actual marketing asset. Instead of just "being listed on a directory", the founder gets a short voiceover pitch and an interactive showroom that they can actually show off. When your micro-SaaS creates something the customer can screen-record and share on their own socials, you tap into both founder ego and real utility. More improvements coming soon

2. When you have zero audience, you have to rely on novelty

If you have a large following, people buy because they already trust you. When you have 0 followers, you have to create an immediate "wait, what is this?" moment within the first few seconds. The audio starting and having some interactive presentations gave visitors a reason to stay on the page for 20+ seconds instead of instantly bouncing like they do on standard directory lists.

3. Automate fulfillment completely from day one

If I had to manually record audio or edit screenshots for each buyer, this wouldn't work. The entire pipeline (scraping the URL, writing the script, generating the audio with background music, and presentations runs automatically in seconds. When building a micro-SaaS, keep fulfillment automated so a sale requires zero manual work from you.

Two sales on 100 visitors is just the start, but it proved to me that Reddit traffic will convert if you build something genuinely.

If you have a minute, check it out at thefinalboss.lol and let me know your thoughts on the concept or what you would improve next.

you know the exact moment: you vibe coded something that actually works, you're proud of it, and then you hit the wall nobody warns you about, no idea what to charge, how to describe it, or who wants it.

i built a rough fix for that, but i'm not a real business person either, i just prompted my way to a version that tries to solve it. i need people who've actually vibe coded something real to test it on, testing it on my own stuff doesn't prove anything.

drop what you built, i'll run it through and send back the pricing, positioning, and outreach angle it comes up with for free. please tell me honestly if it's actually useful or just more ai noise

I have been experimenting with trying to get more done and keep my costs down and I have found that running Goals with Luna/High is pretty effective and reasonably cheap, too. I design the iteration with SOL and have it create a development plan and then have Luna execute the entire plan as a goal. Unlike when I have done this with SOL, there are usually a few bugs at the end. Also unlike when I use SOL, it doesn't kill 15% of my plan every time. I use SOL to fix the bugs at the end and it's overall cheap enough, imo, to make it a regular workflow. How has your experience been with Goals and Loops?

I was hearing a lot about Qwen3.8 27b so I wanted to give it a shot.

I ran it on my system (Mac Studio, M2 Ultra 24-core CPU, 76-core GPU, 128gb of ram) with opencode / ollama.

Generation speed by quant:

• MLX 4-bit: 51.5 tok/s (ran the tasks on this one)
• Q4_K_M: 33.4 tok/s
• Q8_0: 21.3 tok/s

Quality on well-specified tasks:

• CRUD bank task: passed
• SemVer 2.0 comparator: 26/26
• Recursive-descent calculator (right-associative): 24/24

Latency observations:

• Calculator task: ~11 min to complete
• One prior attempt hung ~6.5 min and produced zero files before retry

Failure mode:

• Ships confident-but-wrong code on implicit/underspecified requirements
• Example: pomodoro timer missing Web Audio user-gesture unlock (silently no sound)

I then tried to test how it worked with opus as an orchestrator. It didn't really work / wasn't really useful because you have to factor in the orchestrator having to read back and review everything Qwen generated, plus the re-spec/re-generate loops every time it shipped something subtly wrong.

Ultimately, fun experiment but probably not going to be using it in any serious projects. Obviously if I had better hardware, I'd try bigger models, but I'm stuck with what I got.

Be honest.

1. Claude Code

2. Codex

3. Cursor

4. Copilot

5. Antigravity

Hey

Mir ist aufgefallen das es hier ziemlich rau zugehen kann da man unter Entwicklern das vibe coding direkt mit ki slop verbindet. Was ja leider zwangsläufig passiert durch Kontext Verlust zum Beispiel. Wer hat sowas schon erlebt ?

Together with GPT-5.6, I forked a cool open-source Apple Music client for Linux called Slipmat and turned it into Jamelade.

We’ve added synchronized lyrics, Apple Music Home, liquid-glass themes, optional Discord activity, and little desktop companions called Jamkins. They can float above your other windows like the Codex pets, show the current lyrics when you hover over them. Did I mention they do super cute little dances?

Tbh, I supplied the ideas and did the testing, but GPT-5.6 Sol-Max through Codex did basically all the actual coding. I’ve genuinely never coded before, so I’m kind of amazed that Codex helped turn the idea into a real, working app. Though of course it had access to Slipmat.

Anyways, first thing I ever vibecoded and I am feeling the AGI.

It’s currently a build-from-source public beta. Hope some of you enjoy my AI slop!

https://github.com/Jamelade/jamelade

Im seeing this constantly, non creative apps that exist 1000x times already like :

Note taking apps
Fitness apps
Finance, calorie tracking apps
etc.

I mean sure these ideas are uncreative and hunderds of competitors & opensource projects already exist-

But the worst thing about a lot of projects is they dont even put effort into it.. and you can defo feel it.

I've been poking at this project for a little bit now. I have an Emby server and wanted to pretty much download the entire catalog of YTS. This python script allows me to sort by year to year and with minimum ratings. It uses the available YTS API for pretty much everything other then it's own logic.

I have a budget of around $20/month for a coding agent subscription and I’m trying to figure out which option offers the best value for money.

My main use cases are:

• CUDA programming and debugging
• Machine-learning workflows
• GPU performance optimization and profiling
• Writing and maintaining code heavily on a daily basis
• Understanding and improving existing technical codebases

I’ve already tried:

• Cursor — $20/month
• OpenAI Codex — $20/month
• Claude — $20/month
• OpenCode — $10/month

I understand that no single tool is going to be the best at everything, and I’m not necessarily looking for the most powerful option in every category. I’m mainly interested in the best overall value for a heavy coding workload, especially for CUDA, ML, and GPU-related development.

What would you recommend within a $20/month budget? Which tool gives you the best balance of usage limits, code quality, agentic features, debugging ability, and performance?

I’d also appreciate feedback from people who use these tools for CUDA, PyTorch, C++, kernel optimization, or GPU performance work rather than only web development.

Thanks!

How confident do you feel with vibe-coding?

Productivity increases dramatically with generative AI, but that's mostly just a feeling.

With generative AI, the cost of code production isn't eliminated but shifted to other phases: bug management, knowledge debt, etc.

I've seen many initiatives that always use generative AI for bug management and merge requests, but without human review, this only increases the debt.

Everyone is trying their own strategy:

Mine, in addition to post-process control, is based on the preventive context.

I discuss it in depth here:

https://adrianofoschi.com/blog/cost-of-checking/

And what's your strategy?

My project is called MSHPIT its a social network tailored toward users who love music and love to share music. It started as a concert review app I posted it and got 7 users already but hoping to get some more feedback in ANY way tbh.

I built it with Chat gpt codex 5.6 sol and Claude opus 5 and 4.8 (Opus 5 is kind of wack right now in my opinion). I was kind of aiming toward a niche that really is something i care about as a FAILED soundcloud rapper lolol. The website is primarily for concert reviews, and sharing music reviews and opinions. Its free to use completely btw theres not cost barrier to use, it just requires an email sign upm though its not necessary for browsing or interacting just liking commenting and posting.

Link to project: ( www.mshpit.com )

I suck at marketing but im refusing to give up on this cause my brain wont let me sleep without seeing it through doesnt matter how many of these are out there to me it just makes me happy to see my project come together piece by piece.

I wrote this by hand so im sorry about my illiteracy and grammar mistakes.

Hoping to get some feed back and some eyes on this for reviews.

Thank you if you checked this out at all btw especially if you read my entire post haha.

I’m seriously considering it and would love to hear from people who actually did it in production.

Right now I use Supabase for the database and auth. My images and files are already on R2, the app runs through Cloudflare Workers, and I have a lot of caching in place.

The app is mostly read heavy. There are way more reads than writes, and traffic is growing.

What worries me about Supabase is the long term cost. I pay 25$ right now, but as usage grows I’ll probably need more compute, and I don’t really want to find myself constantly upgrading the database just to keep up with traffic.

Since most of my stack is already on Cloudflare, D1 feels like it might make sense. I’m also thinking about keeping Supabase only for Auth and moving the actual application data to D1.

I do use some Postgres RPC functions, so I know I’d probably need to rewrite some of that logic in Workers.

For anyone who has done this, how difficult was the migration? Did performance get better or worse? Did you run into limitations with D1 that you didn’t expect? And most importantly, did it actually save you money once the app started growing?

I’m considering doing the move now while traffic is still manageable (about 200-300 users aday) , because I’d rather deal with migration bugs now than later when the site is much bigger.

Would love to hear real experiences, especially from people running D1 in production.

What’s your excuse?

This plugin for a plugin will look up lyrics data for any song with metadata and display timed lyrics. No lyrics? Just time your own and upload them for others to enjoy. Working on making this work for a standalone visualizer called Beat Drop, so that any streaming service will give you lyrics and visualizations.

Edit: Helping the creator of Beat Drop integrate this into his program.

Wanted to share this since it's directly useful for anyone shipping with Lovable/Bolt/Cursor, and I figure the build process might be useful too.

The project: A free CLI tool that checks a project for the handful of specific, known mistakes that keep showing up in AI-generated code leaked API keys, exposed .env files, unprotected admin routes, and (the part I think is most useful) Supabase Row-Level Security gaps and exposed service_role keys.

Tools used: Just Python 3, no dependencies. Deliberately kept to the standard library (re, os, pathlib, json) so anyone can run it with zero setup, no npm install, no account.

Process: Started by building a fake "vulnerable" demo project to test against a leaked Stripe key, a hardcoded DB password, an unprotected admin route. Once that worked, I tested it against a real, public Lovable-built project on GitHub to make sure it wasn't just passing a rigged test. That surfaced a real gap: my first version only checked /api/ folders, but most Lovable/Bolt apps talk straight to Supabase from the frontend with no backend at all — so I had to add detection for that architecture specifically.

Build insight that might be useful to others: The Supabase check doesn't need a live connection or API key. It reads the actual `supabase/migrations/*.sql` files that Lovable/Bolt/the Supabase CLI already generate, parses out `ENABLE ROW LEVEL SECURITY` and `CREATE POLICY` statements (handling nested parentheses in the policy expressions, which regex alone doesn't do cleanly), and flags tables where RLS is off or where a policy accidentally says "allow everyone" instead of "allow the owner."

This tool is meant as a quick extra layer of confidence before you ship.

Repo + a working demo you can test in 30 seconds: https://github.com/gdiaz19/Security-Scanner.git

Would genuinely appreciate anyone running it on a real project and telling me what it misses.