Imagine you’re at a coffee shop, your laptop buried in your bag, and a Slack message pings: “Production is throwing 500s on the checkout endpoint.” You pull out your phone, open Telegram, and type: “Check the logs for the checkout service, find the error, fix it, run the tests, and open a PR.” Five minutes later, without touching a keyboard, there’s a green-checked pull request waiting for review. This is what it means to code with OpenClaw — and it’s changing how developers think about where and when work happens.
OpenClaw is an open-source, self-hosted gateway that connects messaging apps like Telegram, WhatsApp, Discord, and iMessage to AI coding agents — most notably Claude Code from Anthropic. It turns your phone into a remote terminal for an AI that can read your codebase, write files, run shell commands, execute tests, and push commits. All through natural language messages.
This isn’t a toy demo. Developers are shipping real features, fixing real bugs, and managing real deployments from their phones every day. Let’s break down exactly how the workflow operates — and where it still falls short.
What Is OpenClaw and Why Should You Care?
OpenClaw runs as a single Gateway process on your machine or server. It acts as a bridge: messages come in from your chat app, get routed to an AI agent (like Claude Code running in a sandboxed environment), and the agent’s responses stream back to your phone. The agent has access to your filesystem, terminal, and browser — everything a developer sitting at the desk would have.
The key architectural decisions that make this work:
- Self-hosted: Your code never leaves your infrastructure. The Gateway runs on your hardware, your rules.
- Multi-channel: One Gateway serves WhatsApp, Telegram, Discord, and more simultaneously. You pick the app you already use.
- Agent-native: Built specifically for coding agents with tool use, persistent sessions, memory across conversations, and multi-agent routing.
- Open source: MIT licensed. You can inspect every line of code that touches your repo.
Setup takes about five minutes: install Node 22+, run npx openclaw, connect your Anthropic API key, and link a Telegram bot via the quickstart guide. That’s it. You now have an AI coding assistant in your pocket.
The Developer Workflow: How to Code with OpenClaw from Your Phone
Here’s what a typical session looks like in practice. You’re away from your desk — commuting, walking the dog, sitting in a waiting room — and you need to get something done.
Starting a Feature
You open Telegram and message your OpenClaw bot:
“Create a new branch feature/user-avatars. Add an avatar upload endpoint to the user service. Accept PNG and JPEG, max 2MB, store in S3, and save the URL to the user profile. Write tests. Don’t merge — just open a draft PR.”
Claude Code receives this, understands the codebase context (it has access to the full repo), and starts working. It will:
- Create and checkout the branch
- Read the existing user service code to understand patterns and conventions
- Write the new endpoint following your project’s style
- Add input validation, error handling, and S3 integration
- Write unit and integration tests
- Run the test suite to verify nothing is broken
- Commit with a meaningful message
- Push and open a draft PR on GitHub
You get progress updates in Telegram as it works. The whole thing takes a few minutes. You review the PR diff on your phone’s GitHub app, leave a comment or two, and move on with your day.
Fixing Bugs in Production
This is where the workflow really shines — the “holy shit” moment most developers experience the first time. A bug hits production. You’re at dinner. Normally this means excusing yourself, finding your laptop, SSHing in, reading logs, tracking down the issue — a 30-minute interruption minimum.
With OpenClaw, you type into Telegram:
“Check the last 50 lines of the API error log. What’s causing the 500s on /api/v2/checkout?”
The agent reads the logs, identifies the issue (say, a null reference from a recent migration that didn’t backfill a column), and reports back. You reply:
“Fix it. Add the missing default value to the migration and backfill existing rows. Run the test suite. If green, deploy to staging.”
Done. You’re back to dinner in under three minutes. The fix is on staging, tests are passing, and you can do the production deploy when you’re comfortable — or tell the agent to do that too.
Running Tests and CI Workflows
One of the most common phone-based interactions is simply running tests and checking results:
“Run the full test suite on the main branch and tell me if anything is failing.”
“The lint CI check is failing on PR #247. Fix the lint errors and push.”
“Run the database migration on the staging environment and verify the schema looks correct.”
Each of these would normally require opening a terminal, navigating to the right directory, running the right commands, and interpreting the output. From your phone, it’s a single message.
Real-World Examples: What People Are Building via Telegram
The developer community around OpenClaw has been sharing some remarkable use cases:
- Full-stack app features from the gym: One developer described building an entire user authentication flow — registration, login, password reset, email verification — across a 45-minute workout session. Each set break was a new message to the agent.
- Autonomous code loops: Users trigger multi-iteration coding loops by sending “fix tests” via Telegram. The agent runs the loop, attempts fixes, re-runs tests, and sends progress updates every five iterations until everything passes.
- Documentation generation: Asking the agent to read through a codebase and generate comprehensive API documentation, README files, or architecture decision records — tasks that are important but always get deprioritized.
- Refactoring sessions: “Refactor the payment service to use the new event-driven architecture we discussed. Follow the pattern in the order service.” The agent reads both services, understands the pattern, and applies it consistently.
- DevOps from anywhere: Checking server health, scaling containers, reviewing deployment logs, rolling back bad releases — all from a chat message.
The Technical Architecture: How Messages Become Code Changes
Understanding what happens under the hood helps you trust (and debug) the system:
- Message ingestion: Your Telegram message hits the OpenClaw Gateway via the Telegram Bot API webhook.
- Session routing: The Gateway identifies your session (persistent per user), loads conversation history and memory, and routes to the configured agent.
- Agent execution: Claude Code receives the message with full context — your conversation history, the
AGENTS.mdpersonality file, tool access, and workspace context. - Tool use: The agent uses tools to read files, execute shell commands, write code, run tests, interact with Git, and more. Each tool call is logged and auditable.
- Response streaming: Results stream back through the Gateway to your Telegram chat. Long operations send intermediate updates so you know progress is being made.
The Gateway also handles safety features: command approval flows for destructive operations, allowlists for who can message the bot, and mention-based triggering in group chats.
Remote Coding Automation: Setting Up Your Own Workflow
Getting started with this kind of remote coding automation takes minimal configuration:
- Install OpenClaw:
npx openclawon any machine with Node 22+. - Connect your LLM: Add your Anthropic API key for Claude Code (or configure Gemini, OpenAI, or local models).
- Create a Telegram bot: Message
@BotFatheron Telegram, create a new bot, and paste the token into OpenClaw’s setup wizard. - Configure your workspace: Point the agent at your code repository. Customize
AGENTS.mdto define the agent’s personality, permissions, and coding conventions. - Set up safety rails: Configure
allowFromto restrict who can message the bot. Set up approval flows for destructive commands.
The entire setup process takes five to ten minutes. After that, every message to your Telegram bot becomes a coding command.
Limitations: What Still Needs a Human at the Keyboard
Let’s be honest about where this workflow breaks down — because understanding the limitations is just as important as knowing the capabilities.
Complex Architectural Decisions
The agent is excellent at implementing well-defined features and following established patterns. It struggles with ambiguous, high-level architectural decisions that require understanding business context, team dynamics, and long-term technical strategy. “Should we migrate to microservices?” is not a Telegram message that will produce a good outcome.
Code Review Still Matters
AI-generated code needs human review. Period. The agent can write clean, functional code that passes tests — but tests only verify what you thought to test. Edge cases, security implications, performance characteristics under load, and subtle logic errors all benefit from human eyes. Use the phone workflow to create PRs, not to merge them blindly.
Large-Scale Refactoring
Changes that touch dozens of files across multiple services can exceed the agent’s context window or lead to inconsistencies. For large refactors, it’s better to break the work into smaller, phone-sized chunks: “Refactor the user service first. I’ll review, then we’ll do the order service.”
Debugging Complex State Issues
Some bugs require interactive debugging — setting breakpoints, inspecting state at runtime, stepping through execution. While the agent can add logging and analyze output, it can’t replace the experience of a developer in a debugger with a hypothesis.
Visual UI Work
Reviewing how a UI change actually looks requires seeing it rendered. The agent can write CSS and component code, but verifying visual correctness from a Telegram chat is inherently limited. Screenshots can help, but rapid visual iteration is better done at a desk.
The AI Coding Assistant That Lives in Your Pocket
The shift OpenClaw represents isn’t really about coding from your phone. It’s about removing the friction between having an idea and executing on it. The phone is just the most dramatic example of that — the moment you realize you can ship a feature from a park bench, something clicks about how AI changes the developer workflow.
Traditional development requires synchronizing three things: the developer, the computer, and the right mental context. OpenClaw collapses these requirements. The computer is always available (your server is running). The AI agent maintains context across sessions. And you — the developer — just need enough mental bandwidth to describe what you want in plain English.
This doesn’t replace deep, focused programming sessions. It augments them. The phone workflow handles the 60% of development tasks that are well-defined, pattern-following, and executable: bug fixes, feature implementations following existing patterns, test writing, documentation, deployment, and routine maintenance. That frees your focused desk time for the 40% that genuinely requires deep thought.
If you’re a developer who hasn’t tried coding through a messaging app yet, set aside ten minutes to get OpenClaw running. Send your first “fix the tests” message from your phone. Watch the agent work. That first time — when you see a commit appear on GitHub from a Telegram message you sent while standing in line at the grocery store — you’ll understand why developers who’ve tried this can’t go back.
The future of development isn’t about where you sit. It’s about what you can describe. And with OpenClaw, you can describe it from anywhere.
