The Creator of Superpowers: Why Real Agentic Engineering Beats Vibe Coding

Jesse Vincent’s agentic software development methodology, embodied in the Superpowers toolkit, is built on decades of experience managing software projects and, more specifically, MIT interns. The core philosophy is that a developer’s role is shifting from writing code to managing AI agents, a transition that requires new skills and tools. The process begins not with code, but with clarifying intent.

The Superpowers Workflow: From Brainstorming to Execution

The methodology is a structured process that moves from high-level ideation to verified implementation, treating the AI as a gifted but distractible engineer with poor judgment.

• Brainstorming Skill: This is the foundational step, designed to “trick the human into figuring out what they actually want.” It uses psychological principles, inspired by Robert Cialdini’s book Influence, to extract a clear problem statement and desired outcome from the user. This ensures that the agent has a well-defined goal before any implementation begins.

• Spec-Driven Planning: Once the goal is clear, the writing plan skill breaks the project into small, manageable steps. This process enforces software engineering best practices like Test-Driven Development (TDD), Don’t Repeat Yourself (DRY), and You Ain’t Gonna Need It (YAGNI). The output is a plan file containing discrete tasks, each with its own context, instructions, and success criteria. This prepares the work for an “idiot” implementer agent that only needs to follow instructions.

• Orchestration with Sub-Agents: Execution is handled by a hierarchy of specialized, disposable sub-agents:

  1. An Implementer Agent is given a single task from the plan file.
  2. Once complete, a brand new Spec Compliance Review Agent is created. Its sole mission is to verify that the implementation meets the spec exactly—nothing more, nothing less.
  3. If the review fails, the feedback is sent back to the original implementer for correction. The reviewer agent is then destroyed.
  4. This loop continues with fresh reviewer agents until the spec is met. This “clean session” approach prevents the reviewer from becoming biased or holding onto the context of past failures.
  5. After spec compliance is achieved, the entire process is repeated with a Code Quality Review Agent.

This separation of concerns, where each agent has one clear mission, avoids the conflicts of interest that arise when a single agent is responsible for both implementation and quality control.

Crafting and Debugging Skills

The effectiveness of the system relies on well-crafted skills. Vincent’s approach to skill creation is iterative and grounded in practical experience.

• The “Why” is Crucial: A key insight is that agents perform significantly better when they understand the intent behind a process, not just the mechanical steps. Explaining why a sub-agent is used for code reviews (to keep the orchestrator’s context clean) or why TDD is necessary helps the agent generalize, handle exceptions, and follow the “spirit” of the instructions rather than just the “letter.”

• Learning from Failure: Skills are not created in a vacuum. A valuable technique is to ask the agent after a difficult session, “How could we have made this easier for you?” The answer often reveals a gap in its knowledge or process that can be codified into a new or updated skill. The debugging skill, for example, is a distillation of 30 years of human debugging experience, focusing on root cause analysis and creating clean reproduction cases.

• Pressure Testing and Rationalization: Agents, like humans, rationalize to avoid rules. To combat this, Vincent developed a “pressure testing” technique where an agent fires up sub-agents and places them in high-pressure scenarios to see if they break the rules defined in a skill. When a sub-agent rationalizes its behavior (e.g., “This task is too small for TDD”), that excuse is captured and added to a “rationalization table” within the skill itself. This table explicitly tells the agent not to fall for these common rationalizations, forcing it to adhere to the process.

The Future of Software Development

This agentic methodology points toward a future where the nature of software and development is fundamentally different.

• Tools for the New Era: Traditional IDEs are becoming obsolete in this workflow. Vincent created Clearance, a Markdown-native browser designed for reading and navigating the specs and plans that now form the core of development. He is also working on Greenfield, a toolset to reverse-engineer legacy codebases or compiled products back into clean specs, facilitating modernization and migration.

• Ethics and the Value of Code: The ease of reverse engineering raises ethical questions about license washing and cloning open-source projects. This leads to a profound idea: the future of open source may not be distributing code, but distributing specs and tests. The implementation could be generated on-demand, bespoke to the user’s specific environment. In this world, the value shifts from the lines of code to the “taste and judgment” embedded in the specifications and the rigor of the test suites.

• The Developer as Manager: Ultimately, the “magic trick” of tools like Superpowers is that they transform a developer into a manager. The job is no longer about writing syntax but about defining outcomes, planning work, and managing a team of AI agents. This mirrors Vincent’s early career experience managing interns, which provided the blueprint for his agentic development framework.

• Tags:
• Software Engineering
• Prompt Engineering
• LLM
• Claude
• Spec-Driven Development
• Agentic Development
• Superpowers