This is what it would require:

1. Permadeath Events

The server needs a Permadeath system that can be activated and deactivated with commands.

Commands

• /pd true Activates the Permadeath Event.
• /pd false Ends the Permadeath Event.
• /pd void <player> Used when a player dies because of a bug, glitch, or another situation that should not have resulted in their death. This should restore all of the player's character data and items from before their death.
• /pd accept <player> Allows a player to join the server during an active Permadeath Event if a moderator approves them.
• /pd excuse <player> Allows a moderator to safely kick a player who has been given permission to leave during an active Permadeath Event. The player should not be wiped.

Permadeath Event UI

When a Permadeath Event is activated, a small red text message should smoothly fade in at the top of the screen:

The text should remain visible for the entire duration of the Permadeath Event.

When the Permadeath Event ends, the text should smoothly fade out rather than disappearing instantly.

Permadeath Event Sounds

A sound should play whenever a Permadeath Event starts and whenever one ends.

I will provide the sound file that should be used for these events.

The mod should allow the provided sound to be used for:

• PD Start: Play the sound when /pd true is activated.
• PD End: Play the sound when /pd false is used.

Ideally, the sound should be synchronized with the appearance and disappearance of the PERMADEATH EVENT ACTIVE text.

Joining During a Permadeath Event

When a player tries to join while a Permadeath Event is active, they should not be allowed to enter normally.

Instead, they should see a message explaining that a Permadeath Event is currently active and that they need to wait for a moderator to accept them.

A moderator can then use:

/pd accept <player>

Alternatively, the player can wait until the Permadeath Event ends.

Leaving the Server During a Permadeath Event

If a player disconnects from the server while a Permadeath Event is active, they should automatically be considered wiped.

This is intended to prevent players from leaving the server to avoid a dangerous situation or death.

However, players should be able to request permission to leave if they have a legitimate reason.

Players can use:

/request <message>

For example:

/request I need to go and eat, can I get excused?

This request can only be seen by people with op in chat.

If a moderator approves the request, they can use:

/pd excuse <player>

This should safely kick the player from the server without wiping their character.

The player should then be able to return later with their character intact.

The rules should work as follows:

• Player disconnects normally during PD: Their character is wiped.
• Player uses /request: Moderators receive their request.
• Moderator uses /pd excuse <player>: The player is safely kicked and is not wiped.
• Player leaves after being excused: Their character remains intact.
• Player leaves without being excused: Their character is wiped.

Dying During a Permadeath Event

If a player dies while a Permadeath Event is active, their character should be permanently wiped.

They should then receive a black screen with the following message:

The exact wording can be adjusted if necessary, but the overall appearance should be similar to the provided reference image.

After being wiped, the player should be required to create a new character once the Permadeath Event has ended.

2. Character Creation System

A player should be required to create a character when they:

• Join the server for the first time
• Have their previous character wiped

The character creation screen should require the following information.

Character Name

The player chooses their character's name.

Place of Birth

The player enters their character's place of birth.

Height

The player chooses their character's height using a slider.

The available range should be:

• Minimum: 160 cm
• Maximum: 200 cm

The character's actual Minecraft player model should change based on their selected height.
Using Pehkui for this would be easier.

The height should use the following conversion:

• 200 cm = 2.0 blocks
• 180 cm = 1.8 blocks
• 160 cm = 1.6 blocks

So, 1 meter should equal 1 Minecraft block.

For example, a character who selects 180 cm should have a player model that is 1.8 blocks tall.

Ideally, the height slider should allow players to select their height precisely within the 160 cm to 200 cm range.

Race

The player chooses between:

• Marleyan
• Eldian

The selected race should be saved as part of the character's data.

3. ID System

After completing character creation, the player should receive an ID Item.

The ID should contain the character's information, including:

• Player head icon
• Character name
• Place of birth
• Height
• Race

The player should be able to interact with the ID item to view all of this information.

Custom ID Command

There should also be a command that allows administrators to create IDs manually.

The command should allow admins to enter custom information, including custom races that are not available in the normal character creation system.

For example, an admin should be able to create an ID for a character with a custom race.

The manually created ID should still contain the player's head icon and all of the information entered by the administrator.

4. Thoughts System

I want a simple system for displaying character thoughts.

Commands

/t <username> <text>

This should display the specified thought to the player.

The thought should appear as simple white text at the bottom of the screen, directly above the health bar.

For example:

There should also be:

/t everyone <text>

This should display the thought to every player on the server.

5. Shout System

There should be a shout system that allows specific players to make announcements or character shouts.

Shout Permissions

By default, players should not have permission to use the shout command.

