superpowers VS compound-engineering-plugin

Meanwhile, the ecosystem materialized. obra/superpowers shipped a complete software development methodology built on composable skills — 1,276+ stars and growing. The cobusgreyling/loop-engineering repo cataloged patterns from Osmani and Cherny into a practical reference.

Projects like Superpowers proved that agents can follow structured methodologies — brainstorm before coding, write tests before implementation, review against specs before declaring success. The skills are mandatory workflows, not suggestions. The agent checks for relevant skills before any task.

If you're looking for complementary skills and plugins then have a look at Addy Osmani's Agent Skills or Superpowers, both provide essential coding assistant skills like Test-Driven Development (TDD). OpenSpec provides consistency, and your workflow can evolve around it.

Before any implementation, I plan. I use the brainstorming skill from Superpowers to think through the approach, then Grill Me - a separate skill that probes for contradictions, gaps, and missing assumptions, question by question. Once I'm satisfied, I save the result as a PRD and move to writing-plans (also from Superpowers), which produces a detailed implementation plan: class names, properties, architecture, tests.

These don't replace the spec; they govern how the agent acts on it. Superpowers uses guided Q&A to clarify intent, then runs sub-agents behind a verification-before-completion gate. GSD manages context in waves for solo developers. HVE Core runs an RPI loop: Research, Plan, Implement, Review.

> It would be extremely cool to be able to write one or two lines of prompt in my harness, and have a light model iterate with me a few times writing/proposing requirements, guidelines and explanations, refining the prompt until it's ready to be sent to the actual LLM.

I feel like the vast majority of AI-using coders already do this via skills suites like Superpowers (see /superpowers:brainstorming), no? https://github.com/obra/superpowers

I sometimes use Superpowers skills such as writing-plan and writing-spec. The Superpowers brainstorming skill stores design specs under docs/superpowers/specs/YYYY-MM-DD--design.md, and the writing-plans skill stores implementation plans under docs/superpowers/plans/YYYY-MM-DD-.md. (GitHub, GitHub)

obra/superpowers – GitHub

I use https://github.com/EveryInc/compound-engineering-plugin/blob... from https://every.to.

Here's a readup on it: https://every.to/guides/compound-engineering

Claude skills made by other people are typically useless. The exceptions I have found are https://github.com/EveryInc/compound-engineering-plugin which was like an early brainstorm -> plan -> write -> embed knowledge and best practices. Which is a common workflow now.

I've recently experimented with more lightweight things like https://github.com/mattpocock/skills which are good.

Most work is just the same 'ask questions step by step to define a spec' , 'make a plan', 'implement using TDD'

archforge is one attempt at the second framing. Pairs naturally with Compound Engineering — CE handles feature-level workflow (Brainstorm → Plan → Work → Review → Compound), archforge handles architectural decisions (Discover → Research → Design → Decide → Document → Review). Architectural decisions feed into CE plans by ADR number; CE compound learnings can produce new ADRs. The integration is materialized by running /archforge:remember-compound-integration once per project.

There's one more piece I'm experimenting with: compound engineering, a philosophy described by Kieran Klaassen and the team at Every in their guide. The core idea is that every unit of engineering work should make subsequent work easier, not harder. Most codebases get worse over time because each feature negotiates with the old ones; compound engineering flips this — features and fixes teach the system new capabilities, and the codebase compounds instead of decaying.

Compound Engineering by Every — a 36-skill, 50-agent framework around the idea that "each unit of engineering work should make the next one easier", ~16k stars. Both ship as Claude Code plugins. Both wrap roughly the same surface — brainstorm, plan, work, review. Both have evangelists writing "I 100x'd my output" posts. So the natural question gets asked a lot: which one wins?

This was also the first issue closed using Compound Engineering — a workflow built around a Plan → Work → Review → Compound loop.

Check out the strats from the Every team: https://github.com/EveryInc/compound-engineering-plugin (I recommend just learning from their builds and doing your own!)

Simon Willison's blog: https://simonwillison.net/guides/agentic-engineering-pattern...

Hey HN! I really enjoy Every's approach to Compound Engineering (https://every.to/guides/compound-engineering), but their plugin is tightly tied to their project (Cora) and stack (Ruby/Rails). I also found the files too big, and they used more context window than what I would like for my personal use.

So, with the help of Amp Code CLI, I've built my own take on the compound engineering workflow. I tried to keep it agnostic to project stacks and as efficient as possible, so the context window could be used in the best way. I also wanted it to be extendable (for example, just drop your own subagents for review that are specific to your project). I also wanted to be easy to set up and update, so I made a simple CLI tool that keeps track of files in the `.agents` directory, updates when new versions are found in the repository, and displays a diff in the terminal before overwriting any customisations.

I feel this matches well with my personal preferences when working with AI agents, but I would love to have feedback from more people.

Have you tried the compound engineering plugin? [^1]

My workflow with it is usually brainstorm -> lfg (planning) -> clear context -> lfg (giving it the produced plan to work on) -> compound if it didn’t on its own.

[^1]: https://github.com/EveryInc/compound-engineering-plugin