72 agent skills synthesizing 17 years of software engineering discipline into a prescriptive methodology for solo developers.
bigpowers is not a random collection of best practices. It is a highly opinionated, chronological layer cake of ideas, combining classical software craftsmanship with modern AI-native architecture.
It provides a 6-phase lifecycle with hard gates, a 94% quality threshold, and a YAML cockpit (specs/state.yaml) that keeps both human and AI agents perfectly aligned across complex software projects. By enforcing strict boundaries and verifiable outcomes, it allows solo developers to orchestrate multi-agent workflows with predictable, high-quality results.
- Runtime: Node.js v14+
- Environment: Bash (required for all internal scripts)
- Tooling: jq (highly recommended for configuration)
- AI Tools: Claude Code, Gemini CLI, Cursor, or pi
# One-shot setup: downloads, syncs artifacts, and links skills
npx bigpowers
# Or install globally
npm install -g bigpowers
bigpowers# Update and re-sync your local skills
npm update -g bigpowers
bigpowersFor deep usage, integrate the generated skills directly into your favorite AI tool (Claude Code, Gemini CLI, Cursor). Use the provided MCP Server to expose skills dynamically:
node scripts/mcp-server.js- 72 Purpose-Built Skills: From
survey-contexttodevelop-tdd, each skill is a targeted tool for a specific phase of development. - Spec-Driven Cockpit: Uses
specs/state.yamlandrelease-plan.yamlto maintain state across agent sessions, preventing context drift. - Native IDE Support: Automatically generates configurations for Cursor (
.cursor/rules), Gemini CLI, and pi. - Model Context Protocol (MCP): Dynamic tool discovery and invocation via the included MCP server.
- Built-in Quality Gates: Strict verification standards (e.g., F.I.R.S.T tests, BCP accounting) enforced before any code is merged.
bigpowers is not a flat list of influences. It is a chronological layer cake — each wave of thinking builds on and resolves tensions from the previous one. No layer replaces the last; each addresses a problem the prior one created.
| Era | Source | Contribution | Tension Resolved |
|---|---|---|---|
| 2008 | Uncle Bob (Clean Code) | SRP, Boy Scout Rule, F.I.R.S.T. tests, intention-revealing names | — (foundation) |
| 2018 | Ousterhout (A Philosophy of Software Design) | Deep modules, information hiding, define errors out of existence | Small functions alone create shallow modules with bloated interfaces |
| 2023–24 | Karpathy, Superpowers, Pocock | Think-first planning, verb-noun skill architecture, zoom-out strategy | Raw LLMs have no discipline — they need orchestration, not raw prompting |
| 2024 | Wasowski (SDD), BCP | Specs as the human-agent interface; business complexity as a pre-build sizing unit | Agents drift without a verifiable spec — BDD Gherkin closes the loop |
| 2026 | Akita (Clean Code for AI Agents) | Grep-ability, structured JSON logging, token economy, remediation hints in errors | Uncle Bob's rules were written for humans — agents need different code hygiene |
| Synthesis | BMAD + GSD (self-authored) | 6-phase lifecycle, hard gates, 94% quality threshold, specs/state.yaml cockpit |
All the above are principles; bigpowers turns them into an executable discipline |
Each philosophical pillar has a corresponding Gherkin .feature file in specs/verifications/features/ that empirically proves compliance:
| Pillar | Verification |
|---|---|
| Classical Craftsmanship | cleancode.feature |
| Complexity Management | pocock.feature |
| Behavioral Integrity | karpathy.feature |
| Spec-Driven Development | Implicit in SDD workflow |
| Agentic Standard | akita.feature |
| Project Conventions | conventions.feature |
| Original Baseline | superpowers.feature |
Run npm run compliance to audit all features. Score < 94% = hard stop.
git clone https://github.com/danielvm-git/bigpowers.git
cd bigpowers
npm install
# Sync artifacts from SKILL.md sources
npm run sync# Run compliance verification against Gherkin features
npm run compliance
# Validate YAML specifications and doctrine
npm run doctrine
npm run validate-specs- Fork the repo.
- Create a feature branch (
git checkout -b feature/my-thing). - Make your changes using the
bigpowersmethodology. - Commit using Conventional Commits (
git commit -am 'feat: add my thing'). - Push to the branch (
git push origin feature/my-thing). - Open a Pull Request.
See CHANGELOG.md or Releases.
- Repository: https://github.com/danielvm-git/bigpowers
- Issue Tracker: https://github.com/danielvm-git/bigpowers/issues
This project is a synthesis of decades of software engineering thought. It would not be possible without the foundational work of the authors who wrote the inspirational articles and books that shaped this methodology:
- Robert C. Martin (Uncle Bob) for establishing the baseline of code hygiene and the F.I.R.S.T principles in Clean Code.
- John Ousterhout for his paradigm-shifting views on Deep Modules and complexity management in A Philosophy of Software Design.
- Andrej Karpathy and Matt Pocock for their pioneering work on agentic skills and structuring context for LLMs.
- Jarek Wasowski for identifying Spec-Driven Development (SDD) as the missing link for AI agents.
- AkitaOnRails for adapting classical clean code principles to the reality of the AI token economy.
MIT — see LICENSE for details.