The Mobile Development Pipeline: Ideas Anywhere, Execution Everywhere
How we turned dead time into development time with AI-powered planning and execution
The Problem Everyone Ignores
The best development ideas always hit at the worst times.
Walking the dog. Airport delay with a dead phone battery. Waiting room between meetings. The shower (always the shower). Standing in line at the grocery store.
You have this moment of clarity. You see exactly how the feature should work, exactly which files need to change, exactly what the user experience should feel like. The solution is right there.
And then life happens.
By the time you get home, sit down at your computer, and open your IDE, the inspiration has faded. The context is gone. That crystal-clear vision is now a foggy memory of "something about buttons and agents."
So you do what we all do: start from scratch. Re-research the problem. Re-think the solution. Lose an hour just getting back to where you were mentally.
This is the dirty secret of development: We lose more features to context loss than we do to technical challenges.
The Vision: Capture Anywhere, Execute Seamlessly
What if the gap between "having an idea" and "implementing it" could shrink to zero?
Not "zero time"—you still need to do the work. But zero context loss. Zero re-research. Zero "what was I thinking?"
Here's what we wanted:
- -Mobile Idea Capture — Have an idea anywhere, capture it immediately
- -AI Research & Planning — The AI does the research, creates a complete implementation plan
- -Seamless Handoff — Walk in the door, say "execute the plan," watch it happen
- -No Context Loss — Every detail preserved, every decision documented
This isn't science fiction. We built it. And today, we proved it works.
What We Actually Built
The system has three components:
1. Milo (Mobile AI Assistant)
Milo is an OpenClaw assistant—our open-source framework for running persistent AI agents that can message you, remember context across sessions, and take actions on your behalf. We named this particular agent Milo, and he runs on Telegram so he's available anywhere with cell signal.
This is one of the workflows we're learning to build with OpenClaw: mobile AI assistants that can do real work, not just chat. When an idea strikes, we message Milo:
"I want to add a 'Copy to Agent' button to the id8Labs website. When users are reading about the workflows and techniques I'm experimenting with, they should be able to copy a prompt that helps them set up something similar with their own AI assistant."
That's it. No formal spec. No Jira ticket. Just the idea, in natural language.
2. The Plan Book (claude-plans/)
Milo doesn't just acknowledge the idea—he researches it. He:
- -Looks at similar features in the codebase
- -Researches UX patterns for the feature type
- -Identifies technical requirements
- -Creates a structured implementation plan
- -Writes it to a shared directory:
/Development/claude-plans/
The plan isn't a vague outline. It's a complete implementation guide with:
- -Context & Research — Why this feature matters, what UX patterns apply, strategic value for the business
- -Implementation Details — Exact files to modify, component architecture, state management approach
- -Success Criteria — How to verify the feature works, edge cases to test, acceptance requirements
3. Claude Code (Local Executor)
When I get home and sit down at my Mac, Claude Code is ready. The conversation goes like this:
Eddie: "Check Milo's plan book. There's a Copy to Agent feature waiting."
Claude: "Found it. 20260203-1020-copy-agent-button.md. Ready to implement. Should I proceed?"
Eddie: "Yes."
And it executes. No re-explaining. No context-setting. The plan has everything Claude needs.
A Real Example: The Copy to Agent Feature
This morning, I was walking my dog. No laptop. Just my phone and a leash.
I had an idea: visitors to the id8Labs website should be able to copy a prompt that helps them replicate the workflows and techniques I'm sharing. Instead of just reading about how I built something, they'd copy a pre-written prompt, paste it into ChatGPT or Claude, and have their own AI walk them through setting up something similar.
10:15 AM — Dog Walk
While my dog sniffed every tree in the neighborhood, I messaged Milo:
"Add Copy to Agent button to id8Labs. Users should be able to copy prompts that help them replicate the workflows and systems I'm sharing."
10:20 AM — Milo Responds
Milo didn't just say "got it." He started researching:
- -Looked at our product pages to understand the context
- -Researched "copy to clipboard" UX patterns
- -Considered button placement (inline vs. floating vs. sidebar)
- -Drafted the actual prompt content for each product
- -Identified which components needed modification
10:35 AM — Plan Created
By the time I got back to my apartment, a 6KB markdown file was waiting in claude-plans/:
20260203-1020-copy-agent-button.md
Complete with:
- -Button component specifications
- -Prompt content tailored to each workflow/article type
- -Placement recommendations (after product description, before CTA)
- -Accessibility considerations
- -Mobile responsiveness requirements
11:00 AM — Home
I walked in the door, opened my terminal, and said:
"Check Milo's plan book for the Copy to Agent feature."
Claude Code found it instantly. Read the plan. Asked one clarifying question about styling preference. Then implemented the feature.
Total time from idea to implementation: Less than 30 minutes of my active involvement.
The dog walk wasn't wasted—it was leveraged. Milo did research I would have had to do anyway. The plan preserved context I would have lost. The execution was seamless because nothing needed re-explaining.
The Technical Architecture
Here's how the pieces connect:
Mobile Phone (Telegram) → Milo (Cloud Agent) → claude-plans/ (Shared Dir) → Claude Code (Local Agent)
The flow is simple:
- -I send a natural language request from my phone
- -Milo researches and writes a structured plan
- -The plan lands in a shared directory on my machine
- -Claude Code reads the plan and executes it
File Naming Convention
Plans follow a strict naming pattern:
YYYYMMDD-HHMM-feature-name.md
Examples:
- -
20260203-0930-copy-agent-feature.md - -
20260203-1010-test-codex-integration.md - -
20260203-1020-copy-agent-button.md
This makes plans:
- -Sortable by creation time
- -Unique (no collisions)
- -Searchable by feature name
- -Traceable to when the idea happened
Plan Structure
Every plan follows the same format:
Header with Plan ID, Status (TODO/IN_PROGRESS/DONE), Assignable agents, and Priority level.
Context & Research explains why this feature matters, what problem it solves, and what patterns or prior art informed the approach.
Implementation Details specifies the exact files to create or modify, the component architecture, data flow, and any dependencies.
Success Criteria defines how we know the feature is complete—specific behaviors to verify, edge cases to test, and acceptance requirements.
Results gets updated after implementation with notes about what was built, any deviations from the plan, and lessons learned.
Multi-Agent Access
The beauty of file-based handoff: any agent can read the plans.
- -Milo creates them
- -Claude Code executes them locally
- -Codex can execute them for automation
- -Future agents can participate without infrastructure changes
No APIs. No webhooks. No authentication tokens. Just files in a folder.
The Results
After one day of using this system:
Ideas Captured: 4 feature requests from mobile
Plans Created: 3 complete implementation plans
Features Implemented: 1 (Copy to Agent button)
Context Lost: Zero
What We Gained
- -
Dead Time Became Productive Time
Dog walks, waiting rooms, commutes—these used to be idea graveyards. Now they're planning sessions.
- -
Research Happens in Parallel
While I'm doing other things, Milo is researching UX patterns, checking the codebase, writing specifications. By the time I'm ready to code, the research is done.
- -
No More "What Was I Thinking?"
Every decision is documented. Every consideration is written down. The plan is a snapshot of the mental state when the idea was fresh.
- -
Cost Optimization
Milo runs on cheaper cloud infrastructure. Claude Code runs locally with full codebase access. Planning happens where it's cheap; execution happens where it's powerful.
- -
Continuous Development Pipeline
Ideas flow in constantly. Plans accumulate. Execution happens when I'm ready. The pipeline never stops, even when I'm not at my desk.
What's Next: Remote Execution
Currently, the workflow is:
- -Plan remotely (anywhere with Telegram)
- -Execute locally (at home with Claude Code)
The next evolution:
- -Plan remotely
- -Execute remotely (via SSH, VPS, or cloud development environment)
Imagine: You have an idea at dinner. Message Milo. He creates the plan. You approve it from your phone. Claude Code executes it on your home machine via SSH.
You wake up to a PR with the feature implemented, tests passing, ready for review.
That's the vision. That's where this is going.
The Bigger Picture: Cognitive Leverage
This isn't just a cool hack. It's cognitive leverage in action.
Cognitive leverage is the core thesis of id8Labs: Humans should focus on creativity, judgment, and decision-making. AI should handle research, execution, and repetitive work.
The Mobile Development Pipeline is a perfect example:
| Human Does | AI Does |
|---|---|
| Has the idea | Researches the implementation |
| Decides what to build | Figures out how to build it |
| Approves the plan | Writes the plan |
| Reviews the result | Executes the code |
We're not replacing human creativity. We're amplifying it. An idea that would have been lost is now captured. Research that would take an hour happens in minutes. Implementation that would require context-rebuilding happens seamlessly.
The best ideas deserve better than being forgotten on the walk home.
Try It Yourself
The system requires three things:
- -A mobile AI assistant (Milo runs on Telegram via Clawdbot, but any AI chat works)
- -A shared directory (we use
~/Development/claude-plans/) - -A local execution agent (Claude Code, Cursor, or any AI-powered IDE)
The magic isn't in fancy infrastructure. It's in the workflow:
- -Capture ideas in natural language
- -Have AI create structured plans
- -Execute plans with full context preserved
You don't need our exact stack. You need the pattern.
Set This Up With Your Agent
Want to build your own Mobile Development Pipeline? Copy this prompt and paste it into your AI assistant (ChatGPT, Claude, or any AI chat). Your agent will walk you through setting up a personalized version of this workflow.
Copy this prompt to your AI assistant:
I just read about the "Mobile Development Pipeline" — a workflow where you capture ideas on mobile, have AI create detailed implementation plans, and execute them seamlessly when you get back to your computer.
I want to set up something similar for my own workflow. Here's what I need help with:
- -
Assess my current setup: Ask me what tools I currently use for development, what AI assistants I have access to (mobile and desktop), and where I store my project files.
- -
Design my plan directory: Help me create a "plan book" directory structure that works with my existing setup. Suggest a location, naming convention, and basic plan template.
- -
Create my plan template: Generate a markdown template I can use for capturing ideas, with sections for Context, Implementation Details, and Success Criteria.
- -
Set up the mobile capture: Help me configure a way to quickly send ideas from my phone to my plan directory. This could be via a notes app that syncs, a messaging bot, or even email-to-file automation.
- -
Configure the execution handoff: Show me how to tell my local AI assistant (Claude Code, Cursor, Copilot, etc.) to read from my plan directory and execute plans.
Important guidelines:
- -Only suggest changes that are reversible and safe
- -Don't modify any existing project files without my explicit approval
- -Adapt to whatever tools I already have — don't require me to install new services unless necessary
- -Keep it simple — start with the minimum viable setup and let me expand later
Let's start by you asking me about my current development setup.
Conclusion
We've been fighting the wrong battle.
The hard part of development isn't writing code. It's preserving context. It's remembering what you were thinking. It's not losing ideas to the gap between "having them" and "executing them."
The Mobile Development Pipeline closes that gap. Ideas captured anywhere become fully-researched plans. Plans become executed features. Context is never lost.
Today, a dog walk idea became a live feature in under 30 minutes of my active time.
Tomorrow, it might happen while I sleep.
This is the future of development: Ideas anywhere. Execution everywhere. Context always.
The Copy to Agent feature is now live on id8labs.com. It was planned on a dog walk and executed at home, with zero context lost in between.
Milo and Claude Code continue to build. One plan at a time.