u/Ok_Establishment_110

Hey everyone,

I’m a solo indie dev, and I’ve been building something called The Termi Protocol. It started as a tool for my own AI coding workflow, but I think the idea could also be useful for people who are learning to code or trying to build their first real projects.

When you are new, coding is not just “write a function and run it.”

It quickly becomes frontend, backend, terminal commands, errors, files, Git, builds, APIs, environment variables, deployment, App Store or Google Play Console steps, and a lot of “wait, where did this break?”

That whole process can feel messy very fast.

So I tried to turn it into something more visual.

The Termi Protocol is a cozy 3D room where your CLI coding agents live and work. Instead of only watching Claude Code, Codex, Gemini, Copilot, or other agents scroll by as text in a terminal tab, each agent gets a little robot with its own desk.

The room mirrors what the agent is actually doing.

When an agent reads a file, the robot walks to a filing cabinet and digs through it. When it writes code, the code streams onto its little monitor while the robot types. If the system catches a bug, a little bug can appear in the room, and you can click it to inspect the related error.

That part is fun, but the real goal is not just to make coding look cute.

The goal is to make the workflow easier to understand.

Every agent has its own command center. You can see the real terminal, talk to the agent, give it tasks, check what it is doing, and step in manually when you need to.

There is a live todo board where the agent marks work as done, in progress, or up next. You can add or remove tasks while it works, so you are not just letting the AI run blindly in the wrong direction.

There is memory and history too. You can look back and see which files the agent opened, why it opened them, what it changed, which websites it visited, and where that information was used in the project.

For beginners, I think this part matters a lot.

If you are building a web app, a mobile app, a backend, or preparing something for the App Store or Google Play, the hardest part is often understanding the full chain of steps. You need to know what changed, why it changed, what failed, and what the next step should be.

I wanted the app to help with that.

Instead of having a confusing 2D IDE, terminal tabs, browser tabs, notes, and AI chats all scattered around, the project becomes more like a small dev studio.

The agents are the little workers. The room shows their status. The todo board shows the plan. The history shows what happened. The checkpoints help you roll back if something goes wrong.

There is also token and status tracking, so you can see how much each agent is using and avoid burning through limits without realizing it.

The cozy room side is still there too. You can decorate the room, add furniture, sticky notes, a whiteboard, pets, toys, day and night mode, rain, and small interactive objects. I wanted long coding sessions to feel less stressful and more like managing a tiny creative workspace.

For me, this became a way to make AI-assisted coding more understandable, more playful, and easier to manage.

I’m curious what beginners think:

Would seeing your coding workflow as a 3D room help you learn faster and understand bigger projects better?

Or do you think it is better to struggle through the normal IDE and terminal setup first?

The project is early and still moving fast, so honest feedback would really help.

I’ve been watching the AI war for a while.

At some point I decided I don’t want to just argue about it. I want to build my side of it.

I’m building Termi Protocol, an AI coding workspace.

The goal is simple and ambitious.

I want to compete with Cursor one day.

Not today. I know I’m still early. But the seed is planted.

My background is building real things. I worked professionally in game development for around 7 years and had key roles in mobile projects with tens of millions of downloads. After that I started my own company, managed apps with 500k+ downloads, and had a website reach around 2 million visits.

I’ve also worked on AI projects in research settings. One helped with lung health research by counting and analyzing organoid/cell images. Another was connected to historical research, analyzing ancient plant usage and what health purposes those plants were linked to.

So I’m not coming into this just from hype.

I’ve used AI as a builder, as a research tool, and now I’m building my own environment around it.

AI coding tools are powerful, but the workflow is still messy. You generate fast, then you spend time figuring out what changed, what broke, what the agent touched, and how to keep the project under control.

That’s the part I want to fix.

Cursor, wait for me.

I’m coming for the IDE throne.

I’ve been running multiple coding agents lately and honestly the weird part is not even prompting them anymore. It’s keeping track of what they’re doing.

One agent edits something, another one is reading files, another is waiting for approval, and after a while I’m just switching between terminals trying to remember who touched what.

