Telegram is becoming my control plane for vibe coding

The IDE is where code changes. Telegram is where the loops run.

Telegram is becoming the control plane for vibe coding.

The IDE is where code changes. Telegram is where the loops run.

I know that sounds a little ridiculous. Coding is supposed to happen in an editor. You open Cursor, talk to the agent, review the diff, run the tests, and keep going until the thing works.

That was my workflow for a while too.

But after using coding agents every day, the split became hard to ignore. The place where code changes and the place where agents are managed do not need to be the same place.

The IDE still matters. Cursor matters. Claude Code matters. Codex matters. I still use all of them. But when agents start doing more of the work, I do not want to live inside the surface where the code is being edited. I want to manage the loop.

That is where Telegram started making more sense than I expected.

My coding interface kept changing

I have been vibe coding for about 6 years now.

I started with GPT-2 inside TabNine. Then GitHub Copilot brought GPT-3 into the editor. Then ChatGPT made coding conversational. Then Cursor moved the AI directly into the IDE. Then Composer made multi-file changes feel normal.

After that, the stack got strange. Claude Code, Codex, Cursor agents, cloud agents, loops, OpenClaw, Hermes, cron jobs, review agents, and software factories all became part of the workflow.

Each interface solved a different problem. Copilot made autocomplete useful. ChatGPT made coding conversational. Cursor made AI feel native inside the IDE. Composer made multi-file edits feel normal. Claude Code and Codex made agent execution feel real.

Hermes solved a different layer for me. It became the personal orchestrator above the coding tools, the thing I could teach, redirect, schedule, and use to coordinate other agents.

Telegram then became the interface I could actually live inside while managing that orchestrator from my phone.

That last part changed more than I expected.

The laptop assumption is still everywhere

Most AI coding tools still quietly assume the human is sitting in front of a coding interface.

That is true even when the agent is doing the work somewhere else, the tests are running on another machine, the branch was created by a background process, another agent is reviewing the output, and the only thing I need to do is approve, reject, or redirect a pull request.

The assumption is still simple: the human is at the desk.

That starts to feel wrong once you use agents seriously.

If an agent can create the branch, write the code, run the tests, inspect the failure, trigger review, and loop on fixes, why am I still forced to manage the system from a laptop?

That question pushed me toward Telegram.

Not because Telegram is a coding app.

Because Telegram gives me mobile context management for coding agents.

Telegram solves context for me too

People talk a lot about context management for agents.

They should. It matters.

But there is another context problem that gets less attention: the human's context.

When you are working across multiple projects, agents, repos, branches, terminals, cloud workers, and review loops, your own memory becomes the bottleneck. You forget which terminal had the important log. You forget which agent was working on which repo. You forget which thread had the decision. You forget whether the bug is still being investigated, already fixed, or waiting on your approval.

A good agent interface should help the model remember. A great one should help the human remember too.

Telegram does this weirdly well.

Folders become project areas. Groups become projects. Supergroups become workspaces. Topics become features, bugs, and experiments. Threads become isolated context. Agents report into the right place.

The whole system becomes glanceable from a phone.

That is the part I care about most. Mobile is not a convenience layer here. Mobile changes the workflow.

I can be away from my laptop and still understand what is happening. I can make judgment calls without reopening an IDE. I can keep work moving without remembering which machine, tab, terminal, branch, or chat window had the state.

The thread is the workspace. The group is the project. The phone is the control plane.

Hermes is the layer that makes this work

Telegram alone is not the system.

Telegram is the interface. Hermes is the orchestrator.

I use Hermes as my personal agent. I can teach it how I work, how I want projects managed, how to run loops, how to use cron jobs, how to route work to other agents, and when to escalate back to me.

The pattern usually looks like this:

1. I give direction in Telegram.
2. Hermes turns that direction into a loop.
3. Cron keeps the loop alive.
4. Poly agents coordinate the work.
5. Codex, Claude Code, Cursor, and other agents execute pieces of the task.
6. Review agents inspect the output.
7. The loop keeps going until the result is usable.
8. I get pulled in only when judgment is needed.

That creates a very different relationship with coding.

