ECC
The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
- 309k
- JavaScript
- MIT
- 2 d ago
Agent skills synthesizing years of software engineering discipline into a prescriptive methodology for solo developers
Repo danielvm-git/bigpowers, read from GitHub 21 h ago. danielvm-git has not joined Take My Repo.
danielvm-git/bigpowers is a public repo on GitHub by danielvm-git. Agent skills synthesizing years of software engineering discipline into a prescriptive methodology for solo developers. It declares the MIT license on GitHub. It is written mainly in Shell, has 293 stars and last changed on 2026-11-09. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-21.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
Agent skills synthesizing 17 years of software engineering discipline — from Clean Code to AI-native architecture — into a single, prescriptive methodology for solo developers.
bigpowers provides a prescriptive, vertical-slice methodology for building software with AI agents (Claude Code, Gemini CLI, Cursor, pi). It bridges the gap between raw LLM capabilities and professional engineering standards.
It is not a random collection of best practices. It is a chronological layer cake of ideas — each wave of thinking (Uncle Bob → Ousterhout → Karpathy → Wasowski → Akita) builds on and resolves tensions from the last, culminating in a 6-phase lifecycle with hard gates, a 94% quality threshold, and a YAML cockpit (specs/state.yaml) that keeps both human and agent aligned across sessions.
Published on npm: bigpowers. The skill count in the badge above is stamped automatically by sync-skills.sh; the canonical catalog is SKILL-INDEX.md.
Docs: bigpowers docs site — searchable, Google-discoverable reference for all skills, guides, and ADRs.
This methodology publishes its own evidence — see the live receipts page.
See it working: bigpowers-showcase — a real URL shortener (CLI + SQLite) built from scratch with the full spec trail committed from day one.
Every gate (compliance, the deterministic golden suite, skill verify, story verify) runs in
one pipeline; release and the Pages deploy start only after that pipeline succeeds on main.
| Layer | What it uses |
|---|---|
| Content | Markdown skills (skills/*/SKILL.md), YAML specs (specs/) |
| Tooling | Bash scripts, Node.js 22, Python 3 (YAML/JSON tooling) |
| Distribution | npm package, Agent Skills renders, MCP server |
| CI/CD | GitHub Actions — gates → release → Pages, one pipeline |
This README is a guided path, not a wall of reference. Start where you are:
| You want to… | Go to |
|---|---|
| Try it in 30 seconds | Quick Start |
| Understand what it actually does | Features and The v2.0.0 Lifecycle |
| Learn the ideas behind it | Philosophical Stack |
| Look something up | Hierarchy of Truth and Project Structure |
| Wire it into pi or MCP | pi Support and MCP Server |
| Contribute or hack on it | Development and Contributing |
After installing, ask your agent to run the using-bigpowers skill — it is the one-time bootstrap that explains the lifecycle and tells you which skill to call first for your situation.
# Global install (no lifecycle scripts — npm v10+ safe)
npm install -g bigpowers@latest
bigpowers setup # runs sync + install, links skills to your tools
# Or one-shot with npx (always fetches the newest release)
npx bigpowers@latest setup
Both commands sync skill artifacts and link them to Claude Code, Gemini CLI, and Cursor (see Prerequisites).
Always pin
@latest. With bigpowers already installed globally, a barenpx bigpowers setupreuses the stale global binary andnpm update -g bigpowersdoesn't reliably cross to the newest release.npm install -g bigpowers@latestandnpx bigpowers@latest setupforce a registry fetch every time.
The npx bigpowers setup command launches an interactive menu where you can:
Use arrow keys to navigate, space to select, and Enter to confirm.

Screenshot from an earlier release; the current installer may differ.
git clone https://github.com/danielvm-git/bigpowers.git && cd bigpowers
npm install
bash scripts/install.sh
survey-context to develop-tdd, each skill is a targeted tool for a specific phase of development. See SKILL-INDEX.md for the full auto-generated catalog.specs/state.yaml and release-plan.yaml to maintain state across agent sessions, preventing context drift..cursor/rules), Gemini CLI, and pi.Every project follows the orchestrate-project 6-phase model (full SOP: docs/WORKFLOW-SOP-v2.md):
ONE TIME seed-conventions (CLAUDE.md, .claude/, .gemini/, agents/, skill sync)
↓
ONCE/PROJECT orchestrate-project
│
├─ Ph1 DISCOVER survey-context, research-first, elaborate-spec
├─ Ph2 ELABORATE model-domain, grill-me, define-language, deepen-architecture
├─ Ph3 PLAN scope-work, slice-tasks, plan-work → release-plan.yaml (BCP baseline)
├─ Ph4 BUILD build-epic × N stories
│
│ Per story — 8-step build-epic cycle:
│ 1. survey-context ← stamps story_start in state.yaml
│ 2. plan-work ← [BCP N] tasks + verify: commands
│ 3. kickoff-branch ← worktree + feature branch
│ 4. develop-tdd ← RED → GREEN → REFACTOR
│ 5. verify-work ← UAT gate
│ 6. audit-code ← quality gate ≥ 94%
│ 7. commit-message ← Conventional Commits + semver
│ 8. release-branch ← land to main; writes story_end + cycle-times.yaml
│
├─ Ph5 VERIFY run-evals, verify-work (project-level)
└─ Ph6 RELEASE semantic-release → v1.0.0 MVP tag
Semver: projects start at 0.0.0-β; each feat: story → minor bump; developer declares MVP → 1.0.0.
BCP accounting: every task labeled [BCP N]; story total in state.yaml; BCP/hr logged to specs/metrics/cycle-times.yaml.
next_skill signaling: each critical-path skill writes handoff.next_skill to state.yaml. Call survey-context after any interruption to resume exactly where you left off.
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.
| Level | Document | Responsibility |
|---|---|---|
| Vision | docs/PRINCIPLES.md |
Philosophical foundations and evolution. |
| Context | specs/tech-architecture/TECH_STACK_LATEST.md |
Tech stack, architecture, and domain notes. |
| Scope | specs/product/SCOPE_LATEST.yaml |
In-scope / out-of-scope and success criteria. |
| Vision | specs/product/VISION_LATEST.yaml |
North star and initiative success criteria. |
| Decisions | specs/adr/ |
Architectural Decision Records (irreversible choices). |
| Roadmap | specs/release-plan.yaml + specs/epics/ |
WSJF-prioritized epics and stories with BCP baseline. |
| Current | specs/state.yaml |
Session flow, active epic, handoff.next_skill, timestamps. |
| Metrics | specs/metrics/cycle-times.yaml |
Per-story BCPs, cycle minutes, BCP/hr (v2.0.0). |
| Index | SKILL-INDEX.md |
Canonical list of all active skills (auto-generated). |
| Style | CONVENTIONS.md |
Coding, testing, and naming standards. |
skills/[skill-name]/: Source files for each of the 80 skills.scripts/: Installation, syncing, and compliance tools.specs/: YAML cockpit — state.yaml, release-plan.yaml, epics/, execution-status.yaml, requirements/.specs/metrics/: Cycle-time ledger (cycle-times.yaml) — per-story BCPs, timestamps, BCP/hr (v2.0.0).dashboard/: Live monitoring tool — TUI (npm run dashboard) and web (npm run dashboard:web, port 7742).docs/: Guides including WORKFLOW-SOP-v2.md (full SDLC SOP) and using-bigpowers.md.docs/references/: Theoretical foundations (Uncle Bob, Ousterhout, Karpathy, etc.).bigpowers generates pi Agent Skills and prompt templates alongside Cursor and Gemini artifacts via sync-skills.sh.
# Clone and sync to generate pi artifacts
cd bigpowers
bash scripts/sync-skills.sh
# Install from local path as a pi package
pi install .
# Or install as a pi npm package (once published with pi-package keyword)
pi install npm:bigpowers
bigpowers init)pi's package contract registers skills and prompts only — it has no resource
type for arbitrary project files, and no lifecycle script runs on install. Skills
reference the package's scripts/*.sh tooling project-relative (e.g.
bash scripts/run-skill-verify.sh, verify gates like test -f scripts/... && test -d specs/bugs), so after installing the package, run one command per
consumer project to provision what the skills expect:
cd <your-project>
npx bigpowers init # or: bigpowers init
This symlinks <project>/scripts → the installed package's scripts/ tree and
scaffolds specs/bugs/ + specs/verifications/. It refuses (never clobbers) a
scripts/ you already own; bigpowers init --remove undoes it. The same step
applies to npm i -g bigpowers / npx bigpowers setup consumers.
What you get:
.pi/skills/ (one per SKILL.md) — loaded automatically into pi's system prompt as <available_skills>.pi/prompts/ — slash commands like /survey-context, /plan-work.pi/package.json — enables pi install with auto-discoverySkills are loaded on-demand via progressive disclosure: only descriptions are always in context; the full SKILL.md loads when the agent reads it. Prompt templates expand in pi's editor with autocomplete.
bigpowers includes an MCP server (scripts/mcp-server.js) that exposes the skill catalog as callable MCP tools, so agents can discover and invoke skills dynamically instead of relying on a static system prompt. It is not active until you register it with your agent — see below.
node scripts/mcp-server.js
claude mcp add bigpowers node /path/to/bigpowers/scripts/mcp-server.js
Or add manually to .claude/settings.json:
{
"mcpServers": {
"bigpowers": {
"command": "node",
"args": ["/path/to/bigpowers/scripts/mcp-server.js"]
}
}
}
| Tool | Description |
|---|---|
bigpowers_list_skills |
List all skills with name, description, phase. Optional phase filter. |
bigpowers_get_skill |
Get full SKILL.md content for any skill by name. |
bigpowers_search_skills |
Keyword/semantic search — returns ranked matches for a query. |
bigpowers_get_state |
Get current specs/state.yaml (active flow, epic, step). |
bigpowers_invoke_skill |
Get skill instructions with optional context for agent invocation. |
npm install:
bigpowers update # fetches bigpowers@latest (global installs), then re-syncs + refreshes symlinks
bigpowers update now runs npm install -g bigpowers@latest for you when bigpowers is installed globally, so running it alone is enough to reach the newest release. Prefer to do it by hand? npm install -g bigpowers@latest && bigpowers update. (Avoid npm update -g bigpowers — it does not reliably cross to @latest.)
git clone:
git pull
npm run sync
bash scripts/install.sh
pi package (installed via ~/.pi/agent/settings.json → packages):
pi update --extensions # refresh installed pi packages, including bigpowers
Install uses symlinks — re-running setup refreshes links without duplicating files.
npm install:
bash "$(npm root -g)/bigpowers/scripts/install.sh" --uninstall
npm uninstall -g bigpowers
git clone:
bash scripts/install.sh --uninstall
npx bigpowers@latest setup
# or, if installed globally:
bigpowers update
git clone https://github.com/danielvm-git/bigpowers.git
cd bigpowers
npm install
# Sync artifacts from SKILL.md sources
npm run sync
One command runs every gate before you push — compliance, the deterministic golden suite, skill sync, and the strict traceability check:
npm run compliance \
&& bash scripts/run-verification-gates.sh \
&& bash scripts/sync-skills.sh \
&& bash scripts/trace-stories.sh --strict
Preflight is the gate, not a suggestion: a red Preflight means forward work stops
until it is green or the defect is logged (see CONVENTIONS.md § Always Green).
# Run compliance verification against Gherkin features
npm run compliance
# Validate YAML specifications and doctrine
npm run doctrine
npm run validate-specs
git checkout -b feature/my-thing).bigpowers methodology.git commit -am 'feat: add my thing').git push origin feature/my-thing).See CHANGELOG.md for the auto-generated commit history, or Releases for GitHub release notes.
For an executive narrative of the project's history — 98 releases across 41 days, 4 phases, 19 epics delivered — read RELEASE-HISTORY.md.
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:
bigpowers has been shaped by contributors who extended it in their own forks. See CONTRIBUTORS.md for the full list.
project-runtime.sh configurable settings library.extensions/omp-hooks.ts): native skill discovery, unified skill tooling, and git-safety hooks for the oh-my-pi runtime.This project is licensed under the MIT License - see the LICENSE file for details.
“Simplicity is the ultimate sophistication, but integrity is the ultimate requirement.”
danielvm-git/bigpowers is a public repo on GitHub by danielvm-git. Agent skills synthesizing years of software engineering discipline into a prescriptive methodology for solo developers.
It declares the MIT license on GitHub.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-11-09. GitHub counts 10 open issues and pull requests. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
Fair-code workflow automation platform with native AI capabilities. Combine visual building with custom code, self-host or cloud, 400+ integrations.

Reverse engineer anything with agents, from app behavior down to native binaries.
Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
jackob's binance-trading-robot running on Google Cloud Platform
Infrastructure validation web application with secure OAuth-based collaboration
A local-first URL shortener. Shorten URLs, manage links, resolve short codes, and serve redirects — all from your terminal, all stored in SQLite on your machine.
Toolchain bootstrapper + thin unifier for AI-assisted coding. One-command install (mise), bts shell dispatcher, bts-map (tree-sitter PageRank repo map).
BigBase is an open-source Backend-as-a-Service platform designed for speed, portability, and modularity. It packs Auth, Database, Storage, Functions, Messaging, and Git Repos into a single Go binary that runs anywhere—from your local machine to a VPS—with zero external dependencies. Built on the Entity-Component-Construct (ECC) pattern
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/danielvm-git/bigpowersTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.