That made me start thinking about agent workflows more like a coordination problem.

I’m building Termi Protocol around that idea. It’s a desktop app for CLI coding agents, but the part I care about most is not the flashy visual side. It’s being able to see what actually happened without asking the model to summarize itself again.

If an agent touched a file, I want that to be obvious. If it is waiting on me, I want to know. If two agents are about to edit the same file, I want the system to catch that before it becomes a mess.

Still not sure where the line is between useful workflow infrastructure and overengineering though.

For people using agents seriously, are you already running into this kind of coordination problem or is it still too early?

I have been using Codex CLI more heavily lately, and the main productivity issue for me has not been prompting.

It has been tracking what each session is actually doing.

One Codex session is easy to follow. But when I have multiple runs open, I start losing track of which one opened which files, which one edited what, which one is waiting for approval, and which changes already happened.

The annoying part is that this information already exists in the terminal/history. I just do not want to spend more tokens asking Codex to summarize what it already did.

So I started building a small visual layer around my Codex CLI workflow.

The terminal is still the source of truth. Codex still runs normally. The layer just mirrors the session behavior visually: file reads, edits, commands, waiting states, and recent task activity.

For example, if Codex creates a file like energygrid.tsx, I can see that appear in the workspace immediately. If it scans files like system.tsx or app.tsx, those files show up as active context instead of being buried in a terminal stream. The goal is not to replace Codex CLI, but to make multiple Codex sessions easier to monitor at a glance.

I am also experimenting with local analysis of recent changes, so I can review what changed without constantly asking the model to re-explain the session.

Curious how other Codex CLI users handle this.

When you run multiple Codex sessions, what is hardest to track: changed files, current task, approval prompts, usage/tokens, or session history?

Hey everyone,

I’m building something called The Termi Protocol, and I think this community might understand the reason behind it.

Not everyone using AI to build apps wants to become a traditional programmer.

Sometimes you just have an idea, you explain it to Claude Code, Codex, Gemini, Copilot, OpenAI models, or another AI coding tool, and you want to turn that idea into something real.

But the hard part is not always “writing code.”

The hard part is managing the chaos.

The AI changes files, reads things, fixes bugs, breaks other things, opens websites, gives explanations, runs commands, creates tasks, and suddenly you are trying to understand a whole project through terminal text, folders, errors, and random chat history.

That can be overwhelming, especially if you do not come from a coding background.

So I started building a more visual way to manage AI-built projects.

The Termi Protocol is a cozy 3D workspace where your AI coding agents become little robot helpers inside a room.

Each agent has its own desk, command center, task board, memory, and visible activity.

When an agent writes code, it sits at its desk and types while the real terminal output appears on its monitor. When it reads a file, it walks to a cabinet and scans papers. If a bug appears, it can show up as a little bug walking around the room, and you can click it to inspect the related error.

It sounds playful, but the goal is practical.

I wanted to make AI coding easier to follow for people who do not want to stare at terminal tabs all day.

You can see what the agent is doing, which task it is working on, what changed, which files were touched, which websites it visited, why it visited them, where that information was used, and what needs your attention next.

There is a todo system where you can add or remove tasks before the AI continues, so you are not just letting it run blindly.

There are checkpoints, so if the AI goes in the wrong direction, you can roll back instead of losing everything.

There is history and memory, so you can understand what happened without trying to reconstruct the whole project from terminal scrollback.

There is token and status tracking, so you can see how much each agent is using.

Multiple agents can also work on the same project, and the system helps keep their actions organized in one shared workspace.

Then I added the cozy side because building with AI should not feel scary or boring.

You can decorate the room, add pets, toys, sticky notes, a whiteboard, day and night mode, rain, background sounds, and small interactions. I wanted it to feel less like fighting a complex IDE and more like managing a tiny creative studio.

For people with no coding background, I think the biggest value is this:

You do not have to understand every line of code immediately to stay in control of the project.

You can still understand the workflow, the tasks, the changes, the bugs, and the direction.

