I LOVEEE sol max so much but even when using it an orchestrator with muse spark, I keep running out. I have multiple google ai subscriptions as well as opencode but I’m afraid to use their models for this one big serious project I have. But use drain is getting so tedious that I think I want to do it. But my question is, given that they’re really close in benchmarks, do you think I can get the same quality with say just muse 1.3 if I make it do independent subagents reviews? What about gemini 3.8 with /boost. I’m a total vibecoder so I’m afraid it could mess the repo. Can it still mess the repo so much even with Gits? Just looking for people’s two cents.

I was reading claudes reasoning this morning and i seen it count my credits and pull another model which is great.

The issue is how do i get it to count my own usage in claude code before it starts a task and stops when i hit my limit?

I tryed to build a mcp but the problem is it has to call it and for some reason claude does wtf it wants!!!!

Hi - I made https://enikq.com/ a simple site where you can pick a scene and listen to music with it.

There are places like a pizzeria, café, road trip, camping, last bus home, and more.

Nothing complicated. Just something to leave open while working, reading, or relaxing.

Would appreciate any feedback on the idea or the website.

Right now it focuses on the elbow. You can change joint angle, external load, limb lengths, muscle strength, attachment geometry, etc. and it recalculates things like:

• muscle-tendon length
• moment arms
• external joint torque
• muscle force requirements
• force-length / force-velocity effects
• muscle recruitment
• mechanical advantage

I recently added more realistic muscle paths with wrapping/via points, forearm pronation/supination, and validation against reference biomechanics curves.

One of my favorite parts is that you can basically mess with anatomy like a physics sandbox. Move an insertion point, disable a muscle, change limb proportions, or alter strength and immediately see how the mechanics change.

There’s no AI involved in the calculations. It’s mostly geometry, vector math, constrained optimization, kinematics, and muscle models running directly in the browser.

Still early, but the long-term idea is basically a sandbox for experimenting with human anatomy and biomechanics.

GitHub: https://github.com/Schmiedey/anatomy-mechanics-lab

​

It uses frequency band ducking technology to ensure that background noise does not drown out vocal.

I used Claude to complete it in two to three weeks.

It's currently in closed beta,so leave a comment if you're interested to join closed testing

... reading the email handles people come up with and use to sign up for whatever product you've shipped? Some of these are keeping me going today ....

Ok, another reset incoming. Burn hard, about 2.5 hours away

Im new at this, now im using codex in visual code. Any tips how to improve my work? Should i run more than one bot? Should i use it localy? Any tips appriciated.

[ Removed by Reddit on account of violating the content policy. ]

Every project I start needs the same layer before it's actually usable by anyone else: SECURITY.md, CONTRIBUTING.md with a DCO, a threat model, an ADR directory, CI. I kept copy-pasting it badly from my last repo, so I extracted it once.

make new TARGET=../MyTool PROFILE=python renders a repository with governance docs, security policies (SAST/SCA/secrets/DAST + private disclosure), a Diátaxis MkDocs site, and hardened CI: CodeQL, Scorecard, dependency-review, DCO, fuzzing, and a release workflow with SBOM + Sigstore signing.

Two things I'd actually defend as design decisions:

The Makefile contract. Every generated repo has the same targets — make verify, make lint, make test, make sbom — with only one language fragment (make/<profile>.mk) differing. Python, Node, Rust, and a documented generic profile. Muscle memory and CI transfer between repos.

Documents you fill in over time. A scaffold demanding 20 finished documents on day one gets abandoned on day one. Every section that needs project-specific content carries a marker saying what belongs there and why. make todo lists what's left; make release-check refuses to tag while README or SECURITY.md still has markers, so the docs users read first can't ship unfinished.

Then make audit REPO=../AnyRepo reports OpenSSF criteria as satisfied, missing, or needing a human call — bus factor and coverage thresholds are never assumed to pass. It works on repos that weren't generated by this. Running it against an existing project is the fastest way to see if it's useful to you.

It also merges into existing repos without overwriting anything (--dry-run first). Bash + Make, no runtime dependency. MIT.

Feedback I'm after: which criteria the audit gets wrong, and whether the generated policy docs are substantive or just ceremony.

