SkillFoxx

bigpowers skill

bigpowers gives an agent 80 skills with a six-phase development cycle, quality gates and specs kept in a specs folder

  • 292 ★ on the repository
  • Last commit
  • MIT
Skill

Extended access

Why this level

  • The installer writes skills and configurations into the Claude Code, Gemini CLI and Cursor directories, globally or per project
  • The skills run git: they create branches and worktrees, prepare commits and merge branches into main under the cycle rules
All reasons and checks

danielvm-git/bigpowersAuthor:danielvm-git

Install

In your terminal, with SkillFoxx CLI

npx skillfoxx add skills/bigpowers

Detects the agents on your machine, shows the access level and pins the version.

Other ways to install

Access and checks

How we review

Extended accessThe tool runs code or makes network calls and only reads external data.

  • The installer writes skills and configurations into the Claude Code, Gemini CLI and Cursor directories, globally or per project
  • The skills run git: they create branches and worktrees, prepare commits and merge branches into main under the cycle rules

This is third-party code. Review the repository files before installing.

What it does

bigpowers is a set of 80 skills that gives Claude Code, Gemini CLI, Cursor and pi a development method for solo developers. It installs from npm with `npx bigpowers@latest setup`: an interactive installer asks whether to install globally or into the current project and for which tools to link the skills. A project moves through six phases under the orchestrate-project skill: discovery, domain elaboration, planning, building epics, verification and release. Each story is built in an eight-step cycle: context survey, task plan, a worktree branch, TDD development, acceptance, a code audit with a 94 percent quality threshold, a Conventional Commits message and a merge to main. State lives in `specs/state.yaml` and the plan in `specs/release-plan.yaml`, so after a break the agent resumes from the right skill. The entry skill using-bigpowers explains the cycle and says which skill to call first. The package also includes an MCP server for finding and calling skills, pi support, a monitoring dashboard (terminal and web on port 7742) and generated Cursor configurations.

Who it is for. Solo developers who build a project with an agent from idea to release and want the process held by specs and checks rather than by chat memory.

Good fit when

  • A project starts from scratch and orchestrate-project leads from discovery and planning to the v1.0.0 release
  • The agent loses the thread between sessions: `specs/state.yaml` keeps the next skill and `survey-context` returns to the right step
  • Development follows TDD with mandatory acceptance, and an audit result below 94 percent blocks the merge
  • Work spans several tools: Claude Code, Gemini CLI and Cursor get one skill set in one command
  • You want cycle metrics: `specs/metrics/cycle-times.yaml` logs how much complexity (BCP) was closed per hour

Not a fit when

  • The change takes five minutes: an eight-step cycle and quality gates are overkill
  • A team with its own process works on the project: the method is written for solo developers
  • Project documentation must stay outside `specs/`: the method writes all output into that folder at the project root
  • The environment has no Bash: the install and sync scripts are written in it

Example request

Run the using-bigpowers skill and tell me which skill to start a new project with: a small Node.js CLI that shortens links.

Limitations

  • Bash and Node.js 14 or newer are required, and jq is recommended for configuring tool settings.
  • The `@latest` suffix is mandatory: a bare `npx bigpowers setup` picks up a stale global binary.
  • The method is prescriptive: the phases and the quality gates with a 94 percent threshold cannot be skipped without editing the skills themselves.
  • The kit writes to `specs/` and generates tool configurations such as `.cursor/rules`, so new directories appear in the project repository.

How to disable. The interactive installer `npx bigpowers@latest setup` offers an Uninstall mode that removes the skills from the chosen tools. Files in the project's `specs/` stay and are deleted by hand.

FAQ

How do I install bigpowers in Claude Code?

Run `npx bigpowers@latest setup`, choose global or local install and tick Claude Code. The `@latest` suffix is mandatory: without it npx may take a stale global copy.

Where do I start after installing?

Ask the agent to run the using-bigpowers skill. It explains the cycle once and names the first skill for your situation.

