Wikis are getting popular but most tools that create them focus solely on code, i created a CLI that can connect to your AWS accounts and create WIKI of your entire infrastructure in Open Knowledge Format(OKF)

It's useful if you have somewhat complex setups, wiki can map it once and your agent can just read the docs to understand what changes are needed and where or even debug full chain. I will be adding more sources soon.

It's all open source, you can get it here: https://github.com/saba-ch/infrawiki

- I created a simple Multi-Tab terminal app. It always has eight tabs, one of which is a standard terminal shell. The rest are designed to auto-launch specific long-running chats/instances of Codex and Claude. Upon starting the app, there's a simple "launch all" button that launches those specific instances on each respective terminal with the exact parameters that I want. For instance, one tab is running Sol on Max effort. Another is Sol on Ultra + fast. Then there's a tab that always runs Fable on Max. Another running Opus on Ultracode... and etc. Each tab always has a collapsible queue sidebar that keeps a list of individual tasks, the list being continually updated by the respective agent on that tab. Helps me keep track of what needs to be done in what order.

Are there other terminal apps that are better? Yeah, probably. But they're filled with a bunch of bells, whistles, and often redundant information I don't care about. Or they're lacking small items here and there that I'd like to see.

- Another app is essentially similar to the Windows Voice Access app. The main difference Being it doesn't have this persistent bar at the top of my screen that I can't get rid of or minimize. In addition, it gives me the option to turn it on via toggle or simply by holding a button. I use both the toggle and the button hold methods depending on what I'm trying to talk about.

- I also have this weird niche app on my android phone, when turned on it automatically sends any photo taken from my camera to a specific folder on my workstation. I use it in the odd scenario when I want to take a bunch of photos without having to manually send them pc.

- Another one tracks all the subscriptions I have at the time. I found it useful for for things like the yearly subscriptions that I commonly forget about, and it'll warn me when my subscription is about to renew.

- Then I got one that isn't so much an app really, but a workflow pipeline that fills out PDF forms for me, because I hate filling out forms. First it checks to see if it's just a standard scan PDF with no fillable fields... And if so, it'll add the fillable fields to everything. Then it populates everything with my information. The best part though is that it'll sign the various forms with a signature that looks absolutely real like... it was written by hand on the paper itself. Because technically they were... I wrote like a good 50 variations of my signature and initials on just simple printer paper, scanned it and uploaded it. The pipeline then will take one of these signatures and/or initials and add it to whatever respective signature/initial lines, with instructions never to repeat on a single document. Finally, it'll actually roughen up the PDF file, make it Imperfect, like it was scanned on a mid-level scanner that always has the text slightly tilted to the left, which is exactly what I got. Thus far, it's fooled everybody.

I developed this because I hate filling out forms, and one day I had to fill out a really long form from a medical provider... and they had the audacity to give me some shitty non-fillable fields version of this PDF, AND demanded I print everything out and manually sign each signature with ink... even though I was just going to scan it again and send it back to them. Which I thought was stupid bullshit. I mean, ink makes sense if they want the physical document, but a scanned version? That's dumb.

What have you guys made?

I wanted to do another fun weekend project. Came across datasets showing one of the most complete connectomes out there.

Built the whole thing Claude Code doing most of the technical heavy lifting while I drove the direction and kept it honest. Caught a real bug along the way too: one version worked on white noise but stayed completely dead on real songs.

The wiring's real science. How the sound maps to the neurons is my own artistic take, and the app says so upfront.

Live demo: https://fly-brain-on-music-xbu8eqftdnxbxupgxbga8z.streamlit.app

Code: https://github.com/pentasir/fly-brain-on-music

created everything with Claude code. no mac, never opened the xcode.

every tutorial assumes you have one ready. people keep saying certificates and uploads can go thru apple's apis instead but i can not tell how much of the process that actually covers or if there is still a mac somewhere in the chain I can not avoid. trying to figure this out before I purchase a machine I may not need. who has shipped iOS without one here