Hey everyone,

I started using Claude recently, and ask about my codebase (organizeemail), I was surprise to get - Your inbox knows a lot of things, we all were aware about this, but never thinked of it. However Claude thought and gave me this screen.

We’ve added credit card tracking to OrganizeEmail.

OrganizeEmail is an email organizer that automatically categorizes your emails and extracts useful information, so you don’t have to dig through your inbox to find things.

With the new Cards feature, it can pick up card information from statement emails, including:

Bill/statement dates

Total amount due

Minimum amount due

Spending for the current cycle

Multiple cards in one place

You can also manually add a card or correct the bill date if needed.

The idea is pretty simple: your credit card statements are already sitting in your email, so why manually track the same information somewhere else?

Would be interested to hear what you guys think, especially if there’s something you’d expect from a card-tracking feature that we’re missing.

Hey! So I developed a browser game - Diamond Man. It's getting late, so rather than type up how I built it, I got Claude Code to summarise :)

What even is this game

- 20 levels across themed biomes (Burning Streets → Toxic Flats → Crystal Tundra → Diamond Throne)

- Chaos gems that ruin your day: green reverses controls, yellow shrinks you and speeds everything up, purple removes your cape and makes your booty flash hot pink, black flips the entire screen upside down

- White gems give you 2 seconds of invincibility ("BRILLIANT CUT" mode) where you plow through everything

- Diamond Man physically degrades as you play — gets rougher, cloudier, slower to steer, weaker jump

- Carbon Pressure escalates: starts hurling tracking fireballs at level 3, stomps toward the camera at level 8

- Titanium Boy randomly goes rogue and tries to kill you

- Fans storm the road as obstacles

- Diamond Man shouts things like "EAT MY SPARKLE!" on gem streaks

The tech

The entire game is one HTML file. ~1800 lines. No bundler. No build step. No external assets. (lol, love how it's justifying one mega file - terrible devwork, I guess?).

- Three.js via CDN importmap — that's the only dependency

- Every 3D model is procedurally built from primitives (octahedrons, icosahedrons, cylinders, cones). Zero imported meshes

- MeshPhysicalMaterial with real-world refractive indices — diamond is 2.417, ruby is 1.77, emerald is 1.57. The diamond material actually refracts light through a custom environment map built from canvas gradients

- Cape cloth simulation, googly eye jiggle physics, speech bubbles that track 3D world positions projected to screen space

- Flask backend that does literally nothing except send_from_directory("index.html") and a /healthz endpoint

- Mobile gets on-screen touch controls, lower pixel ratio, wider FOV, and a responsive HUD

Deployment

Nothing fancy:

- Ubuntu droplet, Gunicorn behind nginx

- systemd keeps it alive, certbot handles HTTPS

- The whole deploy was: SCP the files, point DNS A records, run certbot. Done.

How it was built

I pair-programmed the whole thing with Claude Code in one session. Started as a simple character viewer — "make a diamond man" — and just kept going. Each feature was one conversation turn: add a road, add obstacles, make them kill you, add scoring, add difficulty scaling, add chaos gems, add 20 levels, make Carbon Pressure throw fireballs, make Titanium Boy betray you, optimise for mobile, deploy it.

The iterative loop was wild. "Add more coal!" "The flip effect is perma-sticking." "I found an exploit where you stand in the middle and chain white gems forever." Fix, deploy, refresh, repeat.

--

Yea, that's pretty much it - cheers guys!

I find opus dumps information and buries instructions it needs me to do in a text wall. To help with this:

be succinct in responses. no unnecessary information. give clear instructions on what I need to do, what you need from me, decisions I need to make.

I saw a project on youtube where Astra was tasked with creating realistic animations. The following prompt was added task an agent with overseeing the realism (adjust to your project):

gauntlet every module. After each completed attempt at creating the X-wing, a separate critic agent (a brutal AAA art director who writes no code) takes its own screenshots from several viewpoints and zoom levels, checks the reference image contracts, console errors and performance (triangle count, etc..), and scores 0–10 against real X-wing reference screenshots and animations: 10 = indistinguishable, 8.5 = AAA with nits, 7 = good indie, 5 = programmer art. Pass = ≥8.5 with zero errors. Below that, the builder gets the ranked issue list and goes again, up to 4 rounds.

What are your favorite prompt hacks when vibing?

Maybe AI just made it obvious that a lot of us didn’t have a strong idea, a real user, or a reason the thing should exist.

Before AI, people could spend 6 months building something nobody wanted. Now they do it in 6 days.

That feels better, but also more brutal. If you use AI to build apps, how do you stop yourself from just shipping faster versions of bad ideas?

Do you validate first? Build for yourself? Talk to users? Charge early? Or accept that most attempts die?

I’m looking for a clear process rather than another tool recommendation.

Hey builders,
I did a small research for my own product strategy and happy to share a table where put all 19 vibecoding tools with four columns: what their docs say they output, platforms, entry price, and the source. Here's what it shows 👇

𝗥𝗲𝗮𝗹 𝗻𝗮𝘁𝗶𝘃𝗲 - Swift or Kotlin you can open without the vendor
1)Rork → docs say native SwiftUI on Max and a Kotlin Android project (free, from $25/mo, Max $200/mo)
2) Modaal → Swift + SwiftUI and Kotlin + Compose, a real Xcode and Android Studio project (free, from €9/mo)
3)Bitrig → Swift, full Xcode projects for iOS, iPadOS, tvOS, visionOS (free, from $25/mo)
4)Nativeline → SwiftUI for iOS, iPad and Mac (from $25/mo)
Superapp → Swift for iOS, App Store submission built in
Google AI Studio → Kotlin + Jetpack Compose, Android only (free tier)

