OpenClaw for Coding: Fix Bugs & Open PRs by Phone

Developer Workflow Covered: This guide explains how to set up OpenClaw to autonomously run Claude Code sessions, respond to Sentry error alerts, run test suites, and open GitHub PRs — all triggered from a Telegram message on your phone while you're away from your desk. Includes real setups from X.com developers and required network configuration.

In January 2026, developer @nateliason posted something that stopped the tech community in its tracks: "Yeah this was 1,000% worth it. Separate Claude subscription + Claw, managing Claude Code / Codex sessions I can kick off anywhere, autonomously running tests on my app and capturing errors through a Sentry webhook then resolving them and opening PRs... The future is here."

This wasn't a demo. This was a real production workflow. And it represented something that developers have dreamed about since the dawn of version control: an AI that can actually close the loop — detect an error, understand the codebase, write a fix, run the tests, and open a PR — completely autonomously, while you're walking your dog or sleeping.

@php100 confirmed the same: "Autonomous Claude Code loops from my phone. 'fix tests' via Telegram. Runs the loop, sends progress every 5 iterations." And @conradsagewiz: "I'm literally on my phone in a telegram chat and it's communicating with codex cli on my computer creating detailed spec files while out on a walk with my dog. Wtffff"

This guide breaks down exactly how this works, how to set it up, and why your network connection is the critical infrastructure that makes autonomous remote coding reliable enough for production use.

How the Autonomous Coding Stack Works

Understanding the architecture is key to appreciating why this works — and what can go wrong. Here's the complete stack:

Your Phone (Telegram/WhatsApp)
        ↓  "fix the auth bug"
OpenClaw AI Agent (running on your computer 24/7)
        ↓  interprets intent, plans execution
Claude Code CLI (spawned as subprocess)
        ↓  reads codebase, writes fix
Test Runner (npm test / pytest / jest)
        ↓  validates the fix
GitHub CLI (git commit, push, gh pr create)
        ↓  opens PR with description
OpenClaw Agent
        ↓  "PR opened: github.com/you/repo/pull/42"
Your Phone (notification arrives)

The magic is in OpenClaw's role as the orchestrator. It doesn't just run Claude Code blindly — it manages the session, monitors progress, handles errors, and communicates back to you. You're the decision-maker; OpenClaw is the executor.

~5 min

Average simple bug fix time

0 clicks

Manual operations needed

24/7

Runs while you sleep

Complete Setup Guide: OpenClaw + Claude Code + GitHub

Here's the complete setup to replicate what @nateliason and others have built. This assumes you have OpenClaw installed and a basic Telegram integration working.

Phase 1: Install Claude Code and Authenticate

npm install -g @anthropic-ai/claude-code
claude-code auth login
# Verify it works
cd your-project && claude-code "explain the auth module"

Test Claude Code standalone first. Make sure it can read your codebase, understand the structure, and make basic edits before automating it through OpenClaw.

Phase 2: GitHub CLI Authentication

gh auth login
gh auth status
# Test PR creation
gh pr create --title "test" --body "test" --draft

The GitHub CLI is what allows OpenClaw to create branches, push code, and open pull requests autonomously. Authenticate it and test the flow manually first.

Phase 3: Create the Coding Orchestration Skill

In your OpenClaw Telegram chat, ask it to create a coding skill:

You: "Create a skill that can run Claude Code on my repo at ~/projects/myapp,
run the tests after any changes, and open a GitHub PR if tests pass.
Send me progress updates every 5 iterations."

OpenClaw will write this skill itself, test it, and install it. The self-extending capability means you describe the workflow in English; it handles the implementation.

Phase 4: Connect Sentry Webhooks (Optional but Powerful)

This is what @nateliason uses. When Sentry detects an error, it fires a webhook to your OpenClaw:

# In Sentry: Settings → Integrations → Webhooks
# Add your OpenClaw webhook URL
# OpenClaw receives the error, reads the stack trace,
# kicks off Claude Code to fix it automatically