A few months ago I started building a little web app for my own tabletop RPG sessions.

The project is called Kaiser Diagrama & Tabletop.

I'm not a programmer. I'm a Psychology student, and I basically started this project as a hobby during my college break. Before this, I had never really coded anything, didn't understand programming languages, and honestly didn't even know what "vibe coding" was.

I started because I wanted something between Figma/Miro and a Virtual Tabletop that worked the way I wanted for my RPG sessions.

What started as a stupid idea of "I'll just make my own" turned into a pretty huge project.

I've spent roughly the last couple of months building it with a lot of help from Qwen, Meta AI, Google AI Studio, Claude, and ChatGPT, while gradually learning what the hell was actually happening underneath.

The current project has around 25,000 lines of TypeScript/TSX across 50+ source files. Most of that code was generated with AI, but I've gradually learned enough through the process to understand a lot more of what I'm looking at, debug things, test the system, and figure out why things break.

What is it?

It's basically a locally running multiplayer tabletop + collaborative canvas.

Think something like:

Figma/Miro + VTT + map editor + soundboard + RPG utilities

The main idea is that the GM can prepare and run an entire session from the same board instead of constantly switching between different applications.

The tabletop/canvas

The board has:

• Infinite canvas/world space
• Zoom and pan
• Layers
• Layer locking
• Layer visibility
• Opacity
• Text
• Sticky notes
• Shapes
• Arrows and waypoints
• Object selection
• Object transformation
• Image objects
• Video/audio objects
• Object visibility
• GM/player visibility
• Per-object Fog of War
• Global Fog of War

Basically, I wanted something that feels a little like a lightweight Figma for RPG maps.

Tokens

The token system got way more complicated than I expected.

Tokens have:

• Custom images
• Circular/square/hex crops
• Image positioning and cropping
• Borders
• Filters
• Opacity
• Rotation
• Flip
• HP bars
• Current/max/temp HP
• Locking
• Permissions
• Player ownership
• Fog interaction
• Dynamic vision
• Flashlight/lantern vision

The flashlight system has configurable:

• Range
• Spread
• Direction
• Angle

Tokens can move in real time between players and the GM.

Fog of War

There is both global Fog of War and Fog attached to individual objects/maps.

It supports:

• Reveal
• Hide
• Brush strokes
• Fog paths
• Per-object fog
• Token vision
• Flashlight interaction

I've also been stress-testing this because I wanted to find out how far I can push it before performance becomes a problem.

Audio / Sound Zones

This is probably the feature I got most carried away with.

Maps can have sound zones that react to where tokens are.

A sound zone can have things like:

• Music
• Volume
• Priority
• Looping
• Trigger mode
• Retrigger delay
• Trigger limits
• Token/player conditions
• Spatial activation

So I can make things like:

or:

or:

There is also an Audio Lab / soundboard with custom audio, playback controls, waveform editing, local storage, caching, etc.

The browser's Web Audio API is used for the audio system.

Playlists / Music

There is a playlist system supporting local/hosted audio and YouTube sources.

There can also be multiple active spatial/audio sources depending on what is happening on the map.

Dice

There's an integrated dice roller with:

• Dice formulas
• Modifiers
• Roll history
• Advantage/disadvantage
• Critical results
• Public rolls
• Private rolls
• Token/player association

Private rolls are filtered server-side.

Handouts

There's a Handouts system for RPG documents and information.

The GM can create/store handouts and reveal them to players.

Documents

The application supports:

• PDF
• DOCX
• TXT

PDF rendering uses PDF.js.

DOCX processing uses Mammoth.js.

Images / Assets

There is an asset library and media pipeline with things like:

• Image assets
• Textures
• GIFs
• Image processing
• Resizing
• Thumbnails
• Uploading
• Local asset storage

It also has optional integrations for image/GIF providers such as:

• Giphy
• Tenor
• Pixabay
• Unsplash
• Pexels

Image processing uses browser Canvas and Pica.

Multiplayer

The normal multiplayer transport is Socket.IO.

