The Problem With How Most Developers Use AI Today
You open Claude Code or Cursor, describe what you want, and the agent immediately starts generating code. Sounds great, right? Except ten minutes later, you’re staring at a ViewModel that ignores your DI setup, tests that weren’t written, and a pattern that doesn’t match anything else in your codebase. You spend the next hour fixing what the AI just wrote.
That’s not an AI problem. That’s a workflow problem. The model isn’t broken — the way you’re using it is. And there are three things that actually solve this: spec-driven development, compound engineering, and a Claude Code plugin called Superpowers — a collection of composable skills that enforces a structured development methodology on your agent. Once you understand all three, you stop thinking of AI as a fast code generator and start treating it as a disciplined engineering partner.
Spec-Driven Development: Make the AI Read the Brief First
Spec-Driven Development (SDD) is exactly what it sounds like: you write a spec before any code gets generated, and that spec becomes the source of truth for everything that follows. Not a novel. A short, precise description of what the feature should do, what constraints it must respect, and how you’ll know it worked.
Why does this matter? Because LLMs are extremely good at “completing” things. Give them a vague prompt and they’ll produce confident, plausible-looking output that drifts from what you actually wanted. Give them a concrete spec and they have something to check their work against. The spec is the guardrail.
In practice, SDD with a tool like Claude Code works like this: instead of typing “add a settings screen,” you hold the agent back and ask it to explore your codebase first — your architecture, your DI modules, your existing patterns. Then you ask it to propose approaches, not write code. Once you’ve agreed on the approach, you write down the spec (or let the agent draft it for your approval), and only then does implementation start. Every decision in the generated code can be traced back to a line in the spec.
The SDD ecosystem exploded in 2025. Tools like Superpowers and Kiro (AWS’s agentic IDE built around specs) all shipped their own flavors of this approach. The core idea across all of them is the same: the spec executes as a validation gate, not just a document someone reads once and forgets. When your agent generates code, it can check the output against the spec automatically. When it fails, it knows exactly where and why.
For Android developers, this means your CLAUDE.md (or equivalent context file) becomes a living spec for how your project is built — architecture patterns, naming conventions, which libraries you use and for what. Any new feature gets a short spec that references those constraints. The agent stops guessing and starts building to a contract.
Compound Engineering: Each Task Makes the Next One Easier
Compound engineering is a different idea, and one of the more interesting mental models to come out of the AI-native development space. Originally documented by the team at Every, it’s both a philosophy and a concrete Claude Code plugin. The core insight is simple: most of the value of software development compounds over time, and most developers don’t engineer their workflow to take advantage of that.
Think about what happens when you write good tests for a feature. The next feature you add is faster to validate. When you document a pattern in your codebase, every AI-assisted task that touches that area becomes more accurate. When you build reusable skills or prompt templates for your agent, every subsequent use of those templates is cheaper. Each unit of work you do today becomes an investment that pays dividends on future work.
Compound engineering, as a methodology, takes this seriously and makes it explicit. Instead of treating each AI task as a one-off “generate this thing,” compound engineers think about what artifacts they’re creating that will make future tasks faster and more reliable. Good test coverage, well-documented architecture, reusable agent skills, fast CI/CD pipelines — these are compound investments, not just engineering hygiene.
The numbers being reported are striking. Teams that have fully leaned into this approach are seeing 300–700% productivity gains — not from the AI writing code faster, but from the feedback loops and reusable artifacts making everything downstream cheaper. The caveat is that simply using AI tools doesn’t move the needle. The gains come from rearchitecting how you build software, not from adding a copilot to an unchanged process. If you want to go deep on this, the full Compound Engineering guide on Every is worth reading cover to cover.
For a concrete example: every time you build a feature using strict TDD with an AI agent, you’re also building a test suite that validates every future feature touching the same code. Every CLAUDE.md entry you write teaches the agent something it’ll use on every future task in that project. The upfront investment feels slow. The compounding is where it gets interesting.
Superpowers: The Framework That Combines Both
If spec-driven development and compound engineering are the principles, Superpowers is one of the most concrete implementations of both in the wild. It’s a plugin — installable in Claude Code via /plugin install superpowers, and also available for Cursor, Codex, and Gemini CLI. Created by Jesse Vincent, it hit 213k GitHub stars by mid-2026, which tells you how many developers were looking for exactly this kind of structure.
What Superpowers actually ships is a library of composable skills: markdown files that trigger automatically based on context and function as mandatory workflow steps for your agent. Not suggestions. Not system prompts you paste in once and hope stick. Actual gates that block the next phase from starting until the current one is done. Brainstorming before planning. Planning before implementation. Tests before code. Review before shipping. It works with Claude Code, Cursor, OpenAI Codex, and Gemini CLI — you install it once per tool.
What makes this interesting isn’t the individual steps — those aren’t new. It’s that the agent is structurally prevented from skipping them. You can tell an AI agent “always write tests first” in a system prompt and it’ll nod, start writing code, and forget the tests exist. When that requirement is encoded as a skill that blocks the next phase from starting, the agent can’t shortcut it.
The workflow Superpowers enforces looks like this:
- Brainstorm — explore the codebase, ask clarifying questions, propose approaches. No code yet.
- Spec — write a precise design document. Get human approval before moving on.
- Plan — decompose the spec into bite-sized tasks with exact file paths, expected outputs, and verification commands.
- Implement — one task at a time, using TDD. Red, green, refactor. No exceptions.
- Review — spec compliance check and code quality check, ideally via a fresh subagent that hasn’t seen the implementation process.
- Verify — run the full test suite. Show the output. No completion claims without fresh evidence.
This maps almost perfectly onto what we covered in the structured AI development workflow for Android — if you’ve read that post, Superpowers is essentially the open-source version of that methodology, available for any stack and any AI coding tool.
The compound engineering angle comes in through the skills themselves. Once you write a skill for your specific project — say, one that knows your Hilt module structure and enforces correct DI patterns — that skill compounds. Every new feature your agent builds benefits from it. You build the skill once; it pays off every time the agent runs.
Why These Three Things Work Better Together
On their own, each of these principles is useful. Together, they form something that feels qualitatively different from “using an AI to write code faster.”
Spec-driven development gives the agent a contract to build against — eliminating the biggest failure mode, which is drift from intent. Compound engineering gives you a mental model for where to invest your effort: documentation, tests, skills, and feedback loops that make every future task cheaper. Superpowers (or any equivalent framework) is the operational layer that enforces both, converting good intentions into structural guardrails your agent can’t override.
The result is a development workflow where the AI genuinely amplifies your capabilities instead of generating cleanup work. You design the system — the spec, the patterns, the constraints. The agent implements against your design and validates its own output. You review the result instead of hunting for the mistakes.
That’s what the “superpowers” label is trying to capture. Not that the AI does magic. But that a developer who sets up their workflow this way is doing something qualitatively different from someone who types prompts and accepts whatever comes back.
Where to Start if This Is New to You
You don’t need to overhaul your entire workflow on day one. Start with one habit: hold back your AI agent before it writes code. Ask it to explore your project first. Get it to propose an approach. Write down what you agreed on. That alone — at its most minimal — is spec-driven development, and it immediately reduces the amount of code you need to fix after the agent runs.
Then add a fast test suite if you don’t have one. Even a partial one. Unit tests for your ViewModels, Repository contracts, UseCases. Once you have tests the agent can run, you have a feedback loop — and that’s the foundation for everything else. The agent can verify its own work instead of asking you to check it.
After that, pick one of the concrete tools: Superpowers for Claude Code or Cursor, the Compound Engineering plugin if you like Every’s approach, or Kiro if you want a full spec-driven IDE from AWS. All three are free to start. The Claude Code review workflow post also covers some of this ground. The skills are composable — you can adopt the brainstorming phase first, add planning next, and layer in the rest over time.
The compounding starts the moment you create your first reusable artifact — whether that’s a CLAUDE.md, a prompt template, a test pattern, or a skill file. Each one is an investment. The question is whether you’re making those investments intentionally, or just hoping your AI tool figures it out on its own.
Try Claude Code free for a week — If you haven’t used Claude Code yet, use my referral link to get a free week with no commitment. If you end up subscribing, I get a small usage credit — which helps me keep writing content like this. Either way, it’s a free week to see if it clicks for you: claude.ai/referral/swLTJQMYaw
This post was written by a human with the help of Claude, an AI assistant by Anthropic.