This creates a fully closed loop: error detected → AI reads stack trace → finds root cause → writes fix → runs tests → opens PR → notifies you on Telegram. The entire cycle can happen in under 15 minutes without you touching a keyboard.

Real Developer Workflows From the Community

The OpenClaw developer community has developed fascinating variations on autonomous coding. Here are the most impressive real-world setups:

The Sentry-to-PR Pipeline

Used by @nateliason and dozens of backend developers

Sentry error → OpenClaw receives webhook → Claude Code reads error + codebase → writes fix → runs tests → opens PR with "Fix: [error description]" title. Developer reviews and merges when ready. No manual debugging step.

Time saved: 2-4 hours per bug → 15 minutes including review. Especially valuable for recurring error patterns.

The Phone Walk Spec Writer

Used by @conradsagewiz

"I'm literally on my phone in a telegram chat and it's communicating with codex cli on my computer creating detailed spec files while out on a walk with my dog." The use case: voice-to-text in Telegram describing a feature, OpenClaw translates to a detailed technical spec document, saves it to the codebase for implementation later.

Best for: Product thinking on the move. Capture ideas with full context before they fade.

The Iterative Test Fixer

Used by @php100

Send "fix tests" to Telegram. OpenClaw spawns Claude Code, runs the test suite, reads failures, writes fixes, runs tests again, repeats until all pass or a maximum iteration limit is reached. Gets progress updates every 5 iterations. When done, reports: "All 47 tests passing. PR created."

Best for: Friday evening deploys. Let it fix the test suite overnight, review the PR Saturday morning.

The Documentation Auto-Writer

Popular among solo developers and small teams

Send "update docs for the new API endpoints I added today." OpenClaw reads git diff to understand what changed, reads existing documentation style, writes new documentation sections, opens a PR for review. Documentation stays up-to-date without the pain.

Best for: API documentation, README updates, changelog generation. Every developer's least favorite task, fully automated.

Safety and Best Practices for Autonomous Code Changes

Running AI that autonomously modifies your codebase requires some guardrails. The OpenClaw community has learned these lessons through experience:

Always-On Best Practices

✓ Work on feature branches, never main directly
✓ Require tests to pass before PR creation
✓ Set iteration limits (max 10 Claude Code loops)
✓ Require human review before merging
✓ Log all autonomous actions for audit trail
✓ Use read-only GitHub tokens for analysis tasks

Common Pitfalls to Avoid

✗ Never grant production database access
✗ Don't skip test validation before PRs
✗ Don't let it force-push to protected branches
✗ Avoid unlimited iteration loops (cost risk)
✗ Don't expose API keys in task descriptions
✗ Don't skip code review for security-sensitive changes

🛡️ The OpenClaw Security Principle

OpenClaw's approach is "least privilege by default." You explicitly grant each capability. The AI doesn't have access to your production database unless you specifically authorize it. Each skill has defined boundaries. This makes autonomous operation safe — the agent can only do what you've allowed.

The Critical Network Layer: Why Your VPN Matters

Autonomous coding with OpenClaw creates a unique network challenge. Your OpenClaw instance needs to:

Claude/OpenAI API

High-frequency calls, needs consistent latency

GitHub API

Rate limits sensitive to IP reputation

Telegram Long Poll

Needs persistent connection, no interruptions

When you're away from home — traveling, at a coffee shop, in a hotel — your network environment changes. Geographic IP restrictions can block Claude API calls. Shared WiFi can interrupt Telegram's persistent connection. New IP addresses can trigger GitHub's rate limiting.

This is why serious OpenClaw developers run their agents through VPN07. Your OpenClaw instance always connects through the same trusted IP, in a datacenter with 1000Mbps bandwidth, whether your laptop is in Berlin or Bangkok. The API calls always work. The Telegram connection stays alive. GitHub never sees a suspicious new IP.

VPN07: The Developer's Network Foundation

🥇

VPN07 — Top Choice for Autonomous AI Development

9.9/10 — #1 for AI Developer Workflows

1000Mbps

Raw Bandwidth

70+

Country Nodes

10 Yrs

Operational

$1.5/mo

Developer Plan

