AI Agents While You Sleep

How automation compounds -from a meeting recording to implemented code.

You wake up to three notifications. The first is a PR ready for review -implementing the feature you discussed yesterday. The second is a validation report confirming all tests pass. The third is a time estimate: "Equivalent to 4 hours of human development."

You didn't write a single line of code. You had a meeting, went to bed, and let the agents work.

The Pipeline

It starts with a recording. A 43-minute Google Meet where you and the product owner discuss a new feature. You're not taking notes -you're just talking through requirements, edge cases, preferences.

When the call ends, a chain reaction begins:

The transcription lands in Notion as a draft PLAN.md -a structured document describing what needs to be built. Simultaneously, Telegram pings me: "New plan ready. Which project?"

I reply with a single word. n8n creates a PR with the plan attached and adds a label: claude-plan.

That label triggers the orchestrator.

The Orchestrator

GitHub Actions watches for specific labels. Each label triggers a stage, and each stage prepares the next:

Init runs once per project to discover how to build, run, and test it. It deploys specialized subagents that explore the codebase -more on this below.

Plan analyzes the requirements and creates a detailed implementation plan -what files to modify, what patterns to follow, what tests to write.

Execute is where the code gets written. Claude implements the plan in an isolated git worktree, keeping the main branch clean until validation passes.

Validate builds the project, starts services, and runs tests. If something fails, it documents the issues and triggers Fix.

Fix reads the validation errors, applies corrections, and triggers validation again. This loop continues until everything passes or a human intervenes.

Finalize splits the changes into logical commits and estimates how long this would have taken a human developer.

Init: Teaching the Orchestrator

Before the orchestrator can work on a project, it needs to understand it. That's what Init does -it explores a codebase and discovers how to build, run, and test it.

Init doesn't just read config files. It deploys a team of specialized subagents:

• Project Scout explores the directory structure, finds package.json, *.csproj, Dockerfiles -anything that reveals how the project is organized.
• Build Agent discovers and verifies build commands. It doesn't just find npm run build -it runs it and confirms it works.
• Service Discovery figures out how to start and stop services, finds health endpoints, and tests them with curl.
• Navigation Builder creates a playbook of routes and UI elements for validation testing.

Each subagent is a focused prompt that runs in its own context. They report back findings, and the orchestrator assembles everything into a PROJECT_CONFIG.json:

{
  "name": "acme-app",
  "start": {
    "backend": {
      "command": "npm run dev",
      "ready_check": "curl -s http://localhost:3000/health",
      "timeout_seconds": 60
    }
  },
  "validation": {
    "build": { "command": "npm run build" },
    "base_url": "http://localhost:3000"
  }
}

Once init completes, the orchestrator knows everything it needs. Future PRs on this project skip straight to planning.

The Toolkit

The orchestrator doesn't run inside the target project -it copies a toolkit into an isolated git worktree. This toolkit contains everything Claude needs to work autonomously:

The toolkit includes an MCP server that gives Claude custom tools -tracking iteration history, storing evidence, managing navigation routes. It includes hooks that detect when Claude signals completion. And it includes the subagent prompts themselves -focused instructions for specific tasks.

This architecture means the orchestrator is project-agnostic. The same workflows handle a React frontend, a .NET backend, or a monorepo with both. Init discovers the specifics; the toolkit provides the scaffolding.

Ralph Loop

The key innovation is Ralph Loop -a pattern for iterative AI execution. Each iteration, Claude runs with fresh context but can see summaries of its previous work. When it's done, it signals completion with a special tag.

This solves the context window problem. Long implementations don't need to fit in a single context -they're broken into digestible iterations, each building on the last.

The Compound Effect

None of these pieces are remarkable on their own:

• n8n connects APIs without code. Watch a folder, transcribe a file, send a message.
• GitHub Actions runs workflows on events. A label triggers a job.
• Claude writes code when given context. A plan becomes an implementation.

But connected together, they create something that feels like magic: meetings become implementations. Ideas become PRs. Sleep becomes productive time.

The compound effect isn't in any single tool -it's in the interfaces between them. A recording becomes a transcript becomes a plan becomes a label becomes a workflow becomes code becomes a PR.

Each transformation is simple. The chain is powerful.

The future of software development isn't AI replacing developers. It's developers orchestrating AI agents that work while they sleep.