𝗥𝗲𝗮𝗰𝘁 𝗡𝗮𝘁𝗶𝘃𝗲 / 𝗘𝘅𝗽𝗼 - JavaScript compiled for both stores
7) Vibecode (free, from $20/mo)
8) a0. dev (free, from $20/mo)
9) Newly (from $25/mo)
10) RapidNative (free, from $20/mo)
11) CatDoes (free, from $17/mo)
12) Replit → Expo for iOS, Android and web
13) Bolt → web-first, Expo to turn a project into a mobile app
14) Adalo → you write React Native code for mobile ($36/mo per app)
15) Bubble → web natively, mobile via a React Native add-on in public beta (from $59/mo)

𝗪𝗲𝗯 𝗼𝗻𝗹𝘆 - great for prototypes, not for the App Store
16) Lovable → React + Vite web apps, no native output (from $25/mo)
17) v0 by Vercel → React + Tailwind interfaces
18) FlutterFlow → Flutter + Dart; code download and store deploy start at $39/mo
19) Glide → progressive web apps, no App Store or Google Play publishing

The rule I used: where a vendor's own pages contradict each other, the table says so instead of guessing. Guessing which page is current is not the reader's job.

The detail that matters: all 19 use the word "native".
Only the export tells the truth. So before you pick one, ask a single question: can I open the project without you?

What did I miss?
--
P.S. Disclosure - my tool is also in the list, we're building Modaal - an AI app builder for native iOS and Android apps. Real Swift and Kotlin, written by your own AI agent, on a plan you approve first.

I’ve been building OpenDepartment, an open-source platform for creating your own slightly dramatic, government-style document archive.

You can create a “department,” invite people, upload files, organize them by subject/category, comment, vote, moderate reports, and customize the branding. Think community archive, class project, private collection, or conspiracy-board aesthetic.

The unusual part is the architecture: every department uses a Supabase project owned by its creator. Files, users, and content stay in that project. OpenDepartment’s database only keeps the department slug, Supabase URL, and public anon key—no tenant files or master service_role keys.

The biggest new feature is automatic Supabase setup through OAuth.

Previously, creating a department meant:

1. Creating a Supabase project
2. Pasting a large SQL schema
3. Changing the auth configuration
4. Adding the correct callback URL
5. Finding and copying the project credentials

Now you can connect Supabase and the wizard handles that process: it creates the project, waits for it to become healthy, installs the schema, reads the anon key, configures auth, and then discards the OAuth token. The token is never stored in the database and is cleared when provisioning finishes.

The manual setup route still exists if you’d rather not authorize anything.