What is BCP in tasks?

BCP is a unit of business complexity. Each task gets a label like [BCP N], the story total lands in `specs/state.yaml` and BCP per hour is logged in `specs/metrics/cycle-times.yaml`.

Which agents does bigpowers work with?

The installer links the skills to Claude Code, Gemini CLI and Cursor, and pi has separate support. Rules for Cursor are generated automatically in `.cursor/rules`.

Does bigpowers have an MCP server?

Yes. The package includes an MCP server for finding and calling skills dynamically, kept in the `bigpowers-mcp` directory.

Discussion

No questions or reviews yet.

Skills
Editors’ pick

A skills library that gives coding agents a development process: brainstorming, planning, TDD, subagents and code review

PluginExtended access316.7K

A skill that interviews you and writes requirements.md, design.md and tasks.md so Claude Code and Cursor work from one plan

SkillExtended access158

A Chinese edition of the superpowers skill set: translated development methods plus a few original skills, installed with one command across many agents

PluginExtended access8.5K

A mirror of Lauren Tan's pstack set from Cursor: over 50 skills, the poteto-mode with 23 playbooks and 24 principles for strict agent work on code

SkillBroad access4.1K
Russian stack

Orchestrator skill: from an idea the agent writes requirements and a spec, splits work into tasks, builds the project, checks it

SkillBroad access611

README in short

The README works as a guide: quick start, requirements, features, the six cycle phases and a philosophy stack from Clean Code to Akita's 2026 notes. Then come the project document hierarchy, repository structure, pi support and the MCP server, development of the kit and links to a live page of compliance receipts.

README badge

Original SKILL.md

---
name: using-bigpowers
model: sonnet
effort: standard
description: One-time bootstrap that introduces the bigpowers skills system, the PMBOK lifecycle arc, and tells you which skill to call first for your situation. Use when starting with bigpowers for the first time, when user asks "where do I start?", or when the skills system needs to be explained.
---

# Using bigpowers
> **HARD GATE** — **HARD GATE** — This skill is the entry point. Do NOT skip it when onboarding new users or starting a new session. It establishes the bigpowers methodology, lifecycle phases, and conventions.


Welcome to **bigpowers** — a lifecycle of agent skills for production-ready, TDD-driven software by solo developers. The live catalog and its count are generated in [`SKILL-INDEX.md`](../../SKILL-INDEX.md); never hardcode the number here.

## Install

```bash
npx bigpowers setup           # one-shot setup
npm install -g bigpowers       # global install
bigpowers setup                # sync skills + link to your tools
```

From source: `git clone` → `bash scripts/install.sh`. Package: [bigpowers on npm](https://www.npmjs.com/package/bigpowers).

**Reach tools:** **Cline** — native AGENTS.md reader (no extension). **Aider** — opt-in `.aider.conf.yml` with `read: AGENTS.md` ([Aider-AI/aider](https://github.com/Aider-AI/aider)). **Codex CLI** — optional `.codex/config.toml` via seed-conventions; global `~/.codex/AGENTS.md` from install.sh.

## What bigpowers is

A curated set of skills organized around the PMBOK developer lifecycle. Each skill does one thing. Skills reference each other by name only — low coupling, high cohesion. All written output goes to `specs/` at your project root.

## The lifecycle at a glance

See orchestrate-project for the canonical 6-phase lifecycle.

```
BOOTSTRAP   using-bigpowers (this skill, first time only)
              ↓
DISCOVER    survey-context → research-first → elaborate-spec
              ↓
DESIGN      model-domain / define-language / grill-me / deepen-architecture / design-interface
              ↓
PLAN        scope-work → slice-tasks → plan-work / plan-refactor
              ↓
INITIATE    kickoff-branch → guard-git / hook-commits / seed-conventions
              ↓
SPIKE?      spike-prototype → (feeds back to plan-work)

Report a problem