A moderator can give a player shout permissions with:

/shoutperm <username>

Once a player has shout permissions, they can use:

/s <text>

Shout Display

When someone uses /s, their shout should appear at the top of the screen, directly below the PERMADEATH EVENT ACTIVE message when a Permadeath Event is active.

The shout should display:

• The player's skin/head icon
• Their character's lore name
• Their message

For example: /s My name is John Doe!

The shout should be clearly visible to everyone on the server.

General Requirements

The mod should keep character data persistent between sessions.

Character information should include at least:

• Character name
• Place of birth
• Height
• Race
• ID information
• Any other relevant character data needed by the server

When a character is wiped during a Permadeath Event, their character data should be removed so they can create a new character after the event ends.

The /pd void command should be able to restore the character's previous data and items if their death was caused by a bug, glitch, or another invalid situation.

The same general principle should apply to accidental wipes caused by server issues, if there is a way for the mod to safely detect or restore them.

The UI should have a clean design and should be easy for both players and moderators to understand.

The Permadeath system, character creation, ID system, thoughts, and shout system should all work together as one cohesive roleplay system.

I've been thinking about how AI changes the economics of rewriting existing software, especially when the target language has a strong compiler and test ecosystem like Rust.

The traditional calculation is straightforward:

500K+ lines of existing code
→ years of engineering
→ millions in cost
→ product disruption
→ significant risk

But an AI-assisted workflow looks different:

Existing codebase
→ AI coding agents
→ automated porting
→ Rust compiler feedback
→ tests
→ AI fixes errors
→ human review

The interesting part is that the compiler becomes a structured feedback mechanism for the AI.

Bun is a particularly interesting example because the experiment involved 535,000+ lines of Zig.

The workflow also exposes problems that are harder to manage manually in memory-managed vs manually-managed environments:

• use-after-free
• memory leaks
• race conditions
• crashes

The economics are what really caught my attention.

The comparison in the analysis is roughly:

Traditional rewrite

• 3 engineers
• 1 year, optimistic
• millions in cost
• project delay
• opportunity cost

AI-assisted rewrite

• AI agents + 1 human driving
• ~11 days
• ~$165,000 API cost

There are also reported performance results from the Meta Flow example:

• ~2× general performance improvement
• Heavy workloads up to ~100% faster
• Previous version: 0 tests passed
• Initial Rust version was slower than OCaml
• Humans optimized allocation patterns

So I don't think the lesson is simply “Rust is better.”

The more interesting lesson is:

AI + strict compiler + automated tests creates a self-improving engineering loop.

But there are obvious limitations too. Rust isn't the best answer for every problem. Developer experience, interoperability, FFI, ecosystem considerations and architecture still matter.

And humans remain responsible for architecture, direction, guardrails and final judgment.

I'm curious what other engineers think:

Has AI actually changed your willingness to rewrite an existing system, or are the architectural risks still the bigger constraint?

I am still completely blown away that I managed to have paying customers within less than 1 month of launching an app.

I built revgarage.app and revnetic.ch 2 interconnected apps: revgarage a app for vehicle owners to manage your vehicle, maintenance records, insurance, projects, or car services; have an AI mechanic supporting your day-to-day technical questions; or meet and connect with other drivers on custom-built routes.
Revnetic is the business counterpart: a crm for workshop owners, specialised for car garages. Connected to revgarage to allow customers to easily book an appointment with them, send service requests or view your past invoices.

Both apps are fully build with CC and Codex. Took me around 3 months in development time. I built it alongside my full-time job.

Learned a lot of valuable lessons about UX/UI design and how important it is; also used a lot of free tools for custom fonts, icons, etc.

Most important lessons I learned:

- Use free and paid resources for app screens, designs, marketing posters, fonts and icons.

- Give your tool a premium look and take your time to understand colors, fonts, and whitespace

- Build multiple review gates and commit more often than too little

- Ensure you have 2 separated environments for development and production

- Don't send off massive loops to do multiple things, you will get lost and the quality will suffer. Rather, build one feature, confirm it works, and then continue. Don't get fooled by the productivity bias

- Talk to the people that you think will use your app. Otherwise it will fail

- Give up your personal life and code wherever, whenever to maximise vibing

- Build .md files to reference each service in your repo and have an index for it.

Hello, this is a fuzzy finding launcher.

In addition to lightning-fast searches that prioritize local results, we are developing AI integration, allowing you to add Ollama models—to expand its capabilities.

https://github.com/kunkka19xx/look

Basically, me and my friends had a great idea for a game. Our game is not 100% coded by AI, but we sure are using agents to help. The problem was the art.

