I Left for Three Days. My Laptop Didn't.

I packed a bag, closed the laptop lid — but not the laptop itself — and left for three days.

Before I walked out, I gave my AI coding agent one real task. Not a toy. Actual code, actual commits.

I didn't sit there and watch it work. I couldn't — I was gone. So I steered it from my phone instead, over Telegram, and came back to finished work.

Here's the shift, and how you can set up the same thing.

---

Real work used to mean sitting there for hours. Watching the cursor. Babysitting the process. If you weren't at the desk, the work wasn't happening.

That's the assumption I broke.

An AI coding agent (I use Claude Code) can run a task on its own — read the files, make the change, test it, commit it. The part everyone still gets wrong is thinking you have to sit there and supervise it line by line.

You don't. You just need a way to talk to it when you're not at the desk.

---

Three pieces, nothing exotic:

1. The agent session — running on my laptop, given one real task before I left.
2. A Telegram bridge — a small relay that pulls my texts and forwards them to the agent, then sends its replies back to my phone.
3. The commits — the agent ships its own work back to the repo as it goes, so progress is never sitting only in a chat window.

So the loop looks like this: I text it what to fix. It works. It commits the code back. If it needs a decision only I can make, it asks — and waits for my reply before doing anything it isn't sure about.

I check my phone. There's the work, done.

---

I'm not pretending the AI is unsupervised in some magic way. Here's what's actually true:

I steer intent. It does the work. I tell it what matters — what to fix, what to prioritize, what's out of scope. It doesn't invent the goal; I set that from my phone in a few texts.

I still review. Commits land in the repo, but I look at what shipped before I call it done. The bridge doesn't replace judgment — it replaces sitting at a desk to exercise that judgment.

Even I don't fully believe it works — and I built it. That's the honest reaction the first time you watch a text message turn into a real commit while you're three days away.

---

You don't need my exact setup. You need the same three pieces:

Start an agent task on your machine.
Give it one real, scoped task before you walk away — not "build me an app," something concrete it can make real progress on alone.

Wire up a Telegram bridge.
A bot (free, five minutes to create via Telegram's BotFather) that pulls your replies from a chat and relays them to the agent session, then sends its output back to you.

Let it commit as it goes.
Progress should land in your repo, not just in a chat log — so "done" means something you can actually look at when you're back.

That's the whole shape. One task, one bridge, one phone.

---

*Grab my five-minute phone-control setup, free — it's below.*

---

# The 5-Minute Phone-Control Setup

A free recipe for steering an AI coding agent from your phone — the same shape as the "I left for 3 days" video, sized down so you can wire it up yourself.

Three pieces. One rule. That's the whole thing.

---

1. An agent session on your machine
Whatever you're already using to run AI-driven coding tasks (Claude Code or similar). This is what actually does the work — reads files, makes changes, runs tests, commits.

2. A Telegram bot
Create one free via Telegram's BotFather — takes about five minutes. This is your phone's side of the conversation: it's where you type what you want fixed, and where the agent's updates land.

3. The relay
A small bridge that connects the two: it pulls your incoming texts and forwards them to the agent session, then takes the agent's output and sends it back to you as a Telegram message. This is the only "new" piece — everything else already exists.

---

Step 1 — Start the agent session.
Kick off your task on the laptop like you normally would, before you walk away from it. Give it something concrete and scoped, not vague.

Step 2 — Create the Telegram bot.
Message BotFather, name your bot, grab the token it gives you. Free, no approval wait.

Step 3 — Wire the relay.
Point the bridge at your bot token and your agent session. Its only job: incoming message → agent, agent output → outgoing message. Keep it that simple — resist adding features before the basic loop works.

Step 4 — Test it from your phone before you actually leave.
Send a small real instruction. Confirm you get a real reply and see the agent act on it. Don't trust it unattended until you've watched it work once.

Step 5 — Let it commit as it goes.
Make sure the agent's changes land in your repo, not just in the chat. That's what turns "a chat log" into "actual finished work" when you check back in.

---

It pulls your reply. You don't babysit it.

The bridge waits for your text — it doesn't guess what you want and it doesn't act without direction on anything that matters. You steer intent from your phone in short messages; it does the mechanical work and reports back. If it hits something it isn't sure about, it should ask and wait, not improvise.

That one rule is what makes this safe to walk away from. Skip it, and you've just built something that runs off and does whatever it wants — which is not what you want on a real codebase.

---

That's it. One task, one bot, one relay, one rule. Go set it up before your next trip.