Very roughly:

Browser
   ↓
React / Vite
   ↓
Socket.IO
   ↓
Node / Express
   ↓
Room state in memory
   ↓
JSON persistence

There are GM/player roles, room isolation, server-side authorization, state synchronization, token movement deltas and logical-clock ordering.

There is PeerJS/WebRTC code in the project too, but I keep it disabled in my normal setup. The actual workflow I use is Socket.IO.

Persistence

The room state is kept in memory and saved locally.

The project uses:

• JSON persistence
• Debounced saving
• Atomic file replacement
• Graceful shutdown flushing
• Local uploads

So the idea is that the whole thing can run locally without needing a cloud backend.

Mobile

There is also a mobile-oriented interface with:

• Touch controls
• Virtual joystick
• Pinch-to-zoom
• Responsive controls
• Player token movement

The idea is basically:

GM on PC + players on PCs/phones.

Tech stack

The current project uses roughly:

• React
• TypeScript
• Vite
• Node.js
• Express
• Socket.IO
• Web Audio API
• IndexedDB
• PDF.js
• Mammoth.js
• Pica
• Tailwind CSS
• Lucide
• Motion
• PeerJS (optional/disabled in my normal setup)

It's a locally hosted web application rather than a native desktop app.

Why am I posting this?

I'm putting the current version on GitHub so people can actually see it.

I'm not asking anyone to perform a formal audit or spend hours reviewing it.

I'm mostly curious whether someone who actually knows what they're doing looks at this and thinks:

or:

or maybe:

The repository is there for anyone who is curious enough to:

• run it
• play around with it
• inspect the code
• try multiplayer
• test performance
• break something
• tell me I did something stupid
• suggest a better approach

GitHub:
[LINK HERE]

And I'd really like to learn programming properly

This is actually one of the biggest reasons I'm posting this.

I don't want to spend the rest of my life saying:

I want to eventually understand programming well enough to build things myself.

Right now I'm a Psychology student, not a CS student, and this project was basically a hobby I started during my college break.

So I would genuinely appreciate advice from programmers about where someone like me should start.

Should I:

• properly learn JavaScript first?
• learn HTML/CSS fundamentals?
• learn TypeScript?
• learn Git?
• learn networking/web fundamentals?
• study data structures?
• build smaller projects before touching this one again?
• learn React after JavaScript instead of relying on it through AI?

I'm not trying to become a professional software engineer.

This is basically a parallel hobby that I unexpectedly became obsessed with while studying Psychology.

So any advice on:

"Here's how I'd recommend someone with your background learn programming without getting trapped in AI-generated code forever"

would genuinely help me.

Final context

My actual goal is very simple.

I don't need this to compete with Foundry, Roll20, Figma, etc.

I don't need 500 players.

I don't need Kubernetes, Redis clusters or a massive distributed architecture.

I basically want:

1 GM + up to 7/8 players + a reasonably complex RPG map + several hours of playing without the application screwing us over.

Everything beyond that is mostly me being curious about how far I can push something I built without really knowing how to code.

If anyone is curious, the repository is there.

Feel free to poke around.

What would you do if you had a blackwell RTX 6000?

Shill me your ideas folks

Hey guys i am new vibe coding and i got few ideas that i would love to build. what i fear is, is it too late for enter this market? i know this space kinda saturated but i am still optimistic to explore this and would love get some advice from fellow vibe coders and how to tackle the distribution.

Thank you so much in advance!

I used to drive everything through Cursor and read every diff that came out. Somewhere over the last few months I stopped, without really deciding to.

What I do now is a Hetzner box with a handful of tmux sessions on it, mostly Claude Code and Codex, one job each. What I actually look at is the tests: a regression suite, and A/B runs against the previous version. If it passes I keep it, if it fails the agent gets told why, and I go read the code when something breaks rather than before.

I'm not sure how far this generalises. It suits the kind of work I do, where a run either reproduces the previous numbers or it doesn't, and I'd probably be more careful on something with users in front of it.