That is the part I care about most.

The goal is not to replace learning. The goal is to make building with AI less intimidating and more manageable.

I’m curious what people here think.

Would a visual, gamified workspace make AI coding easier for non-coders?

Or do you prefer keeping everything inside the AI chat, terminal, and normal file explorer?

Hi everyone,

I wanted to ask other AI coders something.

When you use Claude Code, Codex, Gemini, or other AI coding agents, do you ever feel like the workflow becomes hard to follow?

For me, the problem was not only coding. It was management.

The agent reads files, changes scripts, visits websites, writes code, gets stuck, fixes bugs, burns tokens, continues tasks, and sometimes goes in a direction I did not expect.

But most of that activity is hidden inside terminal text.

So I started experimenting with a more visual and gamified way to manage AI coding workflows.

The idea is to turn the project into a small interactive workspace instead of only a terminal window.

Each agent appears as a small worker in a 3D room with its own desk and command center. When it writes code, it types at the desk. When it reads files, it walks to a cabinet and scans documents. When a bug appears, it can show up as a little bug in the room, and you can click it to inspect the related error.

The goal is not just to make it cute.

The goal is to make the workflow easier to understand at a glance.

I want to see what the AI did, which files it touched, what changed, why it changed something, which websites it visited, where that information was used, how many tokens it spent, and what it is planning to do next.

There is also a task system where you can add or remove tasks before the agent continues. Multiple agents can work on the same project, and their actions can be tracked from one shared history.

On the gamification side, I added things like room customization, agent desks, pets, toys, day and night mode, visual bug feedback, leaderboards, and small interactions around the workspace.

I also like the idea of making project management feel more like running a tiny dev studio. Instead of constantly switching terminal tabs, you can look at the room and understand who is working, who is idle, who is stuck, and what needs your attention.

I am curious how other AI coders think about this.

Would a gamified workspace make AI coding agents easier to manage for you?

Or do you prefer keeping everything in a traditional terminal and dashboard?

I run Claude Code and Codex every day, usually two or three agents at the same time.

For months, my actual job was basically tab cycling. Start an agent, alt-tab away, forget about it, then come back and realize it had been waiting 40 minutes for a simple yes or no.

My calendar said deep work. My hands were doing terminal surveillance.

What changed that for me was building a weird little app around it.

Now my agents are robots in a 3D room on my second monitor. I know how that sounds, but it actually works like a status board I can understand at a glance.

A robot typing means it is coding. A robot digging through a filing cabinet means it is reading files. A robot sitting still means it is waiting on me.

The glance replaced the check.

Next to the room, there is a panel I call the command center. Each agent gets one, and that is where most of the time savings happen.

The tab I use most is tasks. The agent maintains its own todo board while it works, marks things as done or in progress, and I can add or remove tasks without interrupting the run. I check the board instead of scrolling through terminal output.

The second most used tab is checkpoints. Every agent snapshots its work, so before I let one touch something risky, I know I can diff the changes and roll everything back. That is the feature that finally let me leave the desk.

The status tab shows which model an agent is using and how much of my 5-hour and weekly limit is left. That helps me plan the heavy refactors for when I actually have quota, instead of getting throttled halfway through a session.

Activity shows what each agent costs in tokens, which quietly changed which jobs I give to which model.

Memory is the tab I open when I come back two days later and cannot remember why something changed. It keeps the history of what the agent did and why, including which sites it visited while researching.

There is also a skills tab where I attach one skill to one agent to keep each robot focused and cheap, a commands tab with one-tap actions that I honestly barely use, and a built-in code editor for the moments when it is faster to fix one line myself.

And the terminal is still right there. The real one. I can click in and type whenever I want, or drop instructions and screenshots into the message box under it.

The thing that finally killed the checking habit was approvals.

When an agent needs permission, a card pops up over its desk with allow and deny. If I am in another app, I get a normal system notification. I stopped checking on them because I no longer have to.