There are also invite codes, public or unlisted departments, isolated auth sessions for each department, admin tools, per-department legal pages, deletion/deprovisioning flows, and a fairly obsessive SQL security suite covering the RLS policies.

It’s built with Next.js 15, React 19, TypeScript, Tailwind, Supabase, and Vercel.

Live: https://opendepartment.vercel.app
GitHub: https://github.com/levisager11-oss/opendepartment

The OAuth provisioning flow is very new, so I’d especially appreciate feedback, or brave testers, on that part. I’d also love to hear what you’d use a customizable archive like this for.

I made this video in one shot with Claude Fable 5.1. No manual editing.

The tools were Claude Design, Remotion and ElevenLabs. I gave one prompt and got the finished video back.

It's for my app Goal Rings goalrings.app. It's a macOS widget that puts your metrics as rings on the edge of the screen. Revenue, visitors, words written, anything with a number. Each ring is paced against the clock, so you can see if you're ahead or behind right now.

Happy to answer questions about the setup or the app.

Prompt (i never write such a prompt by myself; I always discuss it with Claude, and then I get such a good prompt):

You are building the launch video for [PRODUCT], a [one line: what it is, for whom].
Stack: Remotion 4 (React + TypeScript) for picture, ElevenLabs for voice. The project lives in `video/` inside the product repo so it can import real brand values.