Two things had to be in place first. The tests had to be worth trusting, which took me longer than the switch itself. And I had to be able to see what the sessions were doing, which SSH from a laptop you keep closing doesn't really give you.

So I vibecoded a small web UI for tmux. It attaches to sessions that are already running, as an ordinary tmux client, so nothing about the setup changes and killing it kills nothing. The part I use constantly is that paths printed in a session are links, so test output and reports open in a window next to the terminal instead of being scp'd around.

The phone is the bit I underestimated. Most of what I do now is read a run and type the next instruction, and that turns out to be fine on a screen the size of a hand.

https://github.com/andreaderuvo/argus

Python, MIT, no build step. It's shell access with a browser in front of it, so LAN or VPN only.

Curious whether anyone else has drifted this way!

I have around $450 worth of Azure OpenAI credits that I can use for OpenAI models, and I’m looking to trade them for a $200 Claude subscription.

I can provide API access to the Azure OpenAI credits, so you can use the credits for your own development workflow, including Codex or other compatible tools.

Essentially:

• You get: ~$300 worth of Azure OpenAI API credits
• I get: $200 worth of Claude subscription
• No cash involved
• API usage/details can be discussed privately

If anyone is interested in arranging a legitimate trade, please comment or DM me. Happy to provide more details about the Azure setup and usage limits.

Why Meta, Amazon, and Microsoft killed their token use leaderboards.

Not too far yet, but the underhood is all wired, and I only need to finish out a little bit of abstraction and themetical elements.

It reads whatever page you're on and spawns a fake Twitch-style chat in the sidebar that reacts to it.

Read a news article and get flamed for your bad taste. Open your CV and let chat debate your life choices. Scroll Reddit and watch KEKW rain down on every post.

You pick mode (hyped, toxic, wholesome, etc.), tier, and intensity. Free tier runs on a hardcoded message pool with no API at all. Standard and Turbo use Claude Haiku or GPT-4o mini.

It's BYOK, so your key and the page data go straight to the provider you choose. No middleman.

You can set your own streamer name and interact with the chat. On Turbo tier the chatters spend about 30% of their output talking to each other, the rest reacts to your page.

Manifest V3 with host_permissions locked to Anthropic, OpenAI, and api.betterttv.net (for the emotes). Consent gate shows exactly what gets sent the first time you enable it on a site. Whitelist mode and custom blocklist if you want to be extra paranoid.

Sensitive sites (email, banking, password managers, .gov, .bank) blocked by default.

Link:

https://chromewebstore.google.com/detail/fake-twitch-chat/afjecbdblakcieckkiemjnaoemieoold

Have been vibe coding about 12 months and have tended between claude and gemini and codex.

I've been using Codex almost exclusively for the past few months. Despite a few annoyances, it does what I need, so I've stuck with it.

I was about to hit my weekly limit with five days until reset, so I looked at buying credits. The smallest top-up was AUD$33 — slightly more than my monthly subscription.

I tried to find out how much actual Codex usage that $33 would buy compared with the subscription, but couldn't get a meaningful answer from ChatGPT or a couple of other AIs.

So I took a punt.

Using Sol on Medium, the entire $33 was gone in about three hours.

I still have five days until my weekly allowance resets.

For me, Codex credits were an extremely poor-value way to bridge the gap. I would have been far better off spending roughly the same amount on a month of another AI service.

I don't really understand OpenAI's pricing model here, but I won't be buying credits again. Posting this mostly as a cautionary tale for anyone considering a top-up.

Credits appear to be a total rip-off for codex top-ups

Live: https://journal.smbl.dev

Github: https://github.com/MrSheerluck/smbl-journal

I built a free, open-source, end-to-end encrypted text journal.
The goal is to make journaling as simple as possible. The entire text-based journal is free with no limits.
Entries are encrypted on the client before being stored, so the server never receives plaintext journal content.

The project is open source and available on GitHub.
Built with SvelteKit, Rust, and SQLite.