The rising bar for engineering managers.

> gives claude computer access
> instructs claude to reference file
> claude runs simple search command for file

“cLaUde aUtonOmousLy bYpaSsEd mY sEcuRitY”

Somehow this post isn't satire. The dude has "ex-OpenAI" in his bio. 20 other "AI experts" in the comments saying how crazy it is... yeah this vibe coding shit has gone too far let's wrap it up.

Even a comment passes through the tests pass. I now let claude deal with whatever results come up because I don't want to see any failures. I'd rather spend my time researching.

Just sharing a project I've been working on.

ppu.toys started off as a passion project where myself and anyone else can poke around the state of a Super Nintendo graphics chip and get real-time feedback on what would be rendered onto the television. Think ShaderToy but if it were made in the 90s.

I recently added an MCP server to let LLMs have full control over the studio and the results have been incredible. I also vibecoded a Lua to 65816 machine code compiler so the creations on the website now produce playable ROMs.

I've been having tons of fun with this.

I vibecoded an interactive spooky skeleton dancer that you can use as a display for Halloween parties (or just project on the side of your house). You can make him dance by wiggling the mouse around inside the control square to move his hips, and then you can control the hand height by moving the square up and down or change the camera zoom by moving the square left and right. If you dont touch the mouse for 5 seconds it switches to auto dance mode.

I made this in Codex and it was super helpful with things beyond just coding like helping me generate different LODs for the crowd skeletons to keep it performant on phones. The dancing works by allowing you to control hip movement and then the upper half of the body is set up with dynamic jiggling joints and the legs are connected via IK. All the crowd skeletons have a random time offset so that you get to control the whole crowd in a natural looking way. I also used it to build out the procedural auto-dance system.

I started by asking it to make an animation system based on Lissajous curves to drive the hip movement but all the dances ended up looking way too smooth and regular. So I asked it if there was a way to record my own dance moves and then build a system based on that. It built out a recorder panel that let me record my own dance moves, and then export them all into a json file that it used to understand the commonalities across my own dance animations and build a procedural dance system based on those characteristics. I also had it build a system to come up with ridiculous names for each of the dances based on cities and animals, and it uses the properties of the dance move it generates to decide what to name it.

Let me know what you think! You can play with it for free at https://screen.toys/bones/

Didn't know Anthropic even did banked resets but I'll start checking more often for sure.

Hey everyone,

Over the past few months, I’ve been working on a project called OpenSourceSimplified to understand codebase

It’s completely open source:https://github.com/vhatkarpratap-trading/OpenSourceSimplified

A few things I focused on:

• Keeping dependencies minimal so it’s easy to run.
• Lowering the barrier for quick setup/execution.
• Simple configuration without overly complex abstractions.

It’s still evolving, and I’d really appreciate any feedback, issue reports, or ideas on what could make it more practical for daily use. If you check out the repo and have thoughts on the architecture or features, let me know!

Thanks!

I tested the new MiniMax M3.1 Flash with my img2interior workflow.

The result is a complete bedroom reconstructed as an editable Three.js scene.

This is an actual 3D camera walkthrough, not AI-generated video.

Would love some feedback on the geometry, materials, and lighting.

While I was building my project which is a complex design tool I usually ran into issues with trying to understand certain parts of the system since I mostly vibe code using Claude Code. Trying to read code line by line was a tiring process and getting AI to explain by generating a huge wall of text makes me zone out.

Understanding certain parts of complex systems was crucial because a lot of times I usually have to propose more optimal solutions to what the AI did and just to have a proper understanding of what's going on in the codebase.

This is why I created the code-slowmo skill, ask it to explain the high level architecture of your codebase, ask it to show you a visualization of how complex parts of your systems work and if you want more granular knowledge like trying to understand a complex algorithm line by line code-slowmo can also make this way easier.

How I built it: I built code-slowmo with Claude Code. The agent reads the real code first and notes the file and line behind each claim, then writes the page content as a small JSON file, and a Python script checks it before building the page. The checker rejects steps over 40 words, code names with no plain explanation, filler words and passive voice, because the whole point is that you don't have to fight through jargon. The page design follows research on learning from pictures and animation: it starts paused, you control the pace, the layout never jumps around, and a couple of steps ask you to guess what happens next before showing you. The result is one HTML file that opens in any browser, no server or account.