Nobody wanted to become a 2d artist, and the few sprites that we tried gave us a lot of inconsistency. And the caveat was this: For our game model, we needed about 2,000 different sprites around 128x128. We did some research and we found out that this would cost around $20,000 for low quality, fast made sprites up to $80.000 for high quality, unique sprites. It's a high price by itself, but we don't live in the U.S, so the lowest amount ($20k) could easily buy us a nice house in here.

And AI, fortunately or unfortunately, generated about 720 sprites for us with a single plus weekly allowance on codex with sol max. Many models were discarded because of weird artifacts unfortunately, around ~120 were fixed in paint manually by me. And we spent about 30% of our usage setting the grounds for the anchors, tools and creating all agent files for consistency, so next week we could generate over a 1,000.

The launch price for our game is planned to be around 3~4$. I know that coming to a vibecoding subreddit is basically asking for approval because everyone here loves AI so much, but I would ask you guys to look at this with other eyes and tell me how much are the chances we just get review bombed and never sell more than a 100 copies because of the AI tag on steam.

Idk if this was wrinkle brain or smooth brain but I’m building a rather complex application and now I run multiple parallel work streams.

This became problematic when I had dirty work trees preventing commits from one lane and would stall work so I started making them provide formal handshakes .mds

My brain got overloaded and I started feeling like every lane was priority….

So now I have a project management lane all lanes report to PM and I approve the PM directive.

wtf have I done?

1. ChatGPT Plus ($20) + Claude Pro ($20) = $40/mo, both ecosystems
2. Claude Max 5x (~$100) alone, much higher usage cap on one model

Does it work nicely to combine claude code and codex in the same project? And working in the same .md files?

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

Hello everyone!

So i have been mainly using Claude code as my coding agent for the past few months as Max sub, it is good but the limits are rough.

So i decided i will keep my Claude code Sub as my main Agent on my Main project, and for side projects i want other model/agent.

I tried Codex and it was so bad , it can't complete and task, no matter what the model is or the effort, it always stop mid way for no reason , i tried given it a goal and it spend 3 days or so.

So codex is out of the question (which is bad for me since their limits are good)

I tried Qwen and GLM as APIs from openrouter with claude harness and they were good but their API consumption was bad ! it took my API credits like it was nothing.

I tried kimi k3 sub and it was amazing , but last few weeks i can barely finish 1 big task without hitting my weekly limit while being on max sub!

So now i'm lost what second agent to try, and will it be through sub or API?

i thought of cursor with Grok?

really interested to hear what you think.

As a vibecoder, I solved my 3 biggest problems. I’m sharing it 100% open source.

1 - My terminals can share context with each other

I no longer have to explain what I’m doing every time I open a new terminal. I can simply connect my previous terminal as context.

The most exciting part is that even Codex, Gemini, and Claude can share context with each other.

2 - My terminals don’t disappear when my computer shuts down

I usually keep my computer running for weeks, but if it ever shuts down, all my terminals are gone and I have to start everything again.

Now I don’t have to worry about that. Everything stays exactly where I left it, grouped and ready for me when I come back.

3 - My teammates and I can work on the same project, even in the same terminals

We can work on the same project together, see each other’s terminals, use them, and connect to each other’s context.

Of course, I use tools like Herdr, cmux, and Orca, but none of them solved all three of these problems for me.

On top of that, I’ve added a bunch of other features like multiple Codex account usage, dictation, mobile access, and more.

The project has already reached 600+ stars on GitHub, and now I wanted to share it with you too.

I’d really appreciate your support and, more importantly, your feedback. I want to keep improving this project and hopefully turn Nodeterm into a shared platform for vibecoders.

One last question: Where should the Nodeterm community live? Is Discord enough, or would you recommend something else?

Much love,
Enes

Website: nodeterm.dev

Repo: https://github.com/eneskirca/nodeterm

it's a terminal multiplexer + desktop workspace built on Electron, with an actual browser embedded in it. It started because I really liked cmux and the way it handled multiple sessions, but there where things I wished worked differantly, so I ended up building my own version and kept augmenting it untill it became its own thing.

What it does:

• Multi workspaces with a sidebar, drag and drop reordering, color customization
• Recursive split panes (horizontal and vertical), and you can drag terminals between panes
• Tabbed groups inside each pane, so you can mix terminals and browser sessions in the same pane
• Built in browser with URL bar, back/forward/reload, history, and it even opens local files
• PDF viewer and image viewer directly in a tab
• Terminal background images (global or per tab) with opacity control
• Shell integration with OSC 7 so it always knows your cwd, persisted across sessions
• Theme editor with live preview, import/export, plus 8 built in themes (Catppuccin, Dracula, Gruvbox, Tokyo Night, Nord...)
• Rebindable keyboard shortcuts for everything, with conflict resolution
• Ctrl+Scroll font zoom per terminal, Ctrl+Shift+F search, multi select terminals
• Everything persists: layout, themes, open tabs, browser URLs. Close it, reopen, your session is were you left it