VPN07 has been the preferred network solution for serious developers for a decade. With 1000Mbps bandwidth, your Claude Code sessions never throttle. With nodes in 70+ countries, you can set a consistent API request origin regardless of your physical location. The 10-year track record means no unexpected service shutdowns disrupting your autonomous coding pipeline.

2. Alternative Provider B

6.8/10

Reasonable speeds but inconsistent latency spikes. Claude API calls occasionally timeout. Poor choice for unattended overnight coding sessions.

3. Alternative Provider C

5.5/10

Bandwidth limits cause throttling during intensive Claude Code sessions. Not recommended for heavy API usage patterns.

Advanced: Building Your Autonomous Dev Pipeline

Once the basics work, here's how to build a genuinely powerful autonomous development pipeline:

🔴 Level 1: Reactive Bug Fixing

Manual trigger via Telegram. "Fix the login timeout bug." OpenClaw finds the bug, writes fix, runs tests, opens PR. You review and merge. Time: 5-10 minutes vs 30-90 minutes manually.

🟡 Level 2: Webhook-Triggered Automation

Sentry → OpenClaw webhook. Errors auto-trigger fix attempts. You only get notified when a PR is ready for review. Most bugs get fixed before you even know they happened.

🟢 Level 3: Scheduled Code Health

Nightly cron: run full test suite, fix any regressions, update dependencies, check for security vulnerabilities, generate coverage report. Wake up to a healthy codebase every morning.

⚡ Level 4: Full Autonomous Sprint

Break a feature into tasks, assign them to OpenClaw, go on vacation. It works through the sprint: reads specs, writes code, tests, PRs, reviews its own work, iterates. You return to a completed feature. This is what @nateliason is building toward.

Cost Analysis: Is Autonomous Coding Worth It?

Let's be honest about costs. Autonomous coding with Claude Code isn't free. Here's a realistic cost breakdown for a typical solo developer:

Component	Monthly Cost	Notes
Claude API / Max subscription	$20-100	Depends on usage intensity
OpenClaw	Free	Open source
VPN07 (required for reliability)	$1.5	Non-negotiable for remote use
Your time saved (at $100/hr)	$800-2000	8-20 hours of debugging, docs, etc.

The math is overwhelmingly positive. Even if you use Claude's most expensive tier at $100/month, plus VPN07 at $1.5/month, you're looking at a $101.50 monthly investment that saves 10-20 hours of tedious debugging, documentation, and maintenance work. That's 10-20x ROI on time alone — before accounting for the fact that your code quality improves and production errors get fixed faster.

The developers who've adopted this workflow consistently report the same thing: after two weeks, they can't imagine going back to manually debugging every issue and writing every PR description themselves. The cognitive overhead drops dramatically. The creative, architectural work increases. It's not replacing developers — it's making them dramatically more effective.

Choosing the Right AI Model for Autonomous Coding

One nuance that experienced OpenClaw developers have discovered: not all AI models are equally suited for autonomous coding. Here's a practical breakdown based on community testing:

Claude 3.5 Sonnet

Best for: general coding tasks, bug fixes, documentation. Fast and cost-effective for high-volume automated tasks.

Recommended for most teams

Claude Opus 4.6

Best for: complex architectural decisions, security-sensitive changes, large refactors requiring deep reasoning.

Use for high-stakes tasks

Local Models (Ollama)

Best for: sensitive codebases where you can't send code to external APIs. Lower quality but fully private.

Use for confidential code

The flexibility to choose models per-task is one of OpenClaw's architectural advantages. You can configure Sonnet for routine test fixes (cheap and fast) and Opus for the security audit (thorough and careful). Over time, you develop an intuition for which tasks warrant which investment — and OpenClaw's cost reporting helps you optimize the balance.

VPN07: Reliable Foundation for Autonomous Dev

1000Mbps · 70+ Countries · 10 Years Trusted

Keep your OpenClaw coding pipeline running flawlessly from anywhere. VPN07's 1000Mbps bandwidth ensures Claude Code never throttles, GitHub API calls always complete, and your autonomous PRs land even while you're traveling.