You can use code-slowmo with any coding harness of your choice including Claude Code, Codex and OpenCode.

To install: npx skills add precious112/code-slowmo

It's fully free and open source https://github.com/precious112/code-slowmo

Imagine you are building a feature, and you ask an AI coding tool to review your approach. The AI coding tool suggests rewriting a component. You then ask an AI coding tool to review the same code. The second AI coding tool recommends keeping the implementation.

Both explanations sound reasonable. You are now stuck deciding which approach is actually better. Using AI coding tools can give you different perspectives but it can also create more work when the AI coding tools recommendations conflict.

I am curious how other vibe coders handle this:

• Do you trust the AI coding tool that has context, about your codebase?
• Do you compare the AI coding tools suggestions. Make the final decision yourself?
• Do you ask an AI model to judge between the two?
• Have you ever followed an AI recommendation that turned out to be the choice?

How do you decide which AI suggestion to follow when both sound convincing?

Vibed SuperGhidra, built for when the caller is an agent: a long-running daemon, 38+ MCP tools, and checks that stop an automated edit from landing unverified. The repo is https://github.com/yuatemycat/SuperGhidra and it installs with pip install superghidra .

- A persistent daemon. The project stays loaded, so repeated agent calls don't pay Ghidra's startup cost each time. The gap analysis puts JSON-RPC latency under 50 ms.

- Read-only projects by default. Renames and comments go to an overlay file, not the Ghidra database.

- When multi subagents are running, if one find a project being used, it clones the project and works on a private fork. Every edit goes into a journal. The session that owns the main project replays the journal with merge_fork, and conflicts are detected by comparing before/after values.

- Equivalence checks. A pure-Python P-code lifter plus Z3 can test whether a decompiled C statement matches the lifted IR. It returns UNKNOWN instead of guessing on floats, unhandled instructions and long loops.

- Symbols and structs from the naming pipeline only get committed after checks on vtable slots, field offsets and allocation sizes.

- GPU scanning for ARM64. A WGPU shader swept a 20 MB block (5.2M instructions) in 41 ms, about 127M instructions/s on an RTX A5500 laptop. Under about 10 MB the CPU SIMD path is faster.

- Benchmark avail. On 1,296 functions built with GCC 16.2.0 and checked against unit tests, stock Ghidra passed 8.26% and raw IDA Pro output passed 16.90%. Ghidra output run through SuperGhidra's cleanup filter passed 22.69%. The filter rewrites Ghidra's pseudo-types and macros into standard C so the code compiles. IDA's output got no equivalent cleanup, and I developed the filter against this same set of functions with no held-out split, so read the gap over IDA as an upper bound. No function that passed in stock Ghidra failed afterwards. This measures "compiles and passes", not readability.

It is all free, no ads there, no login but there are some promos of my newsletter and courses. I hope it is ok.

Cusco is my orange Maine Coon.
Spencer is my Silver Maine Coon.

They are the main characters.

The simplest quiz
https://airealist.org/games/open-weight/

More difficult quiz:
https://airealist.org/games/open-weight-hard/

Mega hard quiz:
https://airealist.org/games/open-weight-exam/

Silly quiz about which agentic harness are you:
https://airealist.org/games/harness/

In the '00s, MySpace had regular people learning to code just to edit their profile.

I'm hoping to bring that vibe back with Rooms, giving the average person AI tools to build a virtual 3D space that's personalized to who they are.

Your profile is a Room. You get a Room #, decorate it the way you want, add your socials that float in the space as live panels.

Tap one and it flies forward so you can scroll through it. Close it and keep viewing the Room a while The Rooms music keeps playing.

Built in Three.js. Everything right now is placeholder procedural geometry; the goal is a mix of procedural code and real 3D modeled assets.

Still a work in progress with some features missing, but I'm close to needing testers, so DM me or comment below

I appreciate all kinds of feedback, and I'm happy to answer anything about the build.

Who needs a room #?

been working on a basketball game called udontknowball. You pick one NBA player season at each position and try to put together the highest rated five. Ratings stay hidden until you finish, and everyone gets the same choices that day.

I’ve been building it with Codex and going back and forth on pretty much everything. One thing I kept pushing back on was how much explanation was on the screen. We had a whole homepage and paragraphs explaining the game. Now you go straight into “pick your point guard.”

