I Found a Better Way to Use Claude Code (Long Running Agents)

Long-Running Agents: Revolutionizing Agentic Coding with Claude Code

The video introduces long-running agents as the transformative future of agentic coding, particularly within the Claude Code ecosystem. The creator substantiates this claim by showcasing two distinct projects, both initiated with an identical, comprehensive prompt for a content creator assistance application, and executed without any human intervention. The stark differences in the outcomes vividly illustrate the superior capabilities and robust output achievable through a long-running agent approach, a method the creator subsequently details for user implementation via a bespoke UI.

The Inherent Problems of One-Shot Prompts 🤯

Attempting to build complex applications using a single, extensive prompt in a conventional Claude Code workflow presents significant limitations. The first project demonstrated this by employing the standard Claude Code CLI: an exhaustive prompt detailing the application's overview, technical requirements (including Next.js, Gemini 3 Pro/Nano Banana for thumbnails), prerequisites, and desired features (e.g., light/dark mode, AI assistant for card manipulation, editable system prompts) was fed into the agent.

The resulting application, built with a one-shot prompt, was severely flawed. It produced a simplistic UI lacking essential features such as light/dark mode and the ability to delete projects, despite these being explicit prompt requirements. Crucially, the embedded AI assistant failed to perform stipulated actions, like editing or removing content cards, and the UI often did not reflect changes. Furthermore, functionalities like editing system prompts or generating actual images for thumbnails (instead of mere descriptions) were entirely absent.

This failure stems primarily from the agent's inability to manage a massive project within a single context window. As the project scaled, the agent exceeded its context capacity, leading to aggressive conversation compaction and the loss of critical context. The video likens this to developers working in isolated shifts without handover, introducing inefficiencies, duplicate code, and bugs. This highlights the impracticality of "babysitting" an agent through numerous manual phases for large-scale development.

The Transformative Solution: Long-Running Agents ⚙️🚀

The solution lies in implementing a long-running agent harness, a framework designed to allow agents to operate autonomously for extended periods—hours or even days—to complete complex implementations, including integrated regression testing. This innovative approach effectively circumvents the context window problem by segmenting the vast project requirements into manageable, discrete features.

The process begins with an app spec file, a straightforward document outlining the application's prerequisites, tech stack, and core features, which can be populated with assistance from Claude or ChatGPT. An Initializer Agent then processes this spec, establishes the fundamental project structure, and, crucially, generates a detailed Feature List. This list can encompass hundreds or even thousands of individual features, such as a simple light/dark toggle, each slated for implementation and rigorous testing.

Following initialization, Coding Agents take over. Each agent retrieves the next feature from the list, implements it, and, critically, performs regression testing on three randomly selected, already-implemented features. As an agent approaches its context window limit, it gracefully concludes its session, updates the feature statuses, and passes the baton to the next coding agent. This modular approach ensures that each agent operates within its own lean, focused context, preserving critical information and enhancing efficiency. A standout feature is the agent's ability to open a browser window and test the application in real-time, enabling test-driven development, identifying UI bugs, and ensuring a robust, production-ready outcome. Moreover, the system supports unattended operation, automatically resuming work after usage limits reset. For speed-focused scenarios, a "YOLO mode" allows for blind implementation (with lint/type checks) without UI testing.

Project Comparison: A Leap in Quality and Functionality ✨📈

The second project, built with the long-running agent, showcases a dramatic improvement over its one-shot counterpart, delivering a polished and feature-rich application.

• First Project (One-Shot Prompt):

  • ❌ Basic, incomplete UI with missing critical features.
  • ❌ No light/dark mode, project deletion, or system prompt editing.
  • ❌ AI assistant failed to interact with UI elements (e.g., editing/removing cards).
  • ❌ Produced only thumbnail descriptions, not actual images.
  • ❌ Result of context window overflow and significant context loss.

• Second Project (Long-Running Agent):

  • ✅ Enhanced UI & Features: Implemented light and dark mode, a settings panel for editing system prompts (hooks, intros, titles, thumbnails), and the unexpected addition of project filtering by status.
  • ✅ Robust Project Management: Hovering over project cards revealed options to delete, edit, duplicate, and open projects, all functional.
  • ✅ Interactive Workflow: A detailed project view included a progress summary and a fully functional AI assistant with actionable buttons.
  • ✅ Dynamic Content Manipulation: The hooks generation displayed functionality to copy, edit, regenerate, or add more hooks. The AI assistant successfully modified cards (e.g., changing text, removing items), with UI elements visibly updating, including "edited" badges and a history feature for revisions.
  • ✅ Advanced Thumbnail Generation: The agent intelligently researched Nano Banana capabilities, prompting the user for reference images (e.g., logos, templates) and successfully generated actual, editable thumbnails. Users could view prompts, upscale to 4K, refine images (e.g., change text, colors), and track revisions, all persisted even after page refreshes.
  • ✅ Comprehensive Project Completion: The final screen provided a project summary, and the application allowed navigation back to previous steps while preserving progress.

This comparison unequivocally demonstrates the long-running agent's ability to produce a nearly production-ready application from a single prompt, far surpassing the limitations of one-shot methods.

Getting Started with the Long-Running Agent UI 🛠️👩‍💻

To experience the power of long-running agents, users can easily set up the creator's UI. Begin by downloading the provided GitHub repository as a ZIP file and extracting its contents. Run the appropriate script: start_ui.bat for Windows or start_ui.sh for Mac/Linux. Crucially, users must have the Claude Code CLI installed and authenticated (either via a Claude subscription or an Anthropic API key).

Within the UI, creating a new project involves selecting a folder and then choosing between two options: a "vanilla project" requiring manual appspec.md editing, or the recommended method, allowing Claude to generate the appspec.md file through an interactive conversation. Claude guides users with questions, offering "quick mode" for agent-driven decisions or "detailed mode" for user control over architecture. Users can also attach design images to the conversation. This process, which can take a few minutes, generates the appspec.md and updates the initializer_prompt.

The UI provides visibility into the Initializer Agent's progress, displaying features as they are created and added to a "pending" column, sorted by priority. A debug window offers detailed insights into agent activity. Users can also manually add new features to existing projects and query the codebase via a chat window. A key improvement in this custom UI over the vanilla Anthropic harness is the storage of features in a SQLite database instead of a large JSON file, enhancing performance and reducing token usage. A dedicated features_mcp_server facilitates efficient database interactions for features.

Once the initializer agent completes its work, coding agents commence. These agents leverage MCP tools to retrieve features, implement them, and perform regression tests. The truly innovative aspect is the real-time browser testing, where agents open the application in a browser window to visually identify and rectify UI bugs and styling issues, ensuring the output is robust and visually consistent. For those prioritizing speed over meticulous testing, a "YOLO mode" is available, where the agent implements features without real-time UI validation.

Final Takeaway: Long-running agents, especially when augmented with intelligent UI-driven testing and efficient context management, are poised to redefine how complex software is developed, making agentic coding more powerful, autonomous, and accessible.