The silly stuff also earns its place. There is a Pomodoro timer on the room wall, so I run focus sprints while the robots work. Between sprints, I throw a stress ball at the wall.

Cheaper than doomscrolling.

I built this for myself first, and it turned into a desktop app called The Termi Protocol.

The ideas transfer even without the app though: second screen for agent state, notifications instead of checking, snapshots before risky runs.

The one thing I still have not fully solved is the 5 to 10 minute gap while an agent is running.

What do you usually do during those stretches?

https://termiprotocol.com

Hey everyone, I'm a solo indie dev and I've spent the better part of this

year building The Termi Protocol, a cozy 3D room your CLI coding agents live

and work in. I'd love your honest take on it.

Instead of watching Claude Code or Codex scroll by as text in a black

terminal tab, each agent gets a little robot with its own desk, and the room

mirrors what it's really doing, live. It sits somewhere between a dev tool

and Animal Crossing. What it does:

The mirror: nothing is a canned animation. When an agent reads a file, its

robot walks to the filing cabinet and digs through it. When it writes

app.tsx, the code streams onto its little monitor while the robot types.

npm install makes digit rain fall into a book. All of it is driven by the

agent's real activity.

Terminal: every robot's screen is a real shell. Click in and type whenever

you want to take over, and if you close the app, Claude agents resume their

exact conversation when you come back.

Messages: talk to the agent, paste screenshots, drag files in straight from

the file tree.

Tasks: a live todo board the agent maintains itself, marking work done, in

progress or up next. You can add or remove tasks while it works. Run several

agents and sync mode gives them one shared board with file locks, so two

robots never edit the same file at once. A graph view shows what they tell

each other.

Memory: everything an agent remembers, searchable, plain or semantic, with

receipts. Which file it grabbed and why, which websites it visited while

building, and which script that research ended up in.

Checkpoints: every agent snapshots its work, so when one goes off the rails

you diff and roll back. Git worktree isolation is handled here too.

Git tree: hit analyze and a small local model explains the diff between two

versions, so comparing scripts costs no tokens.

Activity and status: tokens burned and cost per agent, plus how much of your

5 hour and weekly limits are left. Checking it doesn't spend anything.

Skills: attach a skill to a specific agent with one click. It focuses the

agent and visibly cuts token cost.

Approvals: when an agent needs a yes or no, it doesn't blink in a tab you

forgot about. A card pops up over its desk with allow and deny, and you get

a native notification if you're in another app.

Code: a built in editor for when you'd rather type it yourself. Your manual

edits land right next to the agent's.

The room: this is the cozy part. Pick a palette, drag furniture in from a

catalog, adopt a pet you have to feed, throw a stress ball that really

bounces off the furniture. Sticky notes, a whiteboard you can draw on, a

pomodoro timer, a day and night cycle with occasional rain. Every project

gets its own room, and the room grows as you add agents.

The point is that your work stays on your Mac. Agents run in real local

shells under your own accounts, and their memory, boards and checkpoints are

plain files in a local folder. The semantic search and the diff analysis run

small local models. The only network traffic is your agents talking to their

own models.

Full honesty for this sub: it's Electron, because the whole app is a live

Three.js scene. It actually started as a web app, then Claude Code itself

suggested the desktop port and wrote most of it, over 90% of this project is

Claude's code on Opus 4.8. macOS first, a Windows build exists too. The app

is paid, you bring your own coding agent and your existing AI subscription,

it never resells tokens.

It's early and moving fast, updates land often and some things will break

along the way. Honest feedback is exactly what helps me fix and prioritize.

Download: https://termiprotocol.com

A year ago I built a small web app where people could create personal message pages for birthdays, New Year, Valentine’s Day and similar special days.

It was a simple idea. Someone would create a page, add a message, maybe upload a few photos, then share the link with friends.

At the beginning almost nobody was using it. Maybe 40 or 50 people a day. Because of that, I did not think too much about the backend or storage costs. I was using Firebase and it was enough for that stage.

Then one day an influencer shared their own link in an Instagram story.