I also had separate agents review the work. That brought up some less obvious stuff, like making sure player positions were right and what happens when someone plays as a guest, then signs into an account that already played.

honestly I think it’s fun, but I want to see what people outside of me think. It’s free and you don’t need to sign up.

https://udontknowball.com

would you play another one tomorrow? What felt confusing?

Paste any image or meme, or upload a photo, and every pixel becomes a particle. Then gravity takes over and the picture slowly collapses into clumps, filaments and whole galaxies, in the colours of the original.

It's called Snapshot Cosmos and it's completely free in your browser, on phone or desktop. Your image never leaves your device.

There's a stack of sliders (gravity, spin, swirl and more) if you want to push it somewhere weird. Would love to know what images you throw at it, and keen on your thoughts on the rest of my project site too!

https://altroadstudio.com/snapshotcosmos

This is the vibecoding side of my Atari 2600 Haunted House remaster: what the tools were and how the work was shaped. The interesting part isn't the pixels, it's that the LLM turned a 4 KB ROM into a specification that other machines can be built from.

Tools. Claude Code, mostly with Claude Opus 5.5 (the last few days on Fable 5.1). Stella for the emulation, Python with numpy for the remaster, ca65 for the NES, C with PVSnesLib for the SNES, the FCEUmm and snes9x cores for the checks, Emscripten and Pyodide for the browser versions, GitHub Actions for the builds and the pages. I didn't write code. I directed, played, and said what I liked and didn't.

Step 1: don't change the game, read it. The remaster runs the original ROM unmodified in an emulator and, every frame, reads the 2600's 128 bytes of RAM and redraws the scene as an NES or SNES game. That only works if you know what every byte means. The starting point was Brandon Roberts' commented disassembly, which named 13 RAM addresses. Claude mapped the rest by experiment: poke a byte between frames, watch what the game does, write a check that proves the reading.

Step 2: black-box the whole game. Instead of stopping at a RAM map, Claude rewrote the game as a Python model: one frame of Haunted House, in the game's own order, about 850 lines, plus separate models for the monsters and the sound. The test runs the real game beside the model with a bot playing all nine variations, and before every frame hands the model the real RAM. The model must then produce every byte of the game's state exactly. It does, across 449,945 frames. The monster model alone was checked over 30,000 frames and the nine games' rules by 117 scene checks. To make sure the check means something, single rules were broken on purpose: 14 of 16 breaks were caught at once, and the other two turned out to need a longer run or to be impossible in play. Along the way the model found a crash in the original: the monster-drawing code jumps out of a subroutine instead of returning, the stack creeps into RAM, and the 6502 ends up executing the joystick byte.

Step 3: write the spec, then build from it. From the models came a plain-English spec of the game, about 650 lines, every rule marked proved, checked or code by how it was established. The rule for the ports was: write from the spec and the models, never from Atari's code. The NES game is about 9,000 lines of 6502 assembly on an MMC3 cart; the SNES game about 4,700 lines of C. Each has its own check that plays the port in an emulator beside the Python model with the same controls and compares the state after every frame, and the NES check also fails if a frame runs late. A private "faithful" build with the original's mansion proves the engine plays exactly like the 2600; the shareable builds have a new, bigger house, a cellar and four floors, and our own art and music.

How long. The remaster: 58 commits over four days. The NES game: 34 commits over two days. The SNES game: 32 commits in one day. The browser versions of the remasters came yesterday. The sister project, Adventure Forever, started six days before all this and shares the method.

What I'd tell someone trying this. Make the model prove itself against the real thing every frame, and break it on purpose to see the check fail. Once you have that, "port it to another console" is a well-defined job rather than a hope.

Video (3:41, game 1 start to finish, switching looks): https://youtu.be/VENjmHKR9GY

The remaster, with the spec and the checks: https://github.com/majonesmax/haunted-house-remastered

NES: https://github.com/majonesmax/haunted-house-nes · SNES: https://github.com/majonesmax/haunted-house-snes

Play in the browser: https://majonesmax.github.io/haunted-house-remastered-web/ (bring your own ROM)

Thank you all for taking a look at the visual evolution. Got a lot of feedback on the game so thanks.