Superpowers: How to Make an AI Agent Run All Night and Deliver Usable Results

Earlier this year while building my own Agent, I wondered whether I could use GitHub issues to write PRDs and break down tasks, enabling long-running agent orchestration. The agent architecture I was playing with was similar to OpenClaw, but the LLM core accessed Codex via ACP.

However, I overreached. My original motivation was that my $200 ChatGPT and $200 Codex subscriptions were going to waste, so I dreamed of filing a request before bed and waking up to completed work. The PRD writing and subtask decomposition went smoothly, but when it came to dispatching and executing subagents, things fell apart. I eventually moved on to vibe coding other things and abandoned it.

Turns out, the Obra/Superpowers toolkit I've been using recently already "solved" this problem late last year — not by dispatching subagents via OpenClaw, but as Skills that run directly inside CLI tools like Claude Code and Codex, which already support a subagent environment.

This Skill set excels at having an Agent execute large tasks, but it overcomplicates small ones. Since we can handle the latter by hand or voice prompt with AI anyway, we can focus on the former.

1. Think and confirm upfront to reduce communication and rework costs.

To realize the dream of "giving the AI a task at bedtime and waking up to usable results," a central requirement is to communicate our needs clearly and in enough detail.

Doing this perfectly in one human-written prompt is very difficult. Superpowers solves this with several clever design techniques.

Before writing the Spec or PRD, Superpowers runs a brainstorming phase that iterates details with the human. It even provides a Visual Companion that can build a rough web demo for visual confirmation of the proposed design. During this process, it only confirms one question at a time; the Visual Companion can offer multiple options; it follows the YAGNI principle (keep it as simple as possible, only what's truly useful); it explores alternatives for the user to choose from; it confirms incrementally (draft first, then refine); and it allows flexibility (if things go wrong, you can restart a discussion). The output of this step is a spec document — once this conversation is done, the hardest human work is complete.

After the spec is done, the next step is writing plans. The first step broke a large requirement into a Spec; the Plans step then breaks it into sufficiently small tasks. Each task is a sub-project with clear boundaries. Each step is a 2–5 minute atomic action (write a failing test / run and confirm it fails / write minimal implementation / run tests to confirm pass / commit code), following DRY, YAGNI, TDD, and frequent commit principles (lots of acronyms learned 😂). It also prohibits common AI lazy habits like TODO comments, "add appropriate error handling," or "similar to Task N." Finally, the Plan must be self-reviewed: checking Spec coverage, scanning for placeholders, and verifying consistency. The resulting plans are high-quality.

Once plans are ready, the system moves to executing plans. The fallback is a single session running end-to-end (if the environment doesn't support subagents), but since both Claude Code and Codex CLI support subagents, we typically choose subagent-driven development. During execution, it reads the plan first, then reviews, then executes. If it gets stuck, it stops to ask rather than guessing.

The key to making an AI run for over an hour on a single requirement is subagent-driven development. It creates a new subagent for each task, and each subagent goes through two phases of review to ensure quality output. The Skill set includes three prompt files — implementer-prompt.md, spec-reviewer-prompt.md, and code-quality-reviewer-prompt.md — for execution and review. Since each subagent only uses its own context, the main session context never gets overloaded. They follow TDD, and some tasks can even run in parallel. The Skill also includes a set of Red Flags to keep the AI on track: don't write code on main/master without permission (large tasks use a worktree instead, handled by another skill); don't skip tasks before fixing issues; don't let subagents read the Plan file — they only need enough context, reading Plan files is the main session's job. Very harness-oriented.

This gives Superpowers a core software development pipeline:

brainstorming → writing-plans → executing-plans / subagent-driven-development

The output of each step is the input to the next. Subagents never inherit the main session's context, keeping each independent and uncontaminated. It also explicitly prohibits the AI from stopping mid-task to ask whether to continue — this is key to sustaining runs over an hour. For quality assurance, it strictly follows the Spec first, then performs Code Quality Review: get it right first, then make it good. In my earlier agent orchestration attempts, task duration went up, but quality fell off a cliff after 20 minutes, exactly because we didn't strictly follow the Spec. This is critical.

2. What's Next?

The word "Harness" has been trending lately, though nobody can quite define it. I think Superpowers' design is an excellent example of Harness in practice.

@RoCry recently shared a video with me: "Harness Engineering: How to Build Software When Humans Steer, Agents Execute — Ryan Lopopolo, OpenAI - YouTube." It makes a key point: "What if the large language model is good enough?"

@RoCry's take: if LLMs today are like a fresh graduate — basic ability and IQ are adequate — then to guide them to write code, you just need to teach them specific coding conventions and methods. Once they master those, almost everything can be delegated; we just need to build a proper harness. (That's the gist; I've paraphrased.)

I think that makes a lot of sense. As of June 2026, frontier models are already very capable — Opus 4.8/4.7 and Codex GPT-5.5 can handle most tasks. The trickiest problem we face is AI going rogue, and Superpowers' Skill practice is one form of Harness: by writing credible Specs and Plans through clear upfront communication, and using them as a basis for judgment, even cheaper models become reliable and produce usable results.

In Superpowers' design, words like "Never" and "HARD-GATE" provide strong constraints on the AI. The contractor-dispatching model between the main agent and subagents makes long-running tasks feasible. Separating the Implementer and Reviewer roles ensures final quality aligns with the Spec. And because it's a Skill Set, it works with multiple CLI tools — Claude Code, Codex, and more.

I recently chatted with a friend who believed that if Harness is good enough, we could use cheap AI models to do work that previously required expensive LLMs. We were discussing agent-based product design at the time, not software engineering. It struck me as insightful, so I switched my agent tools' base model from Gemini to DeepSeek. In my product's Harness, I engineering-implement everything that can be hard-coded, reserving LLM API calls only for text understanding and processing. Now DeepSeek V4 Pro offers both good capability and very affordable pricing. Using a cheaper model for production is pure cost reduction — why not?

Superpowers is just one Skill set of its kind. A couple of days ago, @Clu recommended mattpocock/skills and /grill-me. I haven't tried them yet but plan to.

Superpowers has its limitations. For simple tasks, if the AI automatically decides to invoke Superpowers, it wastes tokens and time, overcomplicating straightforward problems. So use it carefully — judge whether the task truly fits before handing it over.