Capture-to-Build Task Queue for Claude Code
Capture ideas into a file-based queue from one terminal while another Claude Code session plans, builds, tests, and commits each item.
Before & after
Same prompt, same agent — the only difference is the skill.
That's an interesting workflow concept. Setting up autonomous builds with idea capture would involve a few pieces—you'd need a way to queue ideas, then have a separate process that works through that queue and builds things automatically. There are different ways to approach this depending on how structured you want it. You could use a folder-based system, a database, or a message queue, each with different trade-offs. And the build agent would need to know when to plan versus execute, how to handle errors, and when to commit. It's definitely possible to set up, but there are several design decisions to make first. What's your technical comfort level, and how often do you generate ideas?
DO-WORK TWO-TERMINAL SYSTEM: Ready to deploy
ARCHITECTURE:
Terminal 1 (Capture): You type ideas in real time
→ Skill captures to shared queue folder (JSON files with timestamp)
→ Format: title, description, complexity (simple/medium/hard), priority (1-5)
Terminal 2 (Build): Autonomous loop running continuously
→ Detects new files in queue folder
→ Runs planning (for hard tasks only)
→ Spins up git worktree per task
→ Commits after completion
→ Moves completed file to archive folder
QUEUE FILE EXAMPLE:
{"title": "Fix navbar hover bug", "description": "Links don't show on mobile", "complexity": "simple", "priority": 3}
BUILD AGENT DECISION TREE:
→ Complexity=simple? Skip planning, execute immediately
→ Complexity=medium? Run 2min planning loop, then execute
→ Complexity=hard? Full planning + sub-agent delegation + testing before commit
→ Error detected? Pause task, log to errors.txt, notify user
COMMIT PATTERN:
Each task creates one clean commit with title from queue file. Message format: "Fix navbar hover bug" (Cherry-pick most relevant work from build loop output)
SETUP TIME: 30 minutes
QUEUE LOCATION: ./work-queue/
ARCHIVE LOCATION: ./work-complete/
RECOMMENDED: Test with 5 small tasks first before production ideasAbout this skill
You get ideas mid-task, so you either derail what you're doing or lose them. When you finally hand Claude a backlog, the loop stalls on its first question, or it plows ahead and commits half-related changes to main. This skill splits the work into two Claude Code sessions with strict rules. One captures ideas as task files in seconds. The other works through that queue: it plans when needed, parks anything that needs a human, and makes one clean, tested commit per task.
What it does
- Writes each captured idea as a task file that can be built cold. Each file holds your exact words, the context that exists only right now, and "done when" checks a test can verify.
- Splits messy multi-idea dumps into commit-sized items and merges duplicates instead of creating them.
- Claims tasks with an atomic folder move, so a crashed or second worker never double-builds an item.
- Applies an explicit plan-vs-execute rule. Schema changes, new dependencies, deletes, auth, and multi-file changes get a written plan first.
- Parks blocked tasks with one specific question and keeps going, so the loop doesn't stall waiting for you.
- Stages explicit paths, one task per commit, with no push. Stop rules catch systemic failures, and it recovers stale claims from interrupted runs.
What you get
You get a .queue/ folder workflow with a capture mode that answers in one line and a build mode that runs preflight checks, then loops until the queue is empty. At the end it writes a run report listing commits made and questions waiting for you.
Best for
This is for developers using Claude Code who want ideas captured without breaking flow and a backlog built unattended. It's meant for setups where commits stay reviewable and nothing reaches main or production without a human.
SKILL.md preview
---
name: capture-to-build-task-queue
description: Runs a file-based work queue for Claude Code in two modes. Capture logs an idea as a self-contained task file in seconds, with no questions. Build claims the oldest task, decides whether to plan or execute, then implements, tests, and commits one item per commit, repeating until the queue is empty or a stop rule fires. Use when the user says "add this to the queue", "capture: ...", "do work", "work through the queue", "set up a capture and build loop", "I keep losing ideas mid-task", "my agent loop keeps stalling on questions", or "Claude keeps committing half-finished stuff".
---
# Capture-to-Build Task Queue
… (sign up to view the full skill)More development skills
View all Development skills →Performance Bottleneck Profiling: Node, Python, Go
Classifies a slowdown, gives exact profiler commands, reads the output, and proves the fix with same-conditions p95/p99 numbers.
Feature Scaffolding with Working Tests
Turn a short feature spec into code, runnable tests, and integration wiring that match your existing project.
Feature Flag Rollouts and Kill Switches
Design staged flag rollouts, verify rollback paths, and audit flag debt with explicit defaults, gates, and retirement plans.
Microcontroller Firmware and RTOS Engineering
Build and debug MCU firmware with bounded ISR/RTOS timing, safe DMA ownership, and measured power budgets.