The old workflow was simple and exhausting: the human drives every step, reviews every line, catches every mistake, and keeps all the project state in their head.

The new workflow is closer to this: the human defines the goal, sets the boundaries, decides what good looks like, and reviews exceptions. The system does the execution work.

That is why I keep coming back to the word harness.

The best AI coding setup is not the smartest single agent. It is the harness around the agents.

The real skill is removing yourself from the loop

The skill required to work with AI agents is changing.

When the models were weaker, the skill was staying in the loop. You had to review every line because the models were brittle. You had to drive every step because the agents lost the plot. You had to catch every mistake because there was no reliable review loop behind them.

That is still true in some workflows.

But with the current models and current agent capabilities, the human often does not need to be inside every loop.

The agent can write the code, run the test, inspect the failure, ask another agent to review it, open the pull request, and try again when the review fails.

So the question changes.

It is no longer only: how do I prompt better?

It becomes: where am I still blocking the system for no good reason?

That question is uncomfortable.

Because removing yourself from the loop does not mean being careless. It means building a system that can operate without you babysitting every step.

That takes real engineering. You need clear goals, context boundaries, review paths, escalation rules, memory from past mistakes, and a way for agents to report progress without dumping noise everywhere.

You also need a way for the human to re-enter the loop at the right moment, not every moment.

Telegram works well for me because it gives that system a place to live.

Why this feels like a mobile ADE

We already have IDEs: Integrated Development Environments.

They were built around a developer writing, editing, navigating, debugging, and compiling code directly. That still matters.

But agent development needs another kind of environment.

An ADE.

Agent Development Environment.

Not just a place where code changes. A place where agent loops are managed.

On desktop, that might be a terminal, an IDE sidebar, a cloud dashboard, or a coding agent interface. On mobile, Telegram is the best version I have found so far.

It already has the primitives I need: project folders, persistent groups, topic based threads, notification control, search, media, files, voice messages, bots, human escalation, and multi-agent reporting.

None of those were designed specifically for coding agents. Put together, they form a surprisingly good mobile environment for managing them.

That is why Telegram feels less like a chat app in my workflow and more like a control plane.

The IDE is where the code changes. Telegram is where the loops run.

What people miss about this

The obvious reaction is: why not just use the agent UI?

Cursor has a UI. Codex has a UI. Claude Code has a terminal. Cloud agents have dashboards. Some of them even have mobile apps now.

I have tested that path.

The mobile apps help, but they still feel like thinner versions of the same agent product. You are usually inside one tool, one agent, one execution surface, or one task thread.

That is useful. It is not the same thing as managing the system above the agents.

My workflow is not one agent.

It is agents managing agents.

Hermes creates loops. Cron keeps those loops alive. Poly agents route work. Codex, Claude Code, Cursor, and other tools do execution. Review agents close the loop.

I step in when my judgment is needed.

A single-agent UI is not enough for that. A mobile app for one coding agent is still mostly a remote control for that one coding agent.

Hermes plus Telegram feels different because it gives me the layer above the agents.

Telegram gives agents clean context. It gives me clean context. It gives me groups, topics, files, voice, search, notifications, and now even streaming messages from agents in the same mobile surface I already use all day.

That is the UX difference for me.

It is not just mobile access to an agent. It is mobile context management for a whole agent system.

And maybe most importantly, it pushes me to think about software work as a system of loops instead of a sequence of prompts.

Where I think this is going

I think more AI coding work is going to move in this direction.

Not everyone will use Telegram. That is not the point.

The point is that the next important interface might not look like an IDE. It might look like a control plane: a place where the human defines goals, checks progress, approves exceptions, and manages agent loops from anywhere.

The IDE will still matter. The code has to change somewhere.

But the center of gravity is moving.

For me, it moved from writing code in an editor to managing loops from my phone. That changed how I think about AI coding as a skill.

The best setup is not the smartest model, the flashiest IDE, or the agent that writes the most code.

The best setup is the harness around the agents: the memory, the review loop, the escalation path, the context boundary, and the interface that lets the human stay free without losing control.

For me, right now, that interface is Telegram.