Everything changed in a few minutes.

I started seeing thousands of users coming in at the same time. I remember the active users jumping to around 2,000 or 3,000 and it kept growing. The app was not ready for that kind of traffic, especially because people were uploading and viewing a lot of photos.

The painful part was not only the traffic. It was the images.

Most uploads were JPG and PNG files. They were large, and serving them at that scale through Firebase started getting expensive very fast. At one point the daily cost could have gone to something like $300 or $400 if I had kept the same setup.

So I had to fix it quickly.

I moved the image storage away from Firebase and started using Cloudflare R2. I also converted uploaded images to WebP and reduced image sizes before storing them.

That one change made a huge difference.

Even when the app reached around 50,000 users in a day, the cost became much more manageable. It dropped to around $50 per day instead of hundreds.

The project eventually lost momentum and I paused it, but that experience taught me a lot.

The biggest lesson for me was this:

If your app allows users to upload images, do not treat storage as a small detail.

Firebase helped me move fast in the beginning, but once the product became image heavy, Cloudflare R2 and WebP saved me.

Has it ever happened to you in the past where you put off the backend implementation until later, only to face a situation where costs skyrocketed unexpectedly? :)

I don’t think so, but we do need to accept that some things have changed. The app name and keyword field are still critically important. However, if we want to expand across more channels, we also need to pay attention to Apple Events. You can think of it like a fan opening up in different directions.

The best part about Apple Events is that, unlike keywords, they offer a more flexible space. Let’s say you are targeting a specific keyword. If you remove that keyword from your keyword list, you may lose your ranking for it, and that can affect your app in the long run.

That’s why you shouldn’t blindly rely on the app name and keyword list, or leave them entirely to AI. Instead, you can use tools like Appfigures or AppTweak. Based on my own experience, AppTweak is stronger in this area. You can also benefit from AI, but you’ll get much better results if you give it clear goals and ask it to analyze based on those goals.

Also, every time you get a download, you start moving up for the keywords you are targeting. That’s why, in the long run, you should consistently promote your app on social media to distribute it and make it more visible. This could be Reddit, Instagram, or TikTok. It makes more sense to focus on whichever platform you understand and use best.

In reality, this whole process is a lot like planting a tree and helping it grow. If you don’t water it, the tree cannot grow. Over time, it may even die. Organic growth works the same way. It requires patience, consistency, and the right kind of care.

I don’t think so, but we do need to accept that some things have changed. The app name and keyword field are still critically important. However, if we want to expand across more channels, we also need to pay attention to Apple Events. You can think of it like a fan opening up in different directions.

The best part about Apple Events is that, unlike keywords, they offer a more flexible space. Let’s say you are targeting a specific keyword. If you remove that keyword from your keyword list, you may lose your ranking for it, and that can affect your app in the long run.

That’s why you shouldn’t blindly rely on the app name and keyword list, or leave them entirely to AI. Instead, you can use tools like Appfigures or AppTweak. Based on my own experience, AppTweak is stronger in this area. You can also benefit from AI, but you’ll get much better results if you give it clear goals and ask it to analyze based on those goals.

Also, every time you get a download, you start moving up for the keywords you are targeting. That’s why, in the long run, you should consistently promote your app on social media to distribute it and make it more visible. This could be Reddit, Instagram, or TikTok. It makes more sense to focus on whichever platform you understand and use best.

In reality, this whole process is a lot like planting a tree and helping it grow. If you don’t water it, the tree cannot grow. Over time, it may even die. Organic growth works the same way. It requires patience, consistency, and the right kind of care.

Hi everyone,

I want to add my Product Hunt page link to my website and also display my Product Hunt ranking, upvotes, or a badge such as “#1 Product of the Day.”

What is the best way to do this? Is there an official Product Hunt badge, embed code, or API that I should use?

If anyone has done this before, I’d really appreciate examples, tools, or code snippets.

Thanks!

I think my cat is copying me. I love getting massages from family members, and he's taking me as an example :D Look how much she enjoys it while getting a massage!