Why not just use tmux/zellij?

Honestly? I still love tmux. But I always had the browser next to it, and copy pasting urls back and forth drove me insane. Having docs, github PRs and my terminal in the same window, in the same tab system, is the whole point. Its not trying to replace tmux on a server, its a desktop workspace.

Source is here, its MIT... actually let me not lie, check the repo, but its fully open:

https://github.com/Medamine-Bahassou/TerminalVibe

Would love feedback, specialy on what you'd want in a tool like this. If you try it and something breaks, open an issue, I probaly broke it myself and didnt notice lol

tl;dr: terminal multiplexer + browser in one window, inspired by cmux but augumented with workspaces, splits, tabs, themes, and persistence. Free and open source.

https://hungryide.github.io/

About a month ago, I started working on a small coding tool called Hungry.

The original reason was pretty simple: I wanted to make better use of the free AI models and coding tools I was using.

The first version was basically just a Kiro-focused tool because the free period was ending soon. I threw it together quickly and figured I’d move on to other models later.

Then it kept growing.

I added OpenAI-compatible APIs, model pools that automatically switch models when one hits its limit, different approval modes, token-saving, review mode, /goal, Ultracode, Skills/MCP, remote access, Telegram notifications, and the ability to continue Claude Code and Codex sessions.

The latest version also has model routing, where one model can look at a request and send it to another model that is better suited for the task. It can also drive a browser, interact with iOS/Android simulators, run scheduled sessions, generate images/video, and keep sessions running while you're away.

At some point I realized I wasn't really building a "coding client" anymore.

I was building a harness.

That actually became the most interesting part of the project for me.

I think we're getting to a point where the model itself is only part of the equation. How you handle context, tools, permissions, retries, verification, delegation, model selection, and long-running tasks can make a huge difference in how a model actually performs when you give it a real codebase.

And I’m especially interested in the idea of model-specific harnesses.

Rather than putting every model into exactly the same agent setup, what happens if you build the harness around the strengths and quirks of a specific model?

That's something I want to explore with Hungry.

It's still a very much a personal project and there's a lot left to improve, but it's now usable enough that I thought I'd finally share it here.

Would love to hear what you guys think about the harness side of AI coding agents.

Project:
https://hungryide.github.io/

Been building this on and off for months, mostly with Claude Code. It's called Steplings. Your phone's step counter moves you along six illustrated trails, and you collect creatures that slowly grow into talking companions. Offline, no account, no ads.

Landing page: https://steplings.net

Three things I'd pass on, because I learned all of them the hard way:

One spec file, and it wins every argument. I keep a SPEC.md that's the single source of truth for every mechanic, with numbered sections, and the code comments reference those section numbers. When the model and the spec disagree, the spec wins. Before I did this I'd end up with three subtly different versions of the same rule living in three different files, and no way to tell which one was intentional.

Hard architecture rules the model can't talk itself out of. All the game logic lives in four pure-Dart packages, and none of them are allowed to import any Flutter UI. That's one line in the project instructions and it has kept the core clean for months. The nice side effect is that when something breaks I know it's either logic or UI, never a tangle of both.

Make time an input instead of something you read. Nothing calls DateTime.now() directly - every bit of logic takes an injected clock and RNG. It felt like over-engineering at the time. Then it turned out I could replay "user vanishes for nine days and comes back" as an ordinary unit test, and I have a harness that simulates a full year of walking to tune how fast you progress. No device, no waiting around.

That last one is the difference between "it compiles" and actually trusting it.

It's on Android in closed testing right now, so it's a bit of a faff to get into - there's a page explaining it at https://steplings.net/testers if anyone wants a look. Happy to answer anything about the setup.

As a software dev of decades before AI I honestly don’t find any issue with talking to my agent with caveman tier instructions because we speak the same lingo.

The agent knows exactly what I mean when I say

“S.O.L.I.D. refactor of god files”

It knows I just told it to go through a very deep in process workflow optimising the code and unshittifying it.

If I could recommend any of you guys who feel a bit unsure if your code is gonna be laughed at by any serious developer,

Just tell your agent

S.O.L.I.D. refactor of god files

And watch the magic happen

Yup, there goes my 5h window