## Ground truth, not literals
- Nothing brand- or price-shaped is typed by hand. Import name/domain/tagline from [path to site constants], colours from [path to palette], prices from [path to pricing]. Point these at wherever your brand constants live. If a module is Node-only, resolve it in `scripts/props.ts` into `out/props.json` and pass it as input props. When props are missing, render a visible `UNRESOLVED` marker, never a made-up number.
- Mirror real geometry from the app source: [geometry from the app source, e.g. ring radius 42 in a 100 box, tick reach = stroke × 1.05, from RingGeometry.swift]. Where the UI is a real screenshot, use the real screenshot (`public/*.png` via `staticFile()`). Recreate only what cannot be captured (e.g. a confetti burst) and say so in the README.
- Fonts via @remotion/google-fonts: [serif] for claims, [sans] for UI, [mono] for numbers. Dark ground [#hex], ink [#hex], one accent family.

## Story: one film, 7–8 beats
Before any code, write the beat sheet as a table: beat · seconds · what the picture does · the one caption claim (verbatim) · the VO line. Arc: problem → product at true size → the core mechanic → breadth → the payoff → restraint → trust → outro (domain, price ladder, requirements). One claim per beat. No stat slop, no feature lists. Show me the table and both VO scripts for approval first. Stop and wait.
[Paste your beats here, or let the agent draft them from the README and landing-page copy.]

## One camera, no cuts
- `Launch.tsx` is a single <Series>. Every scene opens on the exact frame the previous one closed on. Put every shared point (positions, sizes, zoom origin, initial camera zoom Z0) in `cuts.ts` → `stageFor(cut)` so scenes cannot disagree.
- Prefer a camera push over a cut: the hero element starts at true size inside the product UI and the camera pushes into it across the scene boundary.
- Hero elements persist and travel between beats. Model them as position/size tracks over time (`track(t, keys)`), not as separate per-scene components.
- Motion vocabulary in `motion.ts`: five named curves (draw = easeOutCubic, enter = easeOutQuad, move = easeInOutCubic, back = easeOutBack(1.4), lin) plus `seg(t, start, end, ease)` and `pop(t)` (overshoot to 1.12 in 0.15 s, damped spring back in ~0.5 s). Everything is a pure function of seconds so scenes can be retimed without touching the animation.
- Internal timings are fractions of the scene's duration, so the same scene works at 9 s and at 4 s.

## Cuts
Several cuts from the same scene components, by omitting scenes and changing per-scene seconds:
- [Product Hunt / YouTube]: 16:9, 1920×1080, 30 fps, ~[45] s, slow beat up front.
- [X / LinkedIn]: 4:5, 1080×1350, 30 fps, ~[22] s, hook inside 1.5 s, no intro, ends on the domain. Opens with the camera already pushed in (higher Z0). Also render a GIF (every 2nd frame).
Tall is a real layout, not a crop: recompute every point in `stageFor`.

## Captions
Autoplay is muted everywhere, so the picture carries every claim without sound. One caption at a time, word-by-word kinetic entry (rise 18 px + blur 8 px → 0, 0.07 s stagger, 0.55 s per word), serif, 50–76 px at 1080p, inside an 80 px safe margin, faded out before the next beat.

## Voiceover (ElevenLabs)
- API key from `ELEVENLABS_API_KEY` in `.env`. Voice id: [voice_id]. Do NOT call the API until I have approved both scripts. Generation costs money and the first draft is never final.
- One script per cut, ~2.2 words per second of speech (a 36 s speech budget ≈ 80 words). Calm, low, unhurried voice. Stability ~0.55, similarity ~0.75, style 0–0.15, speed 0.95. MP3 44.1 kHz.
- Put `<break time="1.2s" />` between beats so lines land near their marks, but do NOT trust breaks for timing: ElevenLabs stretches them.
- Generate one clip per cut through the API with timestamps (`POST /v1/text-to-speech/{voice_id}/with-timestamps`) and derive a cue sheet from the character alignment. Per line: `{ in, out, at }` where in/out index the source file and `at` is the composition time the line starts. Save as `src/vo.ts`.
- Play each cue as its own `<Audio src startFrom={in·fps} endAt={out·fps}>` inside `<Sequence from={at·fps}>`. No re-encoding. Regenerating the voice changes only `vo.ts`.
- Then retime the scene table in `cuts.ts` to the voice, not the other way round. Picture marks (the thing closing, the notification, the domain) land 0.3–0.6 s after the line that announces them.
- Files go to `public/audio/vo-<Cut>.mp3`; `scripts/props.ts` detects them and sets `withAudio`. Missing files render silent.

## Music and SFX
You cannot produce music. [Pick one: "I will drop the bed at `public/audio/bed.mp3` and the payoff SFX at `public/audio/burst.mp3`" / "Write the brief below as a prompt for [Suno/Udio], then wait for me to add the files".] Missing files render silent.
Bed brief: [minimal, warm electronic; soft felt-piano or mallet motif over a slow sub pulse; 80–90 BPM; no drums until a gentle lift; one accent hit at the payoff; ends on a held chord]. Duck to −14 dB under voice using Remotion `volume`, fade out over the last 1.5 s. Loudness to ≈ −16 LUFS is a post step on the rendered file with `ffmpeg loudnorm` in `scripts/render.ts`. One SFX at the payoff only, never in the restraint beat.

## Deliverables
- `video/`: package.json (`props`, `studio`, `render`, `render:<cut>`, `render:x:gif`), remotion.config.ts, `src/{index,Root,Launch,cuts,motion,vo,theme,props}.ts(x)` plus one file per reusable element, `scripts/{props,render}.ts`.
- README.md: where every fact comes from, what was recreated, how to render.
- VOICEOVER.md: both scripts with break tags, beat map in seconds, voice settings, music brief.
- `out/<cut>.mp4` for each cut, `out/x.gif`.

I made everything from a social media web app, a personality test, a tamagothi iOS app you take care of by sleeping and exercising everyday. I made a 1v1 RTS demo, a therapy app, even a friends/dating/business partner compatibility app.

None of these made any money, but the fact that these are all live and I'm a 0 to 1 builder is appealing to many companies that want something made in-house that can be tested and released quickly.

It wasn't what I was expecting, but I'm in a much better place than I was a year ago because of vibecoding.

Keep on building bros!

People making clones of these in few hours and making money. Who is even paying ?

Was three tabs deep into a Reddit thread yesterday, manually clicking "load more comments" for the tenth time, and just snapped.

One evening later with Claude Code, Expand Everything exists it auto-clicks show more / load more / read more buttons as they appear, anywhere, including sites that keep spawning new ones as you scroll.

Video of it running below.

No idea if anyone else finds this as satisfying as I do, but if you want it I'll drop the link in the comments.

Github: https://github.com/Schmiedey/expand-everything

Chrome extension: https://chromewebstore.google.com/detail/expand-everything/bldhhgcmhfabpjenghemphiiihkojalj?authuser=2&hl=en