superpowers VS beads

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

This is where Beads comes in, created by Steve Yegge (the same guy behind those famous Google and Amazon rants).

I'm an IT consultant. CCleaner was a good choice to speed up clients' web browsing experience. Unless you paid, it keeps vomiting ads for the product. Which made it a bad choice.

mTTCleaner does most of the same thing to clean most browsers by cleaning caches, compacting databases, and removing unnecessary metrics files.

It can create it's own cron job/scheduled task to run itself every month, if you choose.

It covers 28 browsers on 3 platforms, assuming you have PowerShell 7+.

Please file any bugs if you find them.

This isn't really going anywhere except to help internet users and my clients.

Hope it's helpful

PS - All of it generated with VS Code, Augmentcode AI (https://www.augmentcode.com/), OpenSpec (https://github.com/Fission-AI/OpenSpec), and beads (https://github.com/gastownhall/beads).

Malware might be a bit of stretch but could refer to this issue?

https://github.com/steveyegge/beads/issues/1857

I implemented a post-compaction recovery system using beads - a task tracking system that persists state in git. The key insight: if it's in git, it survives compaction.

This is where the workflow from my previous post paid off. If you haven't read it: I use a pipeline where work gets decomposed into beads — small, focused tasks based on Steve Yegge's beads concept. Each bead is scoped tightly enough that a sub-agent can pick it up and run with it without needing the full conversation history.

I swear by Yegge's Beads https://github.com/steveyegge/beads. Just love it. One of the things Steve talks about in his best practice guide is that the only things that belong in Beads are things that are being actively worked on; it's not a backlog.

I also really like Claude's planning mode, except for the fact that it's tightly coupled with execution.

A pattern I've found is to work in different loops: a planning loop and an execution loop.

Planning loop:

And as engineers seek more parallel agents and longer running autonomous agents, they may have to re-evaluate markdown plans. Maybe markdown plans aren't scalable enough, or are too freeform. For example, you can look at Steve Yegge's beads project, as products in issue tracking. (I haven't tried it, but I'd like to.) I believe the idea is that a more structured workflow will boost clarity, performance and understanding, especially for "totally autonomous agent teams" like his Gastown project.

Understanding scientific articles can be tough, even in your own field. Trying to comprehend articles from others? Good luck.

Enter, Now I Get It!

I made this app for curious people. Simply upload an article and after a few minutes you'll have an interactive web page showcasing the highlights. Generated pages are stored in the cloud and can be viewed from a gallery.

Now I Get It! uses the best LLMs out there, which means the app will improve as AI improves.

Free for now - it's capped at 20 articles per day so I don't burn cash.

A few things I (and maybe you will) find interesting:

* This is a pure convenience app. I could just as well use a saved prompt in Claude, but sometimes it's nice to have a niche-focused app. It's just cognitively easier, IMO.

* The app was built for myself and colleagues in various scientific fields. It can take an hour or more to read a detailed paper so this is like an on-ramp.

* The app is a place for me to experiment with using LLMs to translate scientific articles into software. The space is pregnant with possibilities.

* Everything in the app is the result of agentic engineering, e.g. plans, specs, tasks, execution loops. I swear by Beads (https://github.com/steveyegge/beads) by Yegge and also make heavy use of Beads Viewer (https://news.ycombinator.com/item?id=46314423) and Destructive Command Guard (https://news.ycombinator.com/item?id=46835674) by Jeffrey Emanuel.

* I'm an AWS fan and have been impressed by Opus' ability to write good CFN. It still needs a bunch of guidance around distributed architecture but way better than last year.