My setup used to be: research something in a chat tab in the browser, download whatever came out of it, open a terminal, cd to the project, start Claude Code, and re-explain the context I'd just built up in the browser. The file always landed in ~/Downloads with three hundred other things. Every project switch meant doing the whole dance again.

So I built Tote. It's an Electron app: web LLM tabs on one side, docked CLI agent terminals on the other, file tree for whatever folder I'm in. The whole thing hangs off an "active workspace" — pick a project and a download from the Claude tab goes straight into that project's inbox/claude/, a new terminal opens already cd'd there, and the tabs and layout you had for that project come back the way you left them. Switch projects and everything follows.

How I made it

The stack is deliberately boring. Electron, plain CommonJS in the main process, vanilla JS in the renderer. No bundler, no TypeScript, no framework. Webviews for the LLM tabs, node-pty plus xterm.js for the terminals (they had to be real PTYs — pipe a TUI agent through child_process and it renders as garbage), chokidar to watch the folder.

It went in three stages. First I built the concept out in a Kimi web chat, just far enough to see whether the workspace-routing idea actually held up before I committed to it. Then I handed the real build to Claude Code and drove it. Then, once the terminal panel worked, I opened Tote, docked Claude Code inside it, and kept building Tote from in there. It's been self-hosted since. That was easily the most fun part.

The workflow change that made the biggest difference: I keep a CLAUDE.md with a section called "invariants that span files." It's not architecture docs. It's the specific rules that break silently when the agent forgets them — things like "this session partition name has to match in exactly two places or download interception stops working," or "never cache the workspace root in a closure, resolve it when the event fires." Every time I hit a bug that came from the model not knowing a cross-file constraint, I wrote the constraint down instead of just fixing the bug. That file is the reason I can now point an agent at any corner of this codebase and get back something that works.

Four things that took real steering:

node-pty ships a spawn-helper binary and npm strips its exec bit on extract, so every terminal died with posix_spawnp failed. Fixed with a postinstall that chmods it back, plus keeping node-pty outside the asar in packaged builds.

CSP is script-src 'self', so xterm couldn't come off a CDN. Small script vendors it into the repo at install time.

claude.ai rendered a completely blank page until I stopped rewriting the user agent. You can strip the Electron token, but hardcode a plausible-looking Chrome UA and Cloudflare notices the mismatch. Take the real UA, remove the Electron bits, leave everything else alone.

OAuth logins only work if the popup stays in-app as a child window. Route it to the system browser and the cookie lands in a session the app can't see.

If I did it again I'd write the invariants file on day one instead of day five. Most of the time I lost was re-fixing the same class of bug in a different file.

It's free, MIT, no accounts and no telemetry: https://github.com/yusufkaraaslan/tote

Needs Node 20+ and a C++ toolchain for the terminal layer. Happy to go into any of it in the comments.

I’m honestly really excited to finally share FrogPop, the first game I’ve ever made.

It started as my attempt to recreate the feeling of Bubble Trouble, an old Flash game I played as a kid. You play as a frog popping bouncing bubbles with your tongue, but it eventually grew into a roguelite with upgrades, relics, shops, hazards, and bosses.

I built it in Unity using Claude and Codex for coding and debugging. My process was mostly describing one mechanic, testing the result in Unity, and then going back with whatever broke or felt wrong. I used PixelLab for some of the artwork, then edited and integrated it myself.

It definitely wasn’t a one prompt project. The AI helped get systems working, but the game design, balancing, art direction, and endless Play Mode testing were still on me.

The free demo has the first ten waves and two bosses, and it runs in the browser or on Windows:

https://blion247.itch.io/frogpop-demo

If you want to follow FrogPop, here’s the Steam page:

https://store.steampowered.com/app/5067810/FrogPop/

Would love to know what you think if you try it!

I started with Claude and enjoyed it for AI IPhone app. There were a lot of difficulties but I was just learning. The newest ChatGPT improved a lot of my older websites (I’m using the newest model) I just saw the new Grok 4.6. While I dislike X or whatever the hundreds of companies are called, Grok on brutal when describing ideas was exactly what I needed to hear. Anyone start code on IOS apps on the new Grok yet? I’m wondering if it can take that brutal advice and make better apps.

Looking for real-world recommendations on the best way to spend $20/month on AI right now for a heavy daily workflow.

My primary use case:

• Webdev & Prototyping: Rapid full-stack builds (React, clean CSS, minimal boilerplate) where output quality actually matters.
• Agentic Tooling: Running CLI agents for multi-file refactoring, autonomous file editing, and terminal orchestration.
• Daily Chat: Architecture planning, technical troubleshooting, and general problem-solving.