It’s 11pm. You’re not at your desk. A sharp idea surfaces — the exact right way to structure the next feature, the architectural decision you’ve been circling for a week. You know how this usually goes: you either lose it to sleep, or you context-switch hard enough to disrupt the next day’s momentum.

I stopped accepting that trade-off. Here’s the workflow I built instead.

Three Pieces, One System

The stack has three components. Each solves a different problem. Together they cover the full arc from idea to shipped code — regardless of where you are or what device you’re on.

NanoClaw + Lyra — a personal AI layer that runs across every channel (WhatsApp, Discord, Telegram, Slack) and maintains a persistent knowledge base. This is the capture and planning surface. It’s always on, it’s mobile-first, and it remembers everything.

BMAD Method — an open-source AI development methodology with 21 specialized agents for every phase: analysis, product management, architecture, sprint planning, implementation, code review, retrospectives. Think of it as a structured AI-powered development team living inside Claude Code.

Claude Code Remote Control — the ability to start a full Claude Code session on your local machine and connect to it from any device. Your phone becomes a window into your development environment, complete with filesystem, tools, and MCP servers.

The insight that makes this work: Lyra handles pre-keyboard thinking. Claude Code handles execution. The handoff is seamless because they share the same knowledge base.

How It Actually Works

Phase 1: The 11pm Idea

Back to that late-night insight. Instead of fighting it or losing it, I send a message to Lyra:

brainstorm nyx: federated config system — each crate declares its own config schema

Lyra captures it to the knowledge base vault, does a quick brainstorm session in chat, and surfaces any related notes or decisions from the KB. By the time I’m done with a five-minute phone conversation, the idea has structure. It’s no longer at risk of evaporating.

No context switching. No opening a laptop. No breaking flow.

Phase 2: Planning from the Couch

The next morning, still on my phone, I hand the idea to the PM agent:

nyx/pm: create PRD for federated config system based on last brainstorm

Lyra adopts the PM persona (John from the BMAD roster), reads the brainstorm note from the KB, and runs a guided facilitation — asking the right product questions, surfacing assumptions, producing a structured PRD. When that’s done:

nyx/sm: create story for federated config — Epic 3

Bob (the Scrum Master agent) takes the PRD, sequences it into the sprint, and produces a story file with acceptance criteria, task breakdown, and implementation context. It lands in the project’s docs/implementation-artifacts/ directory, fully formed, waiting for the Dev agent.

All of this happened on a phone. No IDE, no terminal.

Phase 3: Starting the Session

When I’m ready to code, I send one message:

nyx: start dev session — Story 3-1: Federated Config

NanoClaw runs claude remote-control on my machine, in the project directory. The session registers with Anthropic and becomes visible in the Claude app — a computer icon with a green dot in the session list. I tap it from my phone (or open it in a browser, or pick it up later on desktop). I’m now in a full Claude Code session with my local filesystem, MCP servers, and the complete Rust workspace available.

The process runs on my machine. Nothing moved to the cloud.

Phase 4: The BMAD Dev Agent

In the session, I load the Dev agent:

/bmad-agent-bmm-dev

Amelia (the Dev persona) reads the story file completely before writing a single line of code. She executes tasks in order, writes tests alongside implementation, marks tasks complete only when both the code and tests pass. For this project, she runs cargo build and cargo nextest run after every task.

The enforced discipline is the point. The agent can’t “mark it done” without actually doing it. That sounds obvious until you’ve worked with an AI that cheerfully told you everything was fine while the tests were on fire.

Phase 5: Code Review Without Mercy

When implementation is done, I start a fresh session:

nyx: start dev session — Code Review: Story 3-1

In the new session (fresh context — important), I run the review workflow:

/bmad-bmm-code-review

This workflow reads the story file, runs git diff, cross-references every changed file against the story’s claimed File List, validates every Acceptance Criterion is actually implemented, and audits every [x] task to confirm it’s truly done. The target is 3–10 specific issues minimum. It’s explicitly adversarial — the review doesn’t have the dev context that might soften its stance.

The findings come back structured: CRITICAL for anything marked done that isn’t, HIGH for missing ACs, MEDIUM for documentation gaps, LOW for everything else.

Phase 6: The Knowledge Stays

After the session ends, everything routes back to the KB vault:

nyx: sync

Decisions, implementation notes, progress logs — they all land in the right folders. The next time I start a session for a related feature, Lyra has full context. The KB is the persistent memory that survives across sessions, across agents, across weeks.

What Changes When This Works

The traditional dev workflow assumes a specific physical and temporal setup: you at your desk, with your tools open, with uninterrupted blocks of time. Reality doesn’t cooperate.

This stack collapses the gap between where ideas happen and where code gets written.

Capture happens in chat. You don’t need your dev environment to log an issue, make a decision, or capture a brainstorm. You need a message window.

Planning happens asynchronously. PRDs, architecture decisions, story breakdowns — these can happen on a phone between meetings. The structured AI methodology means you’re not producing vague notes; you’re producing artifacts that the Dev agent can act on directly.

Execution happens on your machine. Remote Control means the session runs locally with full environment access. The mobile app is a viewport, not a sandbox. You’re not constrained to what runs in a browser.

Context is never lost. Because everything flows through the KB, the handoff between phases doesn’t require you to re-explain context. Lyra knows the project. The Dev agent gets the story file. The review agent gets the diff and the story. No one is starting from scratch.

The Practical Setup

If you want to build something similar:

BMAD Method is open-source: github.com/bmad-code-org/BMAD-METHOD. Install with npx bmad-method install. The agent roster is large — start with the Quick Flow solo dev (/bmad-agent-bmm-quick-flow-solo-dev) to get a feel before committing to the full phase structure.

Claude Code Remote Control is available now in Claude Code. claude remote-control --name "session-name" starts a session. The Claude iOS app, Android app, and claude.ai/code all support connecting to it.

The KB layer is the piece you build for yourself. An Obsidian vault with a consistent folder structure and routing rules is enough to start. The value compounds with time — every session that captures its outputs makes the next session richer.

The Bigger Pattern

What I’ve described is a specific instantiation of a more general principle: AI tools amplify whatever context they’re given. A Dev agent with a well-formed story file, a project_context.md with hard constraints, and a KB full of prior decisions will produce far better code than the same agent starting cold.

The workflow described here is one way to solve the context problem at scale. The specific tools will evolve. The principle won’t.

The best architecture ideas don’t happen at the keyboard. The question is whether your workflow lets you act on them anyway.

The views expressed here are my own. Examples and scenarios are drawn from my personal projects and do not represent any specific organization, product, or system.