Skip to content
Back to search

bigpowers

Agent skills synthesizing years of software engineering discipline into a prescriptive methodology for solo developers

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/danielvm-git--bigpowers/badge.svg)](/listings/danielvm-git--bigpowers)

HTML

<a href="/listings/danielvm-git--bigpowers"><img src="/api/listings/danielvm-git--bigpowers/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

npm (recommended)

# 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](#-prerequisites)).

> **Always pin `@latest`.** With bigpowers already installed globally, a bare `npx bigpowers setup` reuses the stale global binary and `npm update -g bigpowers` doesn't reliably cross to the newest release. `npm install -g bigpowers@latest` and `npx bigpowers@latest setup` force a registry fetch every time.

Interactive Installer

The `npx bigpowers setup` command launches an interactive menu where you can:

1. **Choose install mode**: Setup/Update or Uninstall 2. **Select location**: Global (available everywhere) or Local (current project only) 3. **Pick tools**: Select which AI tools to install skills for (Claude Code, Cursor, Gemini, pi, etc.) 4. **Confirm**: Review and confirm the installation

Use **arrow keys** to navigate, **space** to select, and **Enter** to confirm.

From source (contributors)

git clone https://github.com/danielvm-git/bigpowers.git && cd bigpowers
npm install
bash scripts/install.sh

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 443 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # bigpowers — Best-in-Class Agentic Skills
  2. [![Test Build Release](https://github.com/danielvm-git/bigpowers/actions/workflows/test-build-release.yml/badge.svg)](https://github.com/danielvm-git/bigpowers/actions/workflows/test-build-release.yml)
  3. ![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)
  4. ![npm version](https://img.shields.io/npm/v/bigpowers.svg)
  5. ![Skills](https://img.shields.io/badge/skills-80-brightgreen.svg)
  6. **Agent skills synthesizing 17 years of software engineering discipline — from Clean Code to AI-native architecture — into a single, prescriptive methodology for solo developers.**
  7. `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.
  8. 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.
  9. Published on npm: [bigpowers](https://www.npmjs.com/package/bigpowers). The skill count in the badge above is stamped automatically by `sync-skills.sh`; the canonical catalog is [`SKILL-INDEX.md`](SKILL-INDEX.md).
  10. Docs: [bigpowers docs site](https://danielvm-git.github.io/bigpowers/) — searchable, Google-discoverable reference for all skills, guides, and ADRs.
  11. **This methodology publishes its own evidence — see the [live receipts page](https://danielvm-git.github.io/bigpowers/receipts/).**
  12. **See it working:** [bigpowers-showcase](https://github.com/danielvm-git/bigpowers-showcase) — a real URL shortener (CLI + SQLite) built from scratch with the full spec trail committed from day one.
  13. ---
  14. ## Build status
  15. [![Test Build Release](https://github.com/danielvm-git/bigpowers/actions/workflows/test-build-release.yml/badge.svg)](https://github.com/danielvm-git/bigpowers/actions/workflows/test-build-release.yml)
  16. Every gate (compliance, the deterministic golden suite, skill verify, story verify) runs in
  17. one pipeline; release and the Pages deploy start only after that pipeline succeeds on `main`.
  18. ## Tech stack
  19. | Layer | What it uses |
  20. |---|---|
  21. | Content | Markdown skills (`skills/*/SKILL.md`), YAML specs (`specs/`) |
  22. | Tooling | Bash scripts, Node.js 22, Python 3 (YAML/JSON tooling) |
  23. | Distribution | npm package, Agent Skills renders, MCP server |
  24. | CI/CD | GitHub Actions — gates → release → Pages, one pipeline |
  25. ## 🗺 How to Read This README
  26. This README is a guided path, not a wall of reference. Start where you are:
  27. | You want to… | Go to |
  28. |:---|:---|
  29. | Try it in 30 seconds | [Quick Start](#-quick-start) |
  30. | Understand what it actually does | [Features](#-features) and [The v2.0.0 Lifecycle](#-the-v200-lifecycle) |
  31. | Learn the ideas behind it | [Philosophical Stack](#-philosophical-stack--how-these-ideas-concatenate) |
  32. | Look something up | [Hierarchy of Truth](#-hierarchy-of-truth) and [Project Structure](#-project-structure) |
  33. | Wire it into pi or MCP | [pi Support](#-pi-support) and [MCP Server](#-mcp-server-model-context-protocol) |
  34. | Contribute or hack on it | [Development](#-development) and [Contributing](#-contributing) |
  35. 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.
  36. ---
  37. ## 🚀 Quick Start
  38. ### npm (recommended)
  39. ```bash
  40. # Global install (no lifecycle scripts — npm v10+ safe)
  41. npm install -g bigpowers@latest
  42. bigpowers setup # runs sync + install, links skills to your tools
  43. # Or one-shot with npx (always fetches the newest release)
  44. npx bigpowers@latest setup
  45. ```
  46. Both commands sync skill artifacts and link them to Claude Code, Gemini CLI, and Cursor (see [Prerequisites](#-prerequisites)).
  47. > **Always pin `@latest`.** With bigpowers already installed globally, a bare `npx bigpowers setup` reuses the stale global binary and `npm update -g bigpowers` doesn't reliably cross to the newest release. `npm install -g bigpowers@latest` and `npx bigpowers@latest setup` force a registry fetch every time.
  48. ### Interactive Installer
  49. The `npx bigpowers setup` command launches an interactive menu where you can:
  50. 1. **Choose install mode**: Setup/Update or Uninstall
  51. 2. **Select location**: Global (available everywhere) or Local (current project only)
  52. 3. **Pick tools**: Select which AI tools to install skills for (Claude Code, Cursor, Gemini, pi, etc.)
  53. 4. **Confirm**: Review and confirm the installation
  54. Use **arrow keys** to navigate, **space** to select, and **Enter** to confirm.
  55. ![Interactive Installer](docs/images/interactive-installer.png)
  56. *Screenshot from an earlier release; the current installer may differ.*
  57. ### From source (contributors)
  58. ```bash
  59. git clone https://github.com/danielvm-git/bigpowers.git && cd bigpowers
  60. npm install
  61. bash scripts/install.sh
  62. ```
  63. ---
  64. ## 🛠 Prerequisites
  65. - **Bash**: Required for all scripts.
  66. - **Node.js**: v14+ (required for npm/npx).
  67. - **jq**: (Highly Recommended) Used for robust configuration of tool settings.
  68. - **AI Tools**: One or more of:
  69. - [Claude Code](https://claude.ai/code)
  70. - [Gemini CLI](https://github.com/google/gemini-cli)
  71. - [Cursor](https://cursor.sh/)
  72. - [pi](https://pi.dev/) — coding agent harness
  73. ---
  74. ## ✨ Features
  75. - **Purpose-Built Skills**: From `survey-context` to `develop-tdd`, each skill is a targeted tool for a specific phase of development. See [`SKILL-INDEX.md`](SKILL-INDEX.md) for the full auto-generated catalog.
  76. - **Spec-Driven Cockpit**: Uses `specs/state.yaml` and `release-plan.yaml` to maintain state across agent sessions, preventing context drift.
  77. - **Native IDE Support**: Automatically generates configurations for Cursor (`.cursor/rules`), Gemini CLI, and pi.
  78. - **Model Context Protocol (MCP)**: Dynamic tool discovery and invocation via the included MCP server.
  79. - **Built-in Quality Gates**: Strict verification standards (e.g., F.I.R.S.T tests, BCP accounting) enforced before any code is merged.
  80. ---
  81. ## 🏗 The v2.0.0 Lifecycle
  82. Every project follows the **orchestrate-project 6-phase model** (full SOP: [`docs/WORKFLOW-SOP-v2.md`](docs/WORKFLOW-SOP-v2.md)):
  83. ```
  84. ONE TIME seed-conventions (CLAUDE.md, .claude/, .gemini/, agents/, skill sync)
  85. ↓
  86. ONCE/PROJECT orchestrate-project
  87. │
  88. ├─ Ph1 DISCOVER survey-context, research-first, elaborate-spec
  89. ├─ Ph2 ELABORATE model-domain, grill-me, define-language, deepen-architecture
  90. ├─ Ph3 PLAN scope-work, slice-tasks, plan-work → release-plan.yaml (BCP baseline)
  91. ├─ Ph4 BUILD build-epic × N stories
  92. │
  93. │ Per story — 8-step build-epic cycle:
  94. │ 1. survey-context ← stamps story_start in state.yaml
  95. │ 2. plan-work ← [BCP N] tasks + verify: commands
  96. │ 3. kickoff-branch ← worktree + feature branch
  97. │ 4. develop-tdd ← RED → GREEN → REFACTOR
  98. │ 5. verify-work ← UAT gate
  99. │ 6. audit-code ← quality gate ≥ 94%
  100. │ 7. commit-message ← Conventional Commits + semver
  101. │ 8. release-branch ← land to main; writes story_end + cycle-times.yaml
  102. │
  103. ├─ Ph5 VERIFY run-evals, verify-work (project-level)
  104. └─ Ph6 RELEASE semantic-release → v1.0.0 MVP tag
  105. ```
  106. **Semver:** projects start at `0.0.0-β`; each `feat:` story → minor bump; developer declares MVP → `1.0.0`.
  107. **BCP accounting:** every task labeled `[BCP N]`; story total in `state.yaml`; BCP/hr logged to `specs/metrics/cycle-times.yaml`.
  108. **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.
  109. ---
  110. ## 🧠 Philosophical Stack — How These Ideas Concatenate
  111. `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.
  112. ![Philosophy Diagram](docs/images/philosophy_diagram.jpg)
  113. | Era | Source | Contribution | Tension Resolved |
  114. |:---|:---|:---|:---|
  115. | **2008** | [Uncle Bob](https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) (Clean Code) | SRP, Boy Scout Rule, F.I.R.S.T. tests, intention-revealing names | — (foundation) |
  116. | **2018** | [Ousterhout](https://www.amazon.com/Philosophy-Software-Design-John-Ousterhout/dp/1732102201) (*A Philosophy of Software Design*) | Deep modules, information hiding, define errors out of existence | Small functions alone create shallow modules with bloated interfaces |
  117. | **2023–24** | [Karpathy](https://github.com/multica-ai/andrej-karpathy-skills), [Superpowers](https://github.com/obra/superpowers), [Pocock](https://github.com/mattpocock/skills) | Think-first planning, verb-noun skill architecture, zoom-out strategy | Raw LLMs have no discipline — they need orchestration, not raw prompting |
  118. | **2024** | [Wasowski](https://medium.com/@wasowski.jarek/sdd-writing-specifications-for-ai-bdd-as-the-missing-link-spec-driven-development-ad1b540b7f75) (SDD), [BCP](https://github.com/flow-ciandt/bcp-agent) | 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 |
  119. | **2026** | [Akita](https://akitaonrails.com/2026/04/20/clean-code-para-agentes-de-ia/) (*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 |
  120. | **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 |
  121. ### How to see the concatenation in action
  122. Each philosophical pillar has a corresponding Gherkin `.feature` file in [`specs/verifications/features/`](specs/verifications/features/) that empirically proves compliance:
  123. | Pillar | Verification |
  124. |:---|:---|
  125. | Classical Craftsmanship | `cleancode.feature` |
  126. | Complexity Management | `pocock.feature` |
  127. | Behavioral Integrity | `karpathy.feature` |
  128. | Spec-Driven Development | Implicit in SDD workflow |
  129. | Agentic Standard | `akita.feature` |
  130. | Project Conventions | `conventions.feature` |
  131. | Original Baseline | `superpowers.feature` |
  132. Run `npm run compliance` to audit all features. Score < 94% = hard stop.
  133. ---
  134. ## 📖 Hierarchy of Truth
  135. | Level | Document | Responsibility |
  136. | :--- | :--- | :--- |
  137. | **Vision** | `docs/PRINCIPLES.md` | Philosophical foundations and evolution. |
  138. | **Context** | `specs/tech-architecture/TECH_STACK_LATEST.md` | Tech stack, architecture, and domain notes. |
  139. | **Scope** | `specs/product/SCOPE_LATEST.yaml` | In-scope / out-of-scope and success criteria. |
  140. | **Vision** | `specs/product/VISION_LATEST.yaml` | North star and initiative success criteria. |
  141. | **Decisions** | `specs/adr/` | Architectural Decision Records (irreversible choices). |
  142. | **Roadmap** | `specs/release-plan.yaml` + `specs/epics/` | WSJF-prioritized epics and stories with BCP baseline. |
  143. | **Current** | `specs/state.yaml` | Session flow, active epic, `handoff.next_skill`, timestamps. |
  144. | **Metrics** | `specs/metrics/cycle-times.yaml` | Per-story BCPs, cycle minutes, BCP/hr (v2.0.0). |
  145. | **Index** | `SKILL-INDEX.md` | Canonical list of all active skills (auto-generated). |
  146. | **Style** | `CONVENTIONS.md` | Coding, testing, and naming standards. |
  147. ---
  148. ## 📁 Project Structure
  149. - `skills/[skill-name]/`: Source files for each of the 80 skills.
  150. - `scripts/`: Installation, syncing, and compliance tools.
  151. - `specs/`: YAML cockpit — `state.yaml`, `release-plan.yaml`, `epics/`, `execution-status.yaml`, `requirements/`.
  152. - `specs/metrics/`: Cycle-time ledger (`cycle-times.yaml`) — per-story BCPs, timestamps, BCP/hr (v2.0.0).
  153. - `dashboard/`: Live monitoring tool — TUI (`npm run dashboard`) and web (`npm run dashboard:web`, port 7742).
  154. - `docs/`: Guides including `WORKFLOW-SOP-v2.md` (full SDLC SOP) and `using-bigpowers.md`.
  155. - `docs/references/`: Theoretical foundations (Uncle Bob, Ousterhout, Karpathy, etc.).
  156. ---
  157. ## 🔌 pi Support
  158. bigpowers generates pi Agent Skills and prompt templates alongside Cursor and Gemini artifacts via `sync-skills.sh`.
  159. ### Install as a pi package
  160. ```bash
  161. # Clone and sync to generate pi artifacts
  162. cd bigpowers
  163. bash scripts/sync-skills.sh
  164. # Install from local path as a pi package
  165. pi install .
  166. # Or install as a pi npm package (once published with pi-package keyword)
  167. pi install npm:bigpowers
  168. ```
  169. ### Provision a consumer project (`bigpowers init`)
  170. pi's package contract registers **skills and prompts only** — it has no resource
  171. type for arbitrary project files, and no lifecycle script runs on install. Skills
  172. reference the package's `scripts/*.sh` tooling project-relative (e.g.
  173. `bash scripts/run-skill-verify.sh`, verify gates like `test -f scripts/... &&
  174. test -d specs/bugs`), so after installing the package, run **one command per
  175. consumer project** to provision what the skills expect:
  176. ```bash
  177. cd <your-project>
  178. npx bigpowers init # or: bigpowers init
  179. ```
  180. This symlinks `<project>/scripts` → the installed package's `scripts/` tree and
  181. scaffolds `specs/bugs/` + `specs/verifications/`. It refuses (never clobbers) a
  182. `scripts/` you already own; `bigpowers init --remove` undoes it. The same step
  183. applies to `npm i -g bigpowers` / `npx bigpowers setup` consumers.
  184. **What you get:**
  185. - **pi skills** in `.pi/skills/` (one per SKILL.md) — loaded automatically into pi's system prompt as `<available_skills>`
  186. - **pi prompt templates** in `.pi/prompts/` — slash commands like `/survey-context`, `/plan-work`
  187. - **pi package manifest** in `.pi/package.json` — enables `pi install` with auto-discovery
  188. Skills 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.
  189. ## 🔧 MCP Server (Model Context Protocol)
  190. 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.
  191. ### Start the server
  192. ```bash
  193. node scripts/mcp-server.js
  194. ```
  195. ### Add to Claude Code
  196. ```bash
  197. claude mcp add bigpowers node /path/to/bigpowers/scripts/mcp-server.js
  198. ```
  199. Or add manually to `.claude/settings.json`:
  200. ```json
  201. {
  202. "mcpServers": {
  203. "bigpowers": {
  204. "command": "node",
  205. "args": ["/path/to/bigpowers/scripts/mcp-server.js"]
  206. }
  207. }
  208. }
  209. ```
  210. ### Available MCP tools
  211. | Tool | Description |
  212. |------|-------------|
  213. | `bigpowers_list_skills` | List all skills with name, description, phase. Optional `phase` filter. |
  214. | `bigpowers_get_skill` | Get full SKILL.md content for any skill by name. |
  215. | `bigpowers_search_skills` | Keyword/semantic search — returns ranked matches for a query. |
  216. | `bigpowers_get_state` | Get current `specs/state.yaml` (active flow, epic, step). |
  217. | `bigpowers_invoke_skill` | Get skill instructions with optional context for agent invocation. |
  218. ---
  219. ## 🔄 Maintenance (Update & Uninstall)
  220. ### Update
  221. **npm install:**
  222. ```bash
  223. bigpowers update # fetches bigpowers@latest (global installs), then re-syncs + refreshes symlinks
  224. ```
  225. `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`.)
  226. **git clone:**
  227. ```bash
  228. git pull
  229. npm run sync
  230. bash scripts/install.sh
  231. ```
  232. **pi package** (installed via `~/.pi/agent/settings.json` → `packages`):
  233. ```bash
  234. pi update --extensions # refresh installed pi packages, including bigpowers
  235. ```
  236. *Install uses symlinks — re-running setup refreshes links without duplicating files.*
  237. ### Uninstall
  238. **npm install:**
  239. ```bash
  240. bash "$(npm root -g)/bigpowers/scripts/install.sh" --uninstall
  241. npm uninstall -g bigpowers
  242. ```
  243. **git clone:**
  244. ```bash
  245. bash scripts/install.sh --uninstall
  246. ```
  247. ### Reinstall
  248. ```bash
  249. npx bigpowers@latest setup
  250. # or, if installed globally:
  251. bigpowers update
  252. ```
  253. ---
  254. ## 🧪 Development
  255. ```bash
  256. git clone https://github.com/danielvm-git/bigpowers.git
  257. cd bigpowers
  258. npm install
  259. # Sync artifacts from SKILL.md sources
  260. npm run sync
  261. ```
  262. ### Preflight
  263. One command runs every gate before you push — compliance, the deterministic golden
  264. suite, skill sync, and the strict traceability check:
  265. ```bash
  266. npm run compliance \
  267. && bash scripts/run-verification-gates.sh \
  268. && bash scripts/sync-skills.sh \
  269. && bash scripts/trace-stories.sh --strict
  270. ```
  271. Preflight is the gate, not a suggestion: a red Preflight means forward work stops
  272. until it is green or the defect is logged (see `CONVENTIONS.md` § Always Green).
  273. ### Tests
  274. ```bash
  275. # Run compliance verification against Gherkin features
  276. npm run compliance
  277. # Validate YAML specifications and doctrine
  278. npm run doctrine
  279. npm run validate-specs
  280. ```
  281. ---
  282. ## 🤝 Contributing
  283. 1. Fork the repo.
  284. 2. Create a feature branch (`git checkout -b feature/my-thing`).
  285. 3. Make your changes using the `bigpowers` methodology.
  286. 4. Commit using Conventional Commits (`git commit -am 'feat: add my thing'`).
  287. 5. Push to the branch (`git push origin feature/my-thing`).
  288. 6. Open a Pull Request.
  289. ### Changelog
  290. See [CHANGELOG.md](CHANGELOG.md) for the auto-generated commit history, or [Releases](https://github.com/danielvm-git/bigpowers/releases) for GitHub release notes.
  291. For an executive narrative of the project's history — 98 releases across 41 days, 4 phases, 19 epics delivered — read [RELEASE-HISTORY.md](docs/RELEASE-HISTORY.md).
  292. ### Links
  293. - **Repository**: https://github.com/danielvm-git/bigpowers
  294. - **Issue Tracker**: https://github.com/danielvm-git/bigpowers/issues
  295. ---
  296. ## 🙏 Acknowledgements
  297. 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:
  298. - **Robert C. Martin (Uncle Bob)** for establishing the baseline of code hygiene and the F.I.R.S.T principles in *Clean Code*.
  299. - **John Ousterhout** for his paradigm-shifting views on Deep Modules and complexity management in *A Philosophy of Software Design*.
  300. - **Andrej Karpathy** and **Matt Pocock** for their pioneering work on agentic skills and structuring context for LLMs.
  301. - **Jarek Wasowski** for identifying Spec-Driven Development (SDD) as the missing link for AI agents.
  302. - **AkitaOnRails** for adapting classical clean code principles to the reality of the AI token economy.
  303. ### Community Contributors
  304. bigpowers has been shaped by contributors who extended it in their own forks.
  305. See [CONTRIBUTORS.md](CONTRIBUTORS.md) for the full list.
  306. - **[Kevin Oberlies (favilo)](https://github.com/favilo/bigpowers)** — Jujutsu VCS support across lifecycle skills + `project-runtime.sh` configurable settings library.
  307. - **[XcluEzy7](https://github.com/XcluEzy7/bigpowers)** — OMP plugin extension (`extensions/omp-hooks.ts`): native skill discovery, unified skill tooling, and git-safety hooks for the oh-my-pi runtime.
  308. ---
  309. ## 📄 License
  310. This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
  311. ---
  312. *“Simplicity is the ultimate sophistication, but integrity is the ultimate requirement.”*

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.