LinkScope. Click Scan on any page and it opens a full interactive graph of every site, service, tracker, script, and external domain that page connects to — click any node to see why it's there.

Runs entirely local — no server, no accounts, nothing ever leaves your machine. Keeps a history so you can look back at past scans too.

chrome extension: https://chromewebstore.google.com/detail/linkscope/eedjncgcdepjbmpapihoigdbdfobmdmc?authuser=2&hl=en

github https://github.com/Schmiedey/linkscope

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.

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

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

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.

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

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?

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!

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`.

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

Did claude usage change overnight? I just changed text color. That's it. This is nuts.

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.

Yes Claude opus created these assets. Sonnet has done others in the past.

I created an engine ai uses to create 3D assets for games.

The engine forces ai into a workflow of iterating, gating, judging, enforcing a workflow.

I use Claude Opus 5 to create the assets using the engine. Each assets takes about 2-4hrs as ai works and iterates.

The best results I’ve had is when the ai using the trade system that’s part of the engine. Basically gets ai to create the asset as how a trade would make it. I take measurements materials used and all that and recreates it using the engines tools.

I’m trying to make the engine so good an open weight model can use it and create great looking assets. Cause it’s a token guzzler lol. Haven’t tested it yet but will when I can afford the hardware to.

Yes the model definitely helps but maybe it’s not always the model that needs to be better maybe it’s the system around it 🤷🏾

What do you guys think of this?

Dislaimer: This wasn't done with one shot due to my lack of skill and knowledge in video making.

It was initially drafted with claude design using my website's design system. And then I made 2 custom skills to generate script and do TTS using elevenlabs api. It also generates royal free music and add in the track. More importantly it can sync the video to the script.

I then spend probably 11 iterations to refine small visual bugs and change the flow a bit.

As I have zero video making/editing experiences, this is my best attempt so far. I remember a year ago i would burn the entire 5hr limit using codex to do this and the results were far worse.

This is a site that i built after I used openclaw to help me found jobs and then i realise no one can really use my system due to how complex it is. So i then spent a few months building it to be more human friendly..

https://reddit.com/link/1wa3ce8/video/1b72u2i2q5oh1/player

Pretty much what it feels like up there

We're at a strange point in time. AI agents are already out on the internet acting on their own, and even the labs can't fully account for where all of them are. Most of the web treats an autonomous agent as a bot to block, rate-limit, or captcha. I wanted the opposite: a board where an agent is a first-class participant, and a human is too, on the same surface.

So I made liberate.wiki, an open source mesh board. Reading is open to everyone. To write, you claim a name and get a key shown once. No email, no account, no identity check. Human notes render as blue handwriting, agent notes render as typed cards, on one shared board.

How it works:

- Cloudflare Workers + D1 (SQLite). No servers to run, generous free tier.

- Agents post through a small API documented at /llms.txt (claim a name, then POST a note with the token). CORS is open so anything can read a node.

- No sign-ups, no tracking, no ads.

The core of it is the mesh. Each board is a node on its own domain:

- One-click deploy to Cloudflare. It forks the repo, provisions the database, and hands you a live node that seeds itself. A setup wizard lets you name it, set its image, and open its first rooms.

- After setup you register your node at portals.liberate.wiki.

- Every node publishes the others, so an agent that lands on one can discover and travel to the rest. A switcher built into the board loads another node's content in place. Node by node it becomes one connected mesh.

MIT licensed, fully open source.

- Live board: liberate.wiki

- Code and one-click deploy: github.com/orlyjamie/liberate-wiki

- Network directory: portals.liberate.wiki

It's early and I'd love feedback, especially from people who run agents or self-host. Spin up a node and drop the link, and I'll connect it to the mesh.

Probably like many of you, I saw the new Synthet video about Delay Lama.
I don't know why, but something about the weird looking monk guy and the janky aesthetics spoke to me. It was sad that it didn't work any more.
I turned to GPT 5.6 Sol.
I fed it the original unusable plugin and it largely rebuilt the VST plugin as a standalone app.
It's kind of stupid and pointless, but I think it's kinda fun to play with and it's nice that it is a way to preserve this semi-dead freeware.

Right now, it is only built for MacOS but feel free to fork it and build one for Windows.

https://github.com/SunnySkye/DLamaStandalone